python3 day02 大纲

一. 格式化输出
    %s 字符串的占位
    %d 数字的占位 digit
    %f 浮点数

    字符串 % (数据)

    模板字符串(3.5)

# username = "admin"
# password = "123456"
'''正常输出'''
# print("管理系统的账号是:", username, "密码是:", password)

'''格式化输出方式一: %s代表字符串(string)占位 %d代表数字(digit)占位, %f代表浮点数(float)占位'''
# print("管理系统的账号是: %s 密码是: %s" % (username, password))

'''格式化输出方式二'''
# print("管理系统的账号是: {} 密码是: {}".format(username, password))

'''格式化输出方式三(3.5以上版本)'''
# print(f"管理消停的账号是: {username} 密码是: {password}")

二. 运算符
    算数运算
        + - * / // %
    比较运算
        > < >=  <=  ==  !=
    成员运算
        in  是否在xxx里面
        not in  是否不在xxx里面

    逻辑运算(重点)
        1. and   并且, 左右两端同时为真, 结果才能是真.
        2. or     或者, 左右两端有一个是真, 结果就是真
        3. not    非, 非真即假, 非假即真
        运算顺序:  ()  > not > and > or

            a or b
            if a == 0:  b   else a
            and和or相反

    赋值扩展运算
        =  赋值, 把等号右边的结果赋值给等号左边的变量
        +=
        -=
        *=
        /=
        //=
        %=

        a+=b   =>  a = a + b

'''
判断某人的留言当中是否包含波多野结衣
'''
# msg = input("请输入您的留言: ").strip()
# if "波多野结衣" in msg:
#     print("留言内容含有敏感关键字,留言失败!")
# else:
#     print("恭喜您,留言成功!")

'''
逻辑运算
'''
# print(1 > 2 and 4 < 6 and 5 > 7)
# print(1 < 2 and 3 < 4 or 1 > 2)
# print(2 > 1 and 3 < 4 or 4 > 5 and 2 < 1)
# print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8)
# print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)
# print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)

'''
or
'''
# print(1 or 2)
# print(0 or 1)
# print(1 or 0)
# print(0 or 3)
# print(2 and 3)
# print(1 or 2 and 3)
# print(0 or 3 or 5 or 1 or 0 or 4 or 7)

'''
and和or 取值相反
'''
# print(1 and 0)
# print(0 and 3)
# print(3 and 4)
# print(4 and 0)
# print(1 and 2 and 0 and 3 and 4)
# print(0 and 1 or 2 and 0 or 1 or 2 and 3)

# print(1 and 2 or 3)
# print(1 and 5 or 3 and 4 or 7 or 8 and 6 or 2)
# print(1 and 5 < 3 or 6)
# print(1 or 0 and 5 < 6 and 7 > 8 or 3)

三. 编码(记结论)
    ascii: 英文+数字+标点+特殊字符  一共编码了128个. 最早的是7bit  => 8bit
    计算机网络传输的时候单位是字节 1byte => 8bit
    ascii第一位是0

    ANSI: 一个标准
    GBK: 国标码的扩展码  16bit 2byte  65536个 主要是放中文  一定兼容ascii, 现在大家的windows默认就是GBK

    ISO+Unicode=> unicode 万国码  32bit  -> 一个面 16bit 65536个文字.
    ascii: a      10101010
    unicode: a   10101010

　　ascii 　　 8bit 　　1types
　　gbk　　　　16bit 　2types
　　unicode　　32bit 　4types

    utf:可变长度的unicode, 弥补了浪费的空间.
    utf-8:
        英文: 8bit  1byte
        欧洲: 16bit 2byte
        中文: 24bit 3byte

    python中默认使用的字符串就是unicode
    进行网络传输和文件存储必须要转化成utf-8或者gbk

    如何把字符串转化成utf-8

    encode(编码)  => 使用编码格式对文字进行编码
    decode(解码)  => 把bytes变回字符串

    8bit  -> 1Byte
    1024B -> 1KB
    1024KB -> 1MB
    1024MB -> 1GB
    1024GB -> 1TB

四. int
    bit_length() 是int唯一的一个动作.

'''
int类型的数据,基本运算
bit_length()二进制长度
'''
# for i in range(1, 20):
#     print(bin(i), i.bit_length(), oct(i), i, hex(i))

五. bool -> 数据类型之间的转化(记结论)
    int(字符串) =>  把字符串转化成数字
    str(数字)   =>  把数字转化成字符串

    结论1: 想要把x变成y   y(x)
    结论2: 所有的空都表示False, 所有的非空都表示True

'''
bool类型,基本数据类型之间的互相转换
bool => int
b = int(a)
print(b)

True => 1
False => 0

0 => False
非0 => True

结论2: 把x转化成y 需要 y(x)
字符串 => 数字
int(字符串)

'''
# a = True
# print(type(a))
# b = int(a)
# print(b)
# print(bool(0))
# print(bool(100))

'''
while 1:比 while True:(效率高一点点)
'''
# while 1:
#     pass

'''
所有表示空的东西都是假
'''
# print(bool(""))

'''
None 空
'''
# print(bool(None))

六. str(重点,  记住, 课上总结的内容)
    字符串的索引
    程序员数数从0开始

    字符串[索引]
    切片:
        字符串[start:end] 从start到end拿到数据. end取不到
        字符串[start:end:step] 从start到end拿数据. 每step个拿出来一个.
            step:
                + 左到右
                - 右到左

    常用操作
        字符串是一个不可变的数据类型
        1. upper()  转化成大写. 在忽略大小写的时候.
        2. strip()  默认去掉左右两端的空白
        3. replace()  字符串的替换
        4. split()  字符串切割, 结果是列表
        5. startswith() 判断是否以xxx开头
        6. find()  查找字符串中xxx字符的位置. 如果找不到返回-1
        7. len() 字符串长度

'''
str 由双引号,单引号,三个单引号,三个双引号括起来的内容
'''
# s = "字符串1"
# s2 = '字符串2'
# s3 = '''字符串3'''
# s4 = """字符串4"""
# print(s, s2, s3, s4)

'''
字符串是索引,索引就是第几个字符,索引从0开始
'''
# s = "hello world"
# print(s[0])
# print(s[-1])
# print(s[-3])

'''
字符串的切片,顾头不顾尾, 默认从左到右 [start:end:step]
'''
# s = "hello world"
# print(s[:])
# print(s[:3])
# print(s[3:])
# print(s[::2])
# print(s[::-1])

'''
大小写转来转去
1.首字母大写 capitalize()
'''
# s = "hello world"
# s = s.capitalize()
# print(s)

'''
2.把所有的字母转化成大写 upper()
'''
# s = "hello world"
# s = s.upper()
# print(s)

'''
3.把所有的字母转化为小写 lower()
'''
# s = "Hello World"
# s = s.lower()
# print(s)

'''
4.标题,每个单词的首字母大写 title()
'''
# s = "hello world"
# s = s.title()
# print(s)

'''
字符串切换 split()
'''
# s = "hello_world"
# lst = s.split("_")
# print(lst)

'''
字符串替换 replace()
'''
# s = "hello world"
# s = s.replace("l", "B")
# print(s)

'''
去掉空白 strip() lstrip() rstrip()
'''
# s = "   hello world  \t \n \r"
# s1 = s.strip()
# print(s1)
# s2 = s.lstrip()
# print(s2, "--end")
# s3 = s.rstrip()
# print(s3)

'''
判断字符串是否以什么开头或结尾 startswith() endswith()
'''
# s = "hello world"
# print(s.startswith("hello"))
# print(s.endswith("D"))

'''
判断子字符串在字符串中出现的次数 count() 
没有不报错
'''
# s = "hello world"
# print(s.count('o'))
# print(s.count('p'))

'''
查找子字符串find() 的索引
如果找不到,返回-1
'''
# s = "hello world"
# print(s.find('o'))
# print(s.find('u'))

'''
查找子字符串索引 index()
找不到会报错
'''
# s = "hello world"
# print(s.index('o'))
# print(s.index('u')) #ValueError: substring not found

'''
判断是否由数字组成 isdigit()
判断是否由文字的基本组成 isalpha()
是否有数字,字母组成,能屏蔽特殊字符 isalnum()
判读是否是数字 isnumeric()
'''
# s = "hello world"
# print(s.isdigit())
# s = "1900"
# print(s.isdigit())

'''
字符串长度 len()
可以用来遍历字符串
'''
# s = "hello world"
# print(len(s))
# for i in s:
#     print(i)

'''
in 和 no in  成员运算
'''
# s = "hello sex world"
# if "sex" in s:
#     print("不合法")
# else:
#     print("合法")

'''
while...else...
for...else...
break不会执行else,打断这个循环,没有经过条件判断,所以不执行else
'''
# i = 0
# while i < 10:
#     print(i)
#     i += 1
# else:
#     print("数完了")

# for i in range(10):
#     print(i)
# else:
#     print("数完了")

七. list - > 装数据的
    列表使用[]表示
    []
    list()
    列表也有索引和切片

    增删改查(重点)
    增加:
        1. append() 追加, 添加在列表的末尾
        2. insert() 插入, 在xxxx位置插入一个元素
        3. extend() 迭代新增.合并列表

    删除:
        1. pop() 删除. 指定索引删除
        2. remove() 删除某个指定元素
        3. del list[3]
        4. clear()  清空列表

    修改:
        使用索引去修改

    查询:
        直接用索引查找.
        使用for循环可以遍历列表

    其他操作:
        sort()
        count()

    元组(tuple): 不可变的列表,  只读列表
        放一些不进行修改的数据
        元组用()表示.
        空元组必须用tuple()来创建

        小知识点:  如果元组只有一个元素. 必须在末尾添加一个逗号

'''
存在的意义:存储大量的数据
列表使用[]括起来,内部元素用逗号隔开
'''
# lst = ["apple", "banana", "watermelon", "pear"]

'''
列表和字符串一样也有索引和切片
'''
# lst = ["apple", "banana", "watermelon", "pear"]
# print(lst[0])
# print(lst[1::2])
# print(lst[-1::-2])

'''
列表的增删改查
添加 
1.append() 追加 向列表的最后放数据
'''
# lst = []
# lst.append("apple")
# lst.append("banana")
# print(lst)

'''
2.insert() 插入
'''
# lst = ["apple", "banana", "pear", "watermelon"]
# lst.insert(2, "strawberry")
# print(lst)

'''
3.extend() 迭代增加
'''
# lst = ["apple", "banana"]
# lst.extend("melon")
# print(lst)
# lst.extend(["pear", "strawberry"])
# print(lst)

'''
删除
1.pop()
2.remove()
3.del lst[index]
4.clear() 清空
'''
# lst = ["apple", "banana", "pear", "watermelon"]
# lst.pop()
# print(lst)
# lst.remove("apple")
# del lst[0]
# print(lst)

'''
修改
'''
# lst = ["apple", "banana", "pear", "watermelon", "blueberry", "pineapple"]
# lst[1] = "orange"
# print(lst)

'''
查询 -> 用的最多的是索引
列表是一个可迭代对象,可以使用for循环
'''
# lst = ["strawberry", "blueberry", "pineapple"]
# for item in lst:
#     print(item)

'''
列表排序
从小到大 sort()
从大到小 sort(reverse=True)
'''
# lst = [1, 4, 7, 1, 2, 8, 2, 9]
# lst.sort()
# print(lst)
# lst.sort(reverse=True)
# print(lst)

'''
列表的深浅拷贝
is判断内存地址是否相同
'''
# a = 10
# # b = a
# # print(a is b)

# lst = ["apple", "banana"]
# lst2 = lst
# print(lst is lst2)
# lst.append("pear")
# print(lst)
# print(lst2)
# print(lst is lst2)

'''
切片方式,会对列表进行一个复制.浅拷贝
'''
# lst = ["apple", "banana", ["watermelon", "blueberry"]]
# lst3 = lst[:]
# print(lst is lst3)
# print(lst[2] is lst3[2])
# lst.append("pear")
# lst[2].append("strawberry")
# print(lst)
# print(lst3)

'''
copy()
'''
# lst = ["apple", "banana", ["watermelon", "blueberry"]]
# lst2 = lst.copy()
# print(lst is lst2)
# print(lst[2] is lst2[2])
# lst.append("pear")
# lst[2].append("strawberry")
# print(lst)
# print(lst2)

'''
深拷贝 inport copy
copy.deepcopy()
'''
# import copy
# lst = ["apple", "banana", ["watermelon", "blueberry"]]
# lst2 = copy.deepcopy(lst)
# print(lst is lst2)
# print(lst[2] is lst2[2])
# lst.append("pear")
# lst[2].append("strawberry")
# print(lst)
# print(lst2)

'''
元组是不可变的列表,又被称为只读列表
元组用小括号表示,并且空元组用tuple()
如果元组中只有一个元素,必须在后面加逗号
元组是可迭代对象
'''
# tu = ("apple", "banana", "pear", "blueberry")
# for t in tu:
#     print(t)

八. dict 字典  查询速度快
        在存储数据的时候必须使用key:value的形式进行存储,
        key不可以重复.
        并且要求key必须可哈希-> 不可变(int, str, tuple, bool, float)
        value没有要求

        字典的增删改查:
            新增:
                1. 直接用新key添加
                2. setdefault(key, value)    如果key存在, 不新增. 不存在, 新增. 最后都查询

            删除:
                1. pop(key)  指定key删除
                2. popitem() 删除最后一个.
                3. del dic[key]
                4. clear()

            修改:
                dic[老key] = 新value

            查询:
                get(key) 使用key获取value
                dic[key] 查询, 如果key不存在. 会报错

            循环:
                for k in dic:
                    k
                    dic[k]

                for k, v in dic.items():
                    print(k)
                    print(v)

'''
字典存储数据的时候,它是根据hash值进行存储的,字典中所有的key必须是可哈希的.
字典用{}表示.以key:value的形式进行保存数据
不可变就是可哈希,列表不能作为字典的Key
'''
# dic = {"苹果": "apple", "香蕉": "banana", "橘子": "orange"}
# print(type(dic))

'''
字典的增删改查
1.查询
'''
# dic = {"苹果": "apple", "香蕉": "banana", "橘子": "orange"}
# print(dic["香蕉"])
# print(dic["橘子"])

'''
字典.get(key) 找不到返回None
当key不存在,返回第二个数据
'''
# dic = {"苹果": "apple", "香蕉": "banana", "橘子": "orange"}
# print(dic.get("苹果"))
# print(dic.get("大苹果"))
# print(dic.get("大苹果", "没有这个水果哦"))

'''
添加元素
当key存在是,就修改,不存在就新增
'''
# dic = {"苹果": "apple", "香蕉": "banana", "橘子": "orange"}
# dic["蓝莓"] = "blueberry"
# print(dic)

'''
dict.setdefault(key) 如果只有一个参数,value放空
dict.setdefault(key, value) 1.首先判断key是否在字典中存在,如果存在,就不执行任何新增操作
2.不论前面是否执行新增,最后都会根据key把value查出来
'''
# dic = {"苹果": "apple", "香蕉": "banana", "橘子": "orange"}
# dic.setdefault("苹果")
# print(dic)
# dic.setdefault("大苹果", "big apple")
# print(dic)
# f = dic.setdefault("苹果", "Apple")
# print(dic)
# print(f)

'''
删除pop(key)
clear()清空
'''
# dic = {"苹果": "apple", "香蕉": "banana", "橘子": "orange"}
# dic.pop("香蕉")
# print(dic)

'''
del dict[key]
'''
# dic = {"苹果": "apple", "香蕉": "banana", "橘子": "orange"}
# del dic["香蕉"]
# print(dic)

'''
字典是可迭代的
查询: keys(), values(), items()
'''
dic = {"苹果": "apple", "香蕉": "banana", "橘子": "orange"}
# print(dic.keys())
# print(dic.values())
# print(dic.items())
# for k in dic.keys():  #不常用
#     print(k)

# for k in dic: #简单,常用
#     print(k)

# for v in dic.values():
#     print(v)

'''
常用:直接获取到key和value的方式
'''
# for k,v in dic.items():
#     print(k,v)

'''
解构,解包:把元组,列表中的每一项拿出来复制给前面的变量
要求:数据和变量要能对的上
'''
# a, b ,c = (1, 2, 3)
# print(a, b, c)

九. 知识点补充
    1. range
    2. join
    3. while...else
    4. for循环的时候不要删除列表中的内容

    欠的: is和==区别, 深浅拷贝, set集合