目录
一、引子
二、数字int
1.1 bit_length() 十进制用二进制表示时，最少使用的位数
三、布尔值bool
四、字符串str
1.1 字符串的索引
1.2 字符串的切片
1.3 captalize() 首字母大写（其他字母小写）
1.4 upper() 全部大写
1.5 lower() 全部小写
1.6 swapcase() 大小写翻转
1.7 title() 非字母元素隔开的每个单词首字母大写
1.8 center() 居中，自己设定长度，默认填充符为None（空格）
1.9 startswith() 判断以xx为开头
1.10 endswith() 判断以xx为结尾
1.11 strip() 去除首尾空格，制表符\t，换行符\n。不仅仅是去除空格
1.12 split() 字符串转换成列表
1.13 join() 将列表转换成字符串
1.14 replace() 替换字符串
1.15 find() 通过元素找索引，找不到返回-1
1.16 index() 通过元素找索引，找不到报错
1.17 len() 公共方法：测量长度，字符串有多少元素
1.18 count() 公共方法：统计某个元素的个数
1.19 format() 格式化输出,format的三种玩法
1.20 expandtabs() \t前面的补全
1.21 isalnum() is系列，字符串由字母或数字组成
1.22 isalpha() is系列，字符串只由字母组成
1.23 isdigit() 字符串只由数字组成
五、列表list
1.1 索引和切片
1.2 增-append() 在最后追加
1.3 增-insert() 插入
1.4 增-extend() 迭代着添加
1.5 删-pop() 按照位置去删除，唯一一个有返回值的
1.6 删-remove() 按照元素去删除
1.7 删-clear() 清空列表，只清空列表内容，不删除列表，内存中还有位置
1.8 删-del 内存级别删除列表，按元素删除，按索引删除
1.9 改-按照索引去改
1.10 改-按照切片去改
1.11 查-按照索引去查询，按照切片去查询,for循环去查询
1.12 其他方法-count() 统计某个元素在列表中出现的次数
1.13 其他方法-len() 统计列表元素个数
1.14 其他方法-index() 通过元素找索引，找到第一个就结束
1.15 其他方法-sort() 排序
1.16 其他方法-reverse() 列表元素反向存放
1.17 练习-列表的嵌套
六、字典dict
1.1 增-有则覆盖，无则添加
1.2 增-setdefault() 有则不变，无则添加
1.3 删-pop() 根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
1.4 删-clear() 清空字典
1.5 删-del 内存级别删除字典
1.6 删-popitem() 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
1.7 改-无则添加，有则覆盖
1.8 改-update() 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
1.9 查-根据key查找，查不存在key会报错
1.10 查-get() key不存在可以返回设定的返回值
1.11 其他操作-keys() <class 'dict_values'>
1.12 其他操作-values() <class 'dict_values'>
1.13 其他操作-items() dict_items类型，可迭代的
1.14 分别赋值
1.15 公共方法-len() 字典键值对的数量
1.16 其他操作-fromkeys() key必须是可迭代的，在内存中是一块地方
1.17 练习-字典的嵌套
七、元组tupe
1.1 索引、切片、for循环
1.2 index() 通过元素找索引
1.3 count() 统计元素出现的次数
1.4 len() 统计有多少元素
1.5 在元组里面，子级不能改，但是孙子级能改
八、集合set
1.1 列表的去重
1.2 增-add() 单个增加
1.3 增-update() 迭代增加
1.4 删-remove() 删除一个元素
1.5 删-pop() # 随机删除一个元素
1.6 删-clear() 清空集合
1.7 删-del 删除集合
1.8 集合的其他操作
1.9 frozenset不可变集合，让集合变成不可变类型。
九、数据类型补充
1.1 练习-删除列表对应奇数位的元素
1.2 练习-保留k开头的键，其他删除
1.3 元组元素的数据类型
十、小数据池
1.1 id == is
1.2 小数据池
十一、深浅copy
1.1 赋值运算
1.2 浅copy
1.3 深copy
十二、编码
1.1 编码理论
1.2 编码实践
一、引子
1、什么是数据？
x=10，10是要存储的数据。
2、为什么数据要分不同的类型
数据是用来表示状态的，不同的状态就应该用不同类型的数据表示
3、数据类型
数字（int）
布尔值（bool）
字符串（str）
列表（list）
元组（tupe）
字典（dict）
集合（set）
二、数字int
数字主要用于计算、运算。
1.1 bit_length() 十进制用二进制表示时，最少使用的位数
1 # 十进制0
2 i = 0
3 print(i.bit_length())
4 # 输出结果：0
5
6 # 十进制1
7 i = 1
8 print(i.bit_length())
9 # 输出结果：1
10
11 # 十进制2
12 i = 2
13 print(i.bit_length())
14 # 输出结果：2
15
16 # 十进制3
17 i = 3
18 print(i.bit_length())
19 # 输出结果：2
20
21 # 十进制4
22 i = 4
23 print(i.bit_length())
24 # 输出结果：3
25
26 # 十进制5
27 i = 5
28 print(i.bit_length())
29 # 输出结果：3
30
31 # 十进制6
32 i = 6
33 print(i.bit_length())
34 # 输出结果：3
35
36 """
37 二进制 十进制
38 0000 0000 0
39 0000 0001 1
40 0000 0010 2
41 0000 0011 3
42 0000 0100 4
43 0000 0101 5
44 0000 0110 6
45 """
扩展：
三、布尔值bool
布尔值就两种：True、False。就是反应条件的正确与否。
真 1 True
假 0 False
int ===> str #str(int)
str ===> int #int(str) 前提：str必须全部是数字组成。
int ===> bool #0为False，非零为True
bool ===> int #int(True)为1，int(False)为0
str ===> bool #bool("")为False，bool(" ")为True 解释：bool空为False，非空为True
四、字符串str
1.1 字符串的索引
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0，依次类推。
涉及到索引，全都是顾头不顾尾。
1 a = 'ABCDEFGHIJK'
2
3 a1 = a[0]
4 print(a1)
5 # 输出结果：A
6
7 a1 = a[3]
8 print(a1)
9 # 输出结果：D
10
11 a1 = a[5]
12 print(a1)
13 # 输出结果：F
14
15 a1 = a[-1]
16 print(a1)
17 # 输出结果：K
1.2 字符串的切片
切片就是通过索引来截取字符串的一段（索引:索引:步长），形成新的字符串。切片的原则是顾头不顾尾。
1 a = 'ABCDEFGHIJK'
2
3 # 打印ABC
4 print(a[0:3])
5
6 # CDE（顾头不顾尾）
7 print(a[2:5])
8
9 # 全部
10 print(a[0:])
11
12 # ABCDEFGHIJ
13 print(a[0:-1])
14
15 # ACE（加步长）
16 print(a[0:5:2])
17
18 # FDB（反向加步长）
19 print(a[5:0:-2])
20
21 # FEDCB（反向）
22 print(a[5:0:-1])
注意：如果倒着取，必须加一个反向的步长。如：a[5:0:-1]
1.3 captalize() 首字母大写（其他字母小写）
1 # captalize() 首字母大写（其他字母小写）
2 s = 'benJamin'
3 s1 = s.capitalize()
4 print(s1)
5 # 输出结果：Benjamin
1.4 upper() 全部大写
1 # upper() 全部大写
2 s = 'benJamin'
3 s1 = s.upper()
4 print(s1)
5 # 输出结果：BENJAMIN
1.5 lower() 全部小写
1 # lower() 全部小写
2 s = 'benJamin'
3 s1 = s.lower()
4 print(s1)
5 # 输出结果：benjamin
例1：不区分大小写验证
1 code = 'QeAr'.upper()
2 your_code = input('请输入验证码：').upper()
3 if your_code == code:
4 print('验证成功')
1.6 swapcase() 大小写翻转
1 # swapcase() 大小写翻转
2 s = 'benJamin'
3 s1 = s.swapcase()
4 print(s1)
5 # 输出结果：BENjAMIN
1.7 title() 非字母元素隔开的每个单词首字母大写
1 # title() 非字母元素隔开的每个单词首字母大写
2 s = 'alex wusir*oldboy3taibai'
3 s1 = s.title()
4 print(s1)
5 # 输出结果：Alex Wusir*Oldboy3Taibai
1.8 center() 居中，自己设定长度，默认填充符为None（空格）
1 # center() 居中，自己设定长度，默认填充符为None（空格）
2 s = 'Benjamin'
3 s1 = s.center(30,"*")
4 print(s1)
5 # 输出结果：***********Benjamin***********
1.9 startswith() 判断以xx为开头
1 # startswith() 判断以xx为开头
2 s = 'oldBoy'
3
4 s1 = s.startswith('o')
5 print(s1)
6 # 输出结果：True
7
8 s1 = s.startswith('old')
9 print(s1)
10 # 输出结果：True
11
12 s1 = s.startswith('Bo',3,5)
13 print(s1)
14 # 输出结果：True
1.10 endswith() 判断以xx为结尾
1 # endswith() 判断以xx为结尾
2 s = 'oldBoy'
3
4 s1 = s.endswith('y')
5 print(s1)
6 # 输出结果：True
7
8 s1 = s.endswith('oy')
9 print(s1)
10 # 输出结果：True
11
12 s1 = s.endswith('Bo',3,5)
13 print(s1)
14 # 输出结果：True
1.11 strip() 去除首尾空格，制表符\t，换行符\n。不仅仅是去除空格
1 # strip() 去除首尾空格，制表符\t，换行符\n
2 s = ' oldboy '
3 s1 = s.strip()
4 print(s1)
5 # 输出结果：oldboy
6
7 s = '\toldboy\n'
8 s1 = s.strip()
9 print(s1)
10 # 输出结果：oldboy
不仅仅是去除空格：
1 s = 'tyoldBoyrte'
2
3 s1 = s.strip('t')
4 print(s1)
5 # 输出结果：yoldBoyrte
6
7 s1 = s.strip('tey')
8 print(s1)
9 # 输出结果：oldBoyr
例2：误输入空格也能验证成功
1 name = input('>>>').strip()
2 if name == 'oldboy':
3 print('验证成功')
1.12 split() 字符串转换成列表
1 # split() 字符串转换成列表
2 s = 'oldboy wusir alex'
3 l = s.split()
4 print(l)
5 # 输出结果：['oldboy', 'wusir', 'alex']
6
7 s = 'oldboywusiroalex'
8 l = s.split('o')
9 print(l)
10 # 输出结果：['', 'ldb', 'ywusir', 'alex']
11
12 # 指定切割次数
13 s = 'oldboywusiroalex'
14 l = s.split('o',1)
15 print(l)
16 # 输出结果：['', 'ldboywusiroalex']
1.13 join() 将列表转换成字符串
1 # join() 将列表转换成字符串
2 s = 'oldboy'
3 s1 = '+'.join(s)
4 print(s1)
5 # 输出结果：o+l+d+b+o+y
6
7 s1 = '_'.join(s)
8 print(s1)
9 # 输出结果：o_l_d_b_o_y
10
11 li = ['oldboy','wusir','alex']
12 s1 = '_'.join(li)
13 print(s1)
14 # 输出结果：oldboy_wusir_alex
15
16 li = ['oldboy',1,'alex']
17 s1 = '_'.join(li)
18 print(s1)
19 # 输出结果：
20 '''
21 File "C:/Users/benjamin/python自动化21期/day2/03 int.py", line 17, in <module>
22 s1 = '_'.join(li)
23 TypeError: sequence item 1: expected str instance, int found
24 '''
25 # 注意：如果列表里面是非字符串元素，就会报错
join不仅能操作字符串、列表，还能此操作元组、字典。
1.14 replace() 替换字符串
1 # replace() 替换字符串
2 s = '大铁锤fdsalj铁锤妹妹范德萨'
3 s1 = s.replace('铁锤','钢蛋')
4 print(s1)
5 # 输出结果：大钢蛋fdsalj钢蛋妹妹范德萨
6
7 s = '大铁锤fdsalj铁锤妹妹范德萨'
8 s1 = s.replace('铁锤','钢蛋',1)
9 print(s1)
10 # 输出结果：大钢蛋fdsalj铁锤妹妹范德萨
1.15 find() 通过元素找索引，找不到返回-1
1 # find() 通过元素找索引，找不到返回-1
2 s = 'oldboy'
3
4 ind = s.find('d')
5 print(ind)
6 # 输出结果：2
7
8 ind = s.find('o')
9 print(ind)
10 # 输出结果：0
11
12 # 找不到返回-1
13 ind = s.find('A')
14 print(ind)
15 # 输出结果：-1
1.16 index() 通过元素找索引，找不到报错
1 # index() 通过元素找索引，找不到报错
2 s = 'oldboy'
3
4 ind = s.index('d')
5 print(ind)
6 # 输出结果：2
7
8 ind = s.index('o')
9 print(ind)
10 # 输出结果：0
11
12 # 找不到报错
13 ind = s.index('A')
14 print(ind)
15 # 输出结果：
16 '''
17 Traceback (most recent call last):
18 File "C:/Users/benjamin/python自动化21期/day2/03 int.py", line 29, in <module>
19 ind = s.index('A')
20 ValueError: substring not found
21 '''
1.17 len() 公共方法：测量长度，字符串有多少元素
1 # len() 公共方法：测量长度，字符串有多少元素
2 s = 'alfladflajdflakldaljhdalsj'
3 print(len(s))
4 # 输出结果：26
1.18 count() 公共方法：统计某个元素的个数
1 # count() 公共方法：统计某个元素的个数
2 s = 'sdssdfdfa'
3
4 print(s.count('d'))
5 # 输出结果：3
6
7 # 切片统计字符串中元素出现个数
8 print(s.count('d',0,5))
9 # 输出结果：2
1.19 format() 格式化输出,format的三种玩法
1 # format() 格式化输出,format的三种玩法
2 # 方法一
3 res='{} {} {}'.format('benjamin',18,'male')
4 print(res)
5 # 输出结果：benjamin 18 male
6
7 # 方法二
8 res='{1} {0} {1}'.format('benjamin',18,'male')
9 print(res)
10 # 输出结果：18 benjamin 18
11
12 # 方法三
13 res='{name} {age} {sex}'.format(sex='male',name='benjamin',age=18)
14 print(res)
15 # 输出结果：benjamin 18 male
1.20 expandtabs() \t前面的补全
1 # expandtabs() \t前面的补全
2 a2 = "hqw\t"
3 # \t前面的补全
4 # 默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
5 ret4 = a2.expandtabs()
6 print(ret4)
7 # 输出结果：hqw 【5个空格】
1.21 isalnum() is系列，字符串由字母或数字组成
1 # isalnum() is系列，字符串由字母或数字组成
2 name='jinxin123'
3 print(name.isalnum())
4 # 输出结果：True
1.22 isalpha() is系列，字符串只由字母组成
1 # isalpha() is系列，字符串只由字母组成
2 name='jinxin123'
3 print(name.isalpha())
4 # 输出结果：False
1.23 isdigit() is系列，字符串只由数字组成
1 # isdigit() is系列，字符串只由数字组成
2 name='jinxin123'
3 print(name.isdigit())
4 # 输出结果：False
例3：判断字符串是否只有数字组成
1 i = '123a'
2 if i.isdigit():
3 i = int(i)
4 else:
5 print("输入有误...")
6 # 输出结果：输入有误...
五、列表list
列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据。
32位python的限制是 536870912 个元素。
64位python的限制是 1152921504606846975 个元素。
列表是有序的，有索引值，可切片，方便取值。
1.1 索引和切片
1 li = [111,'alex',222,'wusir']
2
3 print(li[1])
4 # 输出结果：alex
5
6 print(li[-1])
7 # 输出结果：wusir
8
9 print(li[:2])
10 # 输出结果：[111, 'alex']
11
12 print(li[:3:2])
13 # 输出结果：[111, 222]
1.2 增-append() 在最后追加
1 # append() 在最后追加
2 l = ['老男孩','alex','wusir','taibai','ritian']
3
4 l.append('葫芦')
5 print(l)
6 # 输出结果：['老男孩', 'alex', 'wusir', 'taibai', 'ritian', '葫芦']
7
8 l.append([1,2,3])
9 print(l)
10 # 输出结果：['老男孩', 'alex', 'wusir', 'taibai', 'ritian', '葫芦', [1, 2, 3]]
1.3 增-insert() 插入
1 # insert() 插入
2 l = ['老男孩','alex','wusir','taibai','ritian']
3 l.insert(1,'景女神')
4 print(l)
5 # 输出结果：['老男孩', '景女神', 'alex', 'wusir', 'taibai', 'ritian']
1.4 增-extend() 迭代着添加
1 # extend() 迭代着添加
2 l = ['老男孩','alex','wusir','taibai','ritian']
3 l.extend(['111',222,333])
4 print(l)
5 # ['老男孩', 'alex', 'wusir', 'taibai', 'ritian', '111', 222, 333]
1.5 删-pop() 按照位置去删除，唯一一个有返回值的
1 # pop() 按照位置去删除，唯一一个有返回值的
2 l = ['老男孩','alex','wusir','taibai','ritian']
3 l1 = l.pop(0)
4 print(l1)
5 # 输出结果：老男孩 ==>返回值为删除的元素
6
7 print(l)
8 # 输出结果：['alex', 'wusir', 'taibai', 'ritian']
1.6 删-remove() 按照元素去删除
1 # remove() 按照元素去删除
2 l = ['老男孩','alex','wusir','taibai','ritian']
3 l.remove('alex')
4 print(l)
5 # 输出结果：['老男孩', 'wusir', 'taibai', 'ritian']
1.7 删-clear() 清空列表，只清空列表内容，不删除列表，内存中还有位置
1 # clear() 清空列表，只清空列表内容，不删除列表，内存中还有位置
2 l = ['老男孩','alex','wusir','taibai','ritian']
3 l.clear()
4 print(l)
5 # 输出结果：[]
1.8 删-del 内存级别删除列表，按元素删除，按索引删除
1 # del 内存级别删除列表，按元素删除，按索引删除
2 l = ['老男孩','alex','wusir','taibai','ritian']
3
4 # 切片删除
5 del l[:3]
6 print(l)
7 # 输出结果：['taibai', 'ritian']
8
9 # 按索引删除
10 del l[1]
11 print(l)
12 # 输出结果：['老男孩', 'wusir', 'taibai', 'ritian']
13
14 # 删除整个列表
15 del l
16 print(l)
17 # 输出结果：
18 '''
19 Traceback (most recent call last):
20 File "C:/Users/benjamin/python自动化21期/day2/03 int.py", line 29, in <module>
21 print(l)
22 NameError: name 'l' is not defined
23 '''
1.9 改-按照索引去改
1 # 按照索引去改
2 l = ['老男孩','alex','wusir','taibai','ritian']
3 l[2] = '武藤兰'
4 print(l)
5 # 输出结果：['老男孩', 'alex', '武藤兰', 'taibai', 'ritian']
1.10 改-按照切片去改
1 # 按照切片去改
2 l = ['老男孩','alex','wusir','taibai','ritian']
3 l[:2] = 'abc'
4 print(l)
5 # 输出结果：['a', 'b', 'c', 'wusir', 'taibai', 'ritian']
6
7 l = ['老男孩','alex','wusir','taibai','ritian']
8 l[1:3] = [111,222,333,444]
9 print(l)
10 # 输出结果：['老男孩', 111, 222, 333, 444, 'taibai', 'ritian']
1.11 查-按照索引去查询，按照切片去查询,for循环去查询
1 # 按照索引去查询，按照切片去查询,for循环去查询
2 l = ['老男孩','alex','wusir','taibai','ritian']
3 for i in l:
4 print(i)
5 # 输出结果：
6 '''
7 老男孩
8 alex
9 wusir
10 taibai
11 ritian
12 '''
1.12 其他方法-count() 统计某个元素在列表中出现的次数
1 # count() 统计某个元素在列表中出现的次数
2 a = ["q","w","q","r","t","y"]
3 print(a.count("q"))
4 # 输出结果：2
1.13 其他方法-len() 统计列表元素个数
1 # len() 统计列表元素个数
2 a = ["q","w","q","r","t","y"]
3 print(len(a))
4 # 输出结果：6
1.14 其他方法-index() 通过元素找索引，找到第一个就结束
1 # index() 通过元素找索引，找到第一个就结束
2 a = ["q","w","q","r","t","y"]
3 print(a.index('q'))
4 # 输出结果：0
1.15 其他方法-sort() 排序
1 # sort() 排序
2 # 从小到大排序
3 a = [2,1,3,6,5,4,7]
4 a.sort()
5 print(a)
6 # 输出结果：[1, 2, 3, 4, 5, 6, 7]
7
8 # 从大到小排序
9 a = [2,1,3,6,5,4,7]
10 a.sort(reverse=True)
11 print(a)
12 # 输出结果：[7, 6, 5, 4, 3, 2, 1]
1.16 其他方法-reverse() 列表元素反向存放
1 # reverse() 列表元素反向存放
2 a = [2,1,3,6,5,4,7]
3 a.reverse()
4 print(a)
5 # 输出结果：[7, 4, 5, 6, 3, 1, 2]
1.17 练习-列表的嵌套
l1 = [1,2,'alex','wusir',['oldboy','ritian',99],'taibai']
1、将'alex'全部变成大写，放回原处。
1 # 方法一：
2 l1[2] = 'ALEX'
3 print(l1)
4 # 输出结果：[1, 2, 'ALEX', 'wusir', ['oldboy', 'ritian', 99], 'taibai']
5
6 # 方法二：
7 l1[2] = l1[2].upper()
8 print(l1)
9 # 输出结果：[1, 2, 'ALEX', 'wusir', ['oldboy', 'ritian', 99], 'taibai']
2、给['oldboy','ritian',99]追加一个元素'女神'。
1 l1[-2].append('女神')
2 print(l1)
3 # 输出结果：[1, 2, 'alex', 'wusir', ['oldboy', 'ritian', 99, '女神'], 'taibai']
3、将'ritian'首字母大写，放回原处。
1 # 方法一：
2 l1[-2][1] = 'Ritian'
3 print(l1)
4 # 输出结果：[1, 2, 'alex', 'wusir', ['oldboy', 'Ritian', 99], 'taibai']
5
6 # 方法二：
7 l1[-2][1] = l1[-2][1].capitalize()
8 print(l1)
9 # 输出结果：[1, 2, 'alex', 'wusir', ['oldboy', 'Ritian', 99], 'taibai']
4、将99通过数字相加，变成'100'
1 l1[-2][-1] = str(l1[-2][-1] + 1)
2 print(l1)
3 # 输出结果：[1, 2, 'alex', 'wusir', ['oldboy', 'Ritian', '100'], 'taibai']
5、将下面列表中的10，通过字符串相加，变成'100'
1 l1 = [1,2,'alex','wusir',['oldboy','ritian',10],'taibai']
2 l1[-2][-1] = str(l1[-2][-1]) + '0'
3 print(l1)
六、字典dict
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典的key是唯一的。key必须是不可变的数据类型。
key:不可变的数据类型（可哈希）：str、bool、tuple、int。
value:任意数据类型。
数据类型分类：
不可变的数据类型（可哈希）：str、bool、tuple、int
可变的数据类型：dict、list、set
容器类数据类型：list、tuple、dict、set
字典：存储数据多，关系型数据，查询速度快（二分查找）。
3.6版本之前，字典是无序的。3.6之后字典是有序的。
1.1 增-有则覆盖，无则添加
1 # 增-有则覆盖，无则添加
2 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
3
4 dic['high'] = 180
5 print(dic)
6 # 输出结果：{'name': 'taibai', 'age': 21, 'hobby': 'girl', 'high': 180}
7
8 dic['name'] = 'ritian'
9 print(dic)
10 # 输出结果：{'name': 'ritian', 'age': 21, 'hobby': 'girl', 'high': 180}
1.2 增-setdefault() 有则不变，无则添加
1 # setdefault() 有则不变，无则添加
2 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
3
4 dic.setdefault('high')
5 print(dic)
6 # 输出结果：{'name': 'taibai', 'age': 21, 'hobby': 'girl', 'high': None}
7
8 dic.setdefault('high',180)
9 print(dic)
10 # 输出结果：{'name': 'taibai', 'age': 21, 'hobby': 'girl', 'high': None} ==>有则不变，无则添加
1.3 删-pop() 根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
1 # pop() 根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
2 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
3
4 dic.pop('name')
5 print(dic)
6 # 输出结果：{'age': 21, 'hobby': 'girl'}
7
8 l = dic.pop('a','无key默认返回值')
9 print(l)
10 # 输出结果：无key默认返回值
1.4 删-clear() 清空字典
1 # clear() 清空字典
2 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
3 dic.clear()
4 print(dic)
5 # 输出结果：{}
1.5 删-del 内存级别删除字典
1 # del 内存级别删除字典
2 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
3
4 # 根据key去删除键值对
5 del dic['age']
6 print(dic)
7 # 输出结果：{'name': 'taibai', 'hobby': 'girl'}
8
9 # 删除内存中整个字典
10 del dic
11 print(dic)
12 # 输出结果：
13 '''
14 Traceback (most recent call last):
15 File "C:/Users/benjamin/python自动化21期/day2/03 int.py", line 30, in <module>
16 del dic
17 NameError: name 'dic' is not defined
18 '''
1.6 删-popitem() 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
1 # popitem() 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
2 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
3
4 print(dic.popitem())
5 # 输出结果：('hobby', 'girl')
6
7 print(dic)
8 # 输出结果：{'name': 'taibai', 'age': 21}
1.7 改-无则添加，有则覆盖
1 # 无则添加，有则覆盖
2 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
3 dic['name'] = '老男孩'
4 print(dic)
5 # 输出结果：{'name': '老男孩', 'age': 21, 'hobby': 'girl'}
1.8 改-update() 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
1 # update() 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
2 dic = {"name":"jin","age":18,"sex":"male"}
3 dic2 = {"name":"alex","weight":75}
4 dic2.update(dic)
5 print(dic2)
6 # 输出结果：{'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}
1.9 查-根据key查找，查不存在key会报错
1 # 根据key查找，查不存在key会报错
2 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
3
4 print(dic['name'])
5 # 输出结果：taibai
6
7 print(dic['abc'])
8 # 输出结果：
9 '''
10 Traceback (most recent call last):
11 File "C:/Users/benjamin/python自动化21期/day2/03 int.py", line 6, in <module>
12 print(dic['abc'])
13 KeyError: 'abc'
14 '''
1.10 查-get() key不存在可以返回设定的返回值
1 # get() key不存在可以返回设定的返回值
2 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
3
4 print(dic.get('name'))
5 # 输出结果：taibai
6
7 print(dic.get('name2','此key不存在...'))
8 # 输出结果：此key不存在...
1.11 其他操作-keys() <class 'dict_values'>
1 # keys() <class 'dict_values'>
2 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
3
4 print(dic.keys())
5 # 输出结果：dict_keys(['name', 'age', 'hobby'])
6
7 print(list(dic.keys()))
8 # 输出结果：['name', 'age', 'hobby']
9
10 for i in dic.keys():
11 print(i)
12 # 输出结果：
13 '''
14 name
15 age
16 hobby
17 '''
1.12 其他操作-values() <class 'dict_values'>
1 # values() <class 'dict_values'>
2 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
3
4 print(dic.values())
5 # 输出结果：dict_values(['taibai', 21, 'girl'])
6
7 for i in dic.values():
8 print(i)
9 # 输出结果：
10 '''
11 taibai
12 21
13 girl
14 '''
1.13 其他操作-items() dict_items类型，可迭代的
1 # items() dict_items类型，可迭代的
2 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
3
4 print(dic.items())
5 # 输出结果：dict_items([('name', 'taibai'), ('age', 21), ('hobby', 'girl')])
6
7 print(list(dic.items()))
8 # 输出结果：[('name', 'taibai'), ('age', 21), ('hobby', 'girl')]
9
10 for i in dic.items():
11 print(i)
12 # 输出结果：
13 '''
14 ('name', 'taibai')
15 ('age', 21)
16 ('hobby', 'girl')
17 '''
1.14 分别赋值
1 a,b = 1,2
2 print(a,b)
3 # 输出结果：1 2
4
5 a,b,c = ['alex','wusir','ritian']
6 print(a,b,c)
7 # 输出结果：alex wusir ritian
8
9 a = 1
10 b = 5
11 a,b = b,a
12 print(a,b)
13 # 输出结果：5 1
14
15 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
16 for i in dic.items():
17 print(i)
18 # 输出结果：
19 '''
20 ('name', 'taibai')
21 ('age', 21)
22 ('hobby', 'girl')
23 '''
24
25 for k,v in dic.items():
26 print(k,v)
27 # 输出结果：
28 '''
29 name taibai
30 age 21
31 hobby girl
32 '''
1.15 公共方法-len() 字典键值对的数量
1 # len() 字典键值对的数量
2 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
3 print(len(dic))
4 # 输出结果：3
1.16 其他操作-fromkeys() key必须是可迭代的，在内存中是一块地方
1 # fromkeys() key必须是可迭代的，在内存中是一块地方
2 dic1 = dict.fromkeys('abc','张三')
3 print(dic1)
4 # 输出结果：{'a': '张三', 'b': '张三', 'c': '张三'}
5
6 dic2 = dict.fromkeys([1,2,3],'李四')
7 print(dic2)
8 # 输出结果：{1: '李四', 2: '李四', 3: '李四'}
9
10 dic3 = dict.fromkeys('abc',[])
11 print(dic3)
12 # 输出结果：{'a': [], 'b': [], 'c': []}
13
14 dic3['a'].append('老男孩')
15 print(dic3)
16 # 输出结果：{'a': ['老男孩'], 'b': ['老男孩'], 'c': ['老男孩']}
1.17 练习-字典的嵌套
1 dic = {
2 'name_list':['b哥', '张帝', '人帅', 'kitty'],
3 '老男孩':{
4 'name':'老男孩',
5 'age': 46,
6 'sex': 'ladyboy',
7 },
8 }
1、['b哥', '张帝', '人帅', 'kitty']追加一个元素，'骑兵'
1 dic['name_list'].append('骑兵')
2 print(dic)
3 # 输出结果：{'name_list': ['b哥', '张帝', '人帅', 'kitty', '骑兵'], '老男孩': {'name': '老男孩', 'age': 46, 'sex': 'ladyboy'}}
2、将kitty全部变成大写。
1 # 步骤一：
2 l1 = dic['name_list']
3 print(l1[-1].upper())
4 # 输出结果：KITTY
5 l1[-1] = l1[-1].upper()
6 print(dic)
7 # 输出结果：{'name_list': ['b哥', '张帝', '人帅', 'KITTY'], '老男孩': {'name': '老男孩', 'age': 46, 'sex': 'ladyboy'}}
8
9 # 步骤二：
10 dic['name_list'][-1] = dic['name_list'][-1].upper()
11 print(dic)
12 # 输出结果：{'name_list': ['b哥', '张帝', '人帅', 'KITTY'], '老男孩': {'name': '老男孩', 'age': 46, 'sex': 'ladyboy'}}
3、将老男孩 改成oldboy。
1 dic['老男孩']['name'] = 'oldboy'
2 print(dic)
4、将ladyboy首字母大写。
1 dic['老男孩']['sex'] = dic['老男孩']['sex'].capitalize()
2 print(dic)
七、元组tupe
元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）
1.1 索引、切片、for循环
1 # 有索引、有切片、有步长
2 tu = (11,2,True,[2,3,4],'alex')
3 print(tu[1])
4 # 输出结果：2
5 print(tu[:3:2])
6 # 输出结果：(11, True)
7
8 # for循环
9 for i in tu:
10 print(i)
11 # 输出结果：
12 '''
13 11
14 2
15 True
16 [2, 3, 4]
17 alex
18 '''
1.2 index() 通过元素找索引
1 # index() 通过元素找索引
2 tu = (11,2,True,[2,3,4],'alex')
3 print(tu.index(True))
4 # 输出结果：2
1.3 count() 统计元素出现的次数
1 # count() 统计元素出现的次数
2 tu = (11,2,True,[2,3,4],'alex')
3 print(tu.count(2))
4 # 输出结果：1
1.4 len() 统计有多少元素
1 # len() 统计有多少元素
2 tu = (11,2,True,[2,3,4],'alex')
3 print(len(tu))
4 # 输出结果：5
1.5 在元组里面，子级不能改，但是孙子级能改
1 # 在元组里面，子级不能改，但是孙子级能改
2 tu[-2].append(666)
3 print(tu)
4 # 输出结果：(11, 2, True, [2, 3, 4, 666], 'alex')
八、集合set
集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
去重，把一个列表变成集合，就自动去重了。
关系测试，测试两组数据之前的交集、差集、并集等关系。
1.1 列表的去重
1 set1 = {1,'alex',False,(1,2,3)}
2 l1 = [1,1,2,2,3,3,4,5,6,6]
3 l2 = list(set(l1))
4 print(l2)
5 # 输出结果：[1, 2, 3, 4, 5, 6]
1.2 增-add() 单个增加
1 set1 = {'alex','wusir','ritian','egon','barry'}
2 set1.add('666')
3 print(set1)
4 # 输出结果：{'alex', 'ritian', '666', 'barry', 'egon', 'wusir'}
1.3 增-update() 迭代增加
1 set1 = {'alex','wusir','ritian','egon','barry'}
2 set1.update('abc')
3 print(set1)
4 # 输出结果：{'alex', 'c', 'ritian', 'a', 'barry', 'b', 'egon', 'wusir'}
1.4 删-remove() 删除一个元素
1 set1 = {'alex','wusir','ritian','egon','barry'}
2 set1.remove('alex')
3 print(set1)
4 # 输出结果：{'wusir', 'egon', 'barry', 'ritian'}
1.5 删-pop() # 随机删除一个元素
1 set1 = {'alex','wusir','ritian','egon','barry'}
2 set1.pop()
3 print(set1)
4 # 输出结果：{'barry', 'alex', 'wusir', 'egon'}
1.6 删-clear() 清空集合
1 set1 = {'alex','wusir','ritian','egon','barry'}
2 set1.clear()
3 print(set1)
4 # 输出结果：set()
1.7 删-del 删除集合
1 set1 = {'alex','wusir','ritian','egon','barry'}
2 del set1 # 删除集合
3 print(set1)
4 # 输出结果：
5 '''
6 Traceback (most recent call last):
7 File "C:/Users/benjamin/python自动化21期/day2/09 集合.py", line 5, in <module>
8 print(set1)
9 NameError: name 'set1' is not defined
10 '''
1.8 集合的其他操作
1 交集。（& 或者 intersection）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2) # {4, 5}
print(set1.intersection(set2)) # {4, 5}
2 并集。（| 或者 union）
set1 = {1,2,3,4,5} set2 = {4,5,6,7,8} print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7}
print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7}
3 差集。（- 或者 difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2) # {1, 2, 3}
print(set1.difference(set2)) # {1, 2, 3}
4反交集。 （^ 或者 symmetric_difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
5子集与超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。
1.9 frozenset不可变集合，让集合变成不可变类型。
s = frozenset('barry')
print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>
s = frozenset('barry')
s1 = frozenset({4,5,6,7,8})
print(s,type(s))
# 输出结果：frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>
print(s1,type(s1))
# 输出结果：frozenset({4, 5, 6, 7, 8}) <class 'frozenset'>
九、数据类型补充
1.1 练习-删除列表对应奇数位的元素
方法一：
1 l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩']
2 del l1[1::2]
3 print(l1)
4 # 输出结果：['alex', 'taibai', '老男孩']
方法二：
1 l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩']
2
3 for i in range(len(l1)-1,-1,-1):
4 if i % 2 == 1:
5 del l1[i]
6 print(l1)
7 # 输出结果：['alex', 'taibai', '老男孩']
# 注意：在循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，会出错。
扩展：range，指定范围，生成指定数字。
1 for i in range(1,10):
2 print(i)
3 for i in range(1,10,2): # 步长
4 print(i)
5 for i in range(10,1,-2): # 反向步长
6 print(i)
1.2 练习-保留k开头的键，其他删除
1 dic = {'k1':'v1','k2':'v2','k3':'v3','r':666}
2 l1 = []
3 for i in dic:
4 if 'k' in i:
5 l1.append(i)
6 print(l1)
7 # 输出结果：['k1', 'k2', 'k3']
# 注意：dict 在循环字典时，不要改变字典的大小（删除、增加）。
1.3 元组元素的数据类型
1 #tu 如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致。
2 tu1 = (1)
3 print(tu1,type(tu1))
4 # 输出结果：1 <class 'int'>
5
6 tu1 = (1,)
7 print(tu1,type(tu1))
8 # 输出结果：(1,) <class 'tuple'>
9
10 tu2 = ('alex')
11 print(tu2,type(tu2))
12 # 输出结果：alex <class 'str'>
13
14 tu3 = (['alex',1,2])
15 print(tu3,type(tu3))
16 # 输出结果：['alex', 1, 2] <class 'list'>
十、小数据池
1.1 id == is
#pycharm
1 a = 'alex'
2 b = 'alex'
3 print(a == b) # 数值
4 # 输出结果：True
5
6 print(a is b) # 内存地址
7 # 输出结果：True
8
9 print(id(a))
10 # 输出结果：2250900488632
#python解释器
1 C:\Users\benjamin>python
2 Python 3.6.2 (v3.6.2:5fd33b5, Jul 8 2017, 04:57:36) [MSC v.1900 64 bit (AMD64)] on win32
3 Type "help", "copyright", "credits" or "license" for more information.
4 >>> a = 'alex@'
5 >>> b = 'alex@'
6 >>> print(a == b)
7 True
8 >>> print(id(a),id(b))
9 2174524042184 2174524042240
10 >>> print(a is b)
11 False
1.2 小数据池
python中有小数据池的概念，只针对str和int。
int -5 ~256 的相同的数全都指向一个内存地址，节省空间。
str：s = 'a' * 20 以内都是同一个内存地址；
只要字符串含有非字母元素，那就不是一个内存地址。
十一、深浅copy
1.1 赋值运算
1 #赋值运算，它们共用一个列表
2 a = [1,2,3]
3 b = a
4 a.append(666)
5 print(a,b)
6 # 输出结果：[1, 2, 3, 666] [1, 2, 3, 666]
# 对于赋值运算来说a与b指向的是同一内存地址，所以他们是完全一样的。
1.2 浅copy
1 l1 = [1,2,3]
2 l2 = l1.copy()
3 l1.append(666)
4 print(l1,l2)
5 # 输出结果：[1, 2, 3, 666] [1, 2, 3]
6
7 print(id(l1),id(l2))
8 # 输出结果：1881619532936 1881619531144
9
10 l1 = [1,2,3,[22,33]]
11 l2 = l1.copy()
12 l1[-1].append(666)
13 print(l1,l2)
14 # 输出结果：[1, 2, 3, [22, 33, 666]] [1, 2, 3, [22, 33, 666]]
15
16 print(id(l1[-1]),id(l2[-1]))
17 # 输出结果：1822816634056 1822816634056
# 对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，
# 指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性
1.3 深copy
1 import copy
2 l1 = [1,2,3,[22,33]]
3 l2 = copy.deepcopy(l1)
4 l1[-1].append(666)
5 print(l1,l2)
6 # 输出结果：[1, 2, 3, [22, 33, 666]] [1, 2, 3, [22, 33]]
7
8 print(id(l1[-1]),id(l2[-1]))
9 # 输出结果：1531850938440 1531850939848
# 深copy 对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。
十二、编码
1.1 编码理论
python3x:
1,不同编码之间的二进制是不能互相识别的。
2,python3x str内部编码方式（内存）为unicode
但是，对于文件的存储，和传输不能用unicode
bytes类型：内部编码方式（内存）为非unicode
#对于英文
str:
s = 'laonanhai' 表现形式
内部编码方式 unicode
bytes:
s1 = b'laonanhai' 表现形式
内部编码方式 非unicode （utf-8,gbk,gb2312....）
#对于中文
str：
s = '中国'
print(s,type(s))
bytes：
s1 = b'\xe4\xb8\xad\xe5\x9b\xbd'
print(s1,type(s1))
1.2 编码实践
1、对于英文
1 s = 'laonanhai'
2 print(s,type(s))
3 # 输出结果：laonanhai <class 'str'>
4
5 s1 = b'laonanhai'
6 print(s1,type(s1))
7 # 输出结果：b'laonanhai' <class 'bytes'>
2、对于中文
1 s = '中国'
2 print(s,type(s))
3 # 输出结果：中国 <class 'str'>
4
5 s1 = b'\xe4\xb8\xad\xe5\x9b\xbd'
6 print(s1,type(s1))
7 # 输出结果：b'\xe4\xb8\xad\xe5\x9b\xbd' <class 'bytes'>
3、转化
1 s = 'laonanhai'
2 s2 = s.encode('utf-8') #str -->bytes encode 编码
3 s3 = s.encode('gbk')
4 print(s2,s3)
5 # 输出结果：b'laonanhai' b'laonanhai'
6
7 s = '中国'
8 s2 = s.encode('utf-8') #str -->bytes encode 编码
9 s3 = s.encode('gbk')
10 print(s2)
11 # 输出结果：b'\xe4\xb8\xad\xe5\x9b\xbd'
12
13 print(s3)
14 # 输出结果：b'\xd6\xd0\xb9\xfa'
15
16 ss = s2.decode('utf-8') # bytes ---> str decode 解码
17 print(ss)
18 # 输出结果：中国
扫一扫
4746
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
