整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).
0、基本数据类型：
ASCII：1个字节表示，包含字母、数字、特殊字符；
Unicode ：开始是16位，现在升级以后是32位；
utf-8：最少用一个字节表示，英文用1个字节
欧洲用2个字节
中文用3个字节表示
gbk：中文用2个字节，英文用1个字节表示
0.1、 int类型
int 比较重要的是bit_length()：1个数据最少二进制表达位；
1、字符串类型（str）
1.1 单双引号木有任何区别，但是下面的情况需要注意，不能随便用单引号：
msg = "I‘m a teacher’"
1.2 多引号，就是多行字符串时候用：
1 msg = '''2 我是中国人3 我是广东人4 我是广州人5 '''
1.3 字符串可以相加及相乘：
1 m1 = "我要去西藏" 2 m2 = "唱一曲天路" 3 m3 = m1 + m2 4 m4 = m2 * 4 5 print(m3) 6 print(m4) 7 8 输出为： 9 我要去西藏唱一曲天路10 唱一曲天路唱一曲天路唱一曲天路唱一曲天路
注意：字符串相加，其实就是进行拼接；但是字符串只能跟字符串进行拼接，不能够与数字进行拼接。
2、格式化输出
2.1 %s就是代表字符串占位符，%d是数字占位符，如果是%d则表示必须输入数字。另外如果想表达50%类似这样带%输出的情况，那么在%后面再加一个%，表示转义
1 msg = "我是%s,年龄%d,目前学习进度为80%%"%('金鑫',18)2 print(msg) 2.2 format的三种用法 格式化输出
1 #format的三种用法 格式化输出 2 s = '我叫{}，今年{}，爱好{}，再说一下我叫{}'.format('彭',25,'sport','彭') 3 print(s) 4 name = input('请输入名字：') 5 s = '我叫{0}，今年{1}，爱好{2}，再说一下我叫{0}'.format(name,25,'sport') 6 print(s) 7 name = input('请输入名字：') 8 s = '我叫{name}，今年{age}，爱好{hobby}，再说一下我叫{name}'.format(age=25,name=name,hobby='sport') 9 print(s)10 11 结果：12 我叫彭，今年25，爱好sport，再说一下我叫彭13 请输入名字：彭14 我叫彭，今年25，爱好sport，再说一下我叫彭15 请输入名字：彭16 我叫彭，今年25，爱好sport，再说一下我叫彭 3、字符串的索引及切片
isdigit()：判定是否为全部是数字， 返回bool值
isapha()： isnumpha()： startswith：判定以什么开头；endswith：判定以什么结尾；
title ：首字母大写 center（）：居中，不够的空白或者指定字符填充； strip（）lstrip rstrip： split： format ：格式化输出repalce:字符串替换，repalce(old,new,count)
expandtabs：对于s = 'peng\tjun'中，自动在\t处的左边补8个空格；
find : 找出指定字符的下标，index = content.find('+')
capitalize()：把首字母改为大写。
1 #字符串的索引及切片 2 3 s = "pengJunFei" 4 s1 = s.capitalize() #首字母大写 5 print(s1) 6 s2 = s.upper() #全部转为大写 7 s3 = s.lower() #全部转为小写 8 print(s2) # 9 print(s3)10 11 s4 = "PengJunFei"12 s5 = s4.swapcase() #大小写翻转13 print(s5)14 15 s6 = "peng*jun fei-123&abcd$rrrr%ddfef"16 s61 = s6.title() #把空格/特殊字符隔开的字符串首字母转为大写17 print(s61)18 19 s7 = "jun"20 s71 = s7.center(20,"*") #把目标字符串用相应的字符居中，没有第1个参数的话，则默认为空格。21 print(s71)22 23 s8 = "peng\tjunfei\t555广东" #自动把前面的字符补足8位24 s81 = s8.expandtabs()25 print(s81)26 27 s9 = "peng广东junfei"28 s92 = len(s9) #计算字符串长度，中文也是按一个来计算。29 print(s92)30 31 s10 = "pengAAceng"32 s11 = s10.startswith('pen') #判定字符串是否以xxx为开头33 s12 = s10.startswith('g',3,5) #判定字符串的第3个字符开始，第5个字符结束的这一区间是否以'g'开头，其中5可以去掉34 #则默认为到结尾，即顾头不顾尾35 print(s11)36 print(s12)37 38 s20 = 'pengJUNfeigaaa'39 s21 = s20.find('g') #选择找到相应字符的第1次出现的下标索引40 print(s21,type(s21)) #type()是判定变量的数据类型41 42 43 44 45 46 47 结果：48 Pengjunfei49 PENGJUNFEI50 pengjunfei51 pENGjUNfEI52 Peng*Jun Fei-123&Abcd$Rrrr%Ddfef53 ********jun*********54 peng junfei 555广东55 1256 True57 True58 3 1 s20 = 'pengJUNfeigaaa' 2 s21 = s20.find('g') #选择找到相应字符的第1次出现的下标索引 3 s22 = s20.index('a') #找字符串中第一个出现所标字符的位置，如果没有则报错 4 print(s21,type(s21)) #type()是判定变量的数据类型 5 print(s22) 6 7 8 结果： 9 3 10 11 1 s = "ABCDEFGHIJKLMN" 2 3 s1 = s[0] 4 print(s1) 5 s2 = s[4] 6 print(s2) 7 s3 = s[0:4] #列表的切片，是顾头不顾尾，即尾那个数不计算在内 8 print(s3) 9 10 s4 = s[0:-1]#切到倒数第1个11 print(s4)12 s5 = s[:] #没有指定，则全部13 print(s5)14 s6 = s[0:]#c从第0开始，一直到结束，其实s5是等价于s6的15 print(s6)16 17 结果：18 A19 E20 ABCD21 ABCDEFGHIJKLM22 ABCDEFGHIJKLMN23 ABCDEFGHIJKLMN
1 s = "ABCDEFGHIJKLMN"2 s7 = s[0:0]#就是没有取到任何值3 print(s7)4 5 结果：6 #结果为空，没有取到值
1 s = "ABCDEFGHIJKLMN"2 s8 = s[0:5:2] #首、尾、步长：0就是首3 print(s8)4 5 结果：6 ACE
1 s = "ABCDEFGHIJKLMN"2 s9 = s[4:0:-1]3 print(s9)4 5 结果：6 EDCB
1 s = "ABCDEFGHIJKLMN"2 s10 = s[3::-1]3 print(s10)4 5 结果：6 DCBA
1 s = "ABCDEFGHIJKLMN"2 s11 = s[3::-2] #反向切，且步长为23 print(s11)4 5 结果：6 DB
1 s = "ABCDEFGHIJKLMN"2 s12 = s[-1::-1]#从最后一个反向切，一直切到最开头，步长为13 print(s12)4 5 结果：6 NMLKJIHGFEDCBA
1 s = "ABCDEFGHIJKLMN"2 s13 = s[-2::-1]3 print(s13) #从倒数第二个开始切，一直切到最开头，步长为14 5 结果：6 MLKJIHGFEDCBA
1 s = "ABCDEFGHIJKLMN"2 s14 = s[::-1]3 print(s14)4 5 结果：6 NMLKJIHGFEDCBA
3.1 字符串的前后删除某个字符 strip()、lstrip()、rstrip()
1 s1 = ' $pengJun###FEI##' 2 s10 = s1.strip() # 在用户输入中，可以把前后的空格去掉,实际字符中间则删不掉 3 print(s10) 4 s11 = s1.strip('$') 5 print(s11) 6 s12 = s10.strip('$') #从头尾同时向中间找，找到里面的字符则删除，遇到非要找的字符则停止 7 print(s12) 8 s13 = s10.strip('$#')#中间三个###删不掉是因为从尾部往中间遇到了I，挡住了 9 print(s13)10 11 #例如12 username = input('请输入名字：').strip()13 if username == '彭':14 print('输入正确')15 16 结果：17 $pengJun###FEI##18 $pengJun###FEI##19 pengJun###FEI##20 pengJun###FEI21 请输入名字： 彭 22 输入正确
1 # strip(), 从两边往中间删，遇到非指定要删字符则停止 2 # rstrip(),从右边往中间删，左边不动 3 # lstrip()，从左边往中间删，右边不动 4 5 s1 = '&&peng&jun%%*fei***' 6 s12 = s1.rstrip('%*%') 7 s13 = s1.lstrip('&*') 8 print(s12) 9 print(s13)10 11 结果：12 &&peng&jun%%*fei13 peng&jun%%*fei*** 3.2 计算字符串中指定字符的个数 count()
1 s1 = '&&peng&jun%%*fei***'2 s11 = s1.count('&')# 查找指定字符的个数3 print(s11)4 5 结果：6 3 3.3 把字符串按字符串中某个字符进行分割，一分为二地分割为列表 split()
1 #splint()是对按指定字符一分为二为列表 2 s2 = '&& peng& jun%%* fei***' 3 s21 = s2.split() #按空格一分为二为列表 4 s22 = s2.split('&')#按&一分为二为列表 5 print(s21) 6 print(s22) 7 8 结果： 9 ['&&', 'peng&', 'jun%%*', 'fei***']10 ['', '', ' peng', ' jun%%* fei***'] 例子：加法计算器
1 content = input('请输入加法计算式：').strip() 2 print(content) 3 content_conl = content.split('+') 4 print(content_conl) 5 sum = 0 6 for i in content_conl: 7 sum += int(i) 8 print(sum) 9 10 结果：11 请输入加法计算式：5+8+9 +612 5+8+9 +613 ['5', '8', '9 ', '6']14 28
4、布尔值
1 while True:2 pass3 4 比5 6 while 1:7 pass8 9 要慢，因为True还得转换为1，增加了这个步骤则更多的耗时。
字符串转为布尔值：bool(str), 如果str为空则为False；如果不为空，哪怕为str里为0，结果为True。
5、列表(list)
列表的增删改查
5.1 增
append()：插入到列表的末尾
1 #增加append 2 #列表增加是直接增加，且加什么就是什么，即数字就是数字，加字符串就是字符串 3 my_list = ['peng','li',"quan",'钟'] 4 5 while 1: 6 name = input('请输入增加的名字：') 7 if name.strip().upper() == 'Q': 8 break 9 else:10 my_list.append(name)11 print(my_list)12 13 结果：14 请输入增加的名字：彭15 请输入增加的名字：全16 请输入增加的名字：钱三17 请输入增加的名字：q18 ['peng', 'li', 'quan', '钟', '彭', '全', '钱三'] insert()：插入到指定位置，即按索引去添加
1 my_list = ['peng','li',"quan",'钟']2 my_list.insert(2,'广东')3 print(my_list)4 5 结果：6 ['peng', 'li', '广东', 'quan', '钟']
extend()：按可迭代的元素增加，添加到最后，即增加的数据必须是可迭代的，如果只是一个整数则不可增加，因其不可迭代
1 my_list = ['peng','li',"quan",'钟'] 2 my_list.extend('abc') 3 print(my_list) 4 my_list.extend(['a','123','b,c,d']) 5 print(my_list) 6 my_list.extend('h') 7 print(my_list) 8 my_list.extend(25) 9 10 结果：11 ['peng', 'li', 'quan', '钟', 'a', 'b', 'c']12 File "E:/Python Project/05/Day4/List的增删改查.py", line 26, in 13 ['peng', 'li', 'quan', '钟', 'a', 'b', 'c', 'a', '123', 'b,c,d']14 ['peng', 'li', 'quan', '钟', 'a', 'b', 'c', 'a', '123', 'b,c,d', 'h']15 my_list.extend(25)16 TypeError: 'int' object is not iterable 5.2 删
pop() ：按索引去删除，有返回被删除值，如果没有输入参数则默认删除最后一个
1 my_list = ['peng','li',"quan",'钟']2 #pop() ：按索引去删除，有返回被删除值，如果没有输入参数则默认删除最后一个，3 my_list.pop(1)4 print(my_list)5 6 结果：7 ['peng', 'quan', '钟']
remove():按元素去删除，即输入具体要删除的元素
1 my_list = ['peng','li',"quan",'钟']2 #remove()：按元素去删除，即输入具体要删除的元素3 my_list.remove('quan')4 print(my_list)5 6 结果：7 ['peng', 'li', '钟'] clear()：清空列表
1 my_list = ['peng','li',"quan",'钟']2 #clear()：清空列表3 my_list.clear()4 print(my_list)5 6 结果：7 []
del ：切片的去删除
1 my_list = ['peng','li',"quan",'钟']2 #del[] ：切片删除3 del my_list[0:2]4 print(my_list)5 6 结果：7 ['quan', '钟']
1 my_list = ['peng','li',"quan",'钟']2 #del[] ：切片删除3 del my_list[2:]4 print(my_list)5 结果：6 ['peng', 'li']
5.3 改
按索引改：
1 my_list = ['peng','li',"quan",'钟']2 my_list[0] = 'zhang'3 print(my_list)4 结果：5 ['zhang', 'li', 'quan', '钟']
按切片改：
1 my_list = ['peng','li',"quan",'钟']2 #按切片去改3 my_list[0:2] = ["a,b,c",'中国']4 print(my_list)5 6 结果：7 ['a,b,c', '中国', 'quan', '钟']
5.4 查
按切片去查：
1 my_list = ['peng','li',"quan",'钟']2 3 print(my_list[1:3])4 结果：5 ['li', 'quan']
6、公共方法
len()：统计列表元素长度
1 my_list = ['peng','li',"quan",'钟',[1,2,3],'钟','钟三','钟','钱']2 Len = len(my_list)3 print(Len)4 结果：5 9
count()：统计指定元素的个数
1 my_list = ['peng','li',"quan",'钟',[1,2,3],'钟','钟三','钟','钱']2 num = my_list.count('钟') #统计指定元素的个数3 print(num)4 结果：5 3 index()：找到元素对应的索引，列表中通过元素找索引只有index
1 my_list = ['peng','li',"quan",'钟',[1,2,3],'钟','钟三','钟','钱']2 num = my_list.index('quan') #找到元素对应的索引，对列表进行通过元素找索引只有index()方法3 print(num)4 结果：5 2 1 my_list = ['peng','li',"quan",'钟',[1,2,3],'钟','钟三','钟','钱']2 num = my_list.index('钟') #找到元素对应的索引，对列表进行通过元素找索引只有index()方法3 print(num)4 结果：5 36 7 即返回第一次找到元素的索引 sort()：正向排序
1 my_list = [1,5,3,8,9,4,5,6,2,7,4]2 my_list.sort() #正向排序3 print(my_list)4 结果：5 [1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 9]
sort（reverse = True）：反向排序
1 my_list = [1,5,3,8,9,4,5,6,2,7,4]2 my_list.sort(reverse=True) #反向排序3 print(my_list)4 结果：5 [9, 8, 7, 6, 5, 5, 4, 4, 3, 2, 1]
reverse()：反转排序，即前后对应的元素对调
1 my_list = [1,5,3,8,9,4,5,6,2,7,4]2 my_list.reverse()3 print(my_list) #反转4 5 结果：6 [4, 7, 2, 6, 5, 4, 9, 8, 3, 5, 1]
7、列表的嵌套
1 #列表的嵌套2 list_nest = ['peng111',"abc",['quan',"zhang",23],"中国"]3 list_nest[2][1] = list_nest[2][1].capitalize() #把首字符变大写4 print(list_nest)5 结果：6 ['peng111', 'abc', ['quan', 'Zhang', 23], '中国']
6、元组（tuple）
元组是只读列表，可以读，元组的儿子不改写，但元组的儿子可能可以写
1 my_tuple = ('a','b','c',1,2,3,["peng",'qian'],"tuple")2 my_tuple[6][1] = my_tuple[6][1].upper()3 print(my_tuple)4 5 my_tuple[6].append("zhang")6 print(my_tuple)7 结果：8 ('a', 'b', 'c', 1, 2, 3, ['peng', 'QIAN'], 'tuple')9 ('a', 'b', 'c', 1, 2, 3, ['peng', 'QIAN', 'zhang'], 'tuple') 7、 range()用法
range的用法：顾头不顾尾，范围的大小变化方向不能与步长的方向相反，否则输出为空，即什么也不输出
1 for i in range(10): 2 print(i) 3 4 结果： 5 0 6 1 7 2 8 3 9 410 511 612 713 814 9
1 for i in range(1,10): 2 print(i) 3 结果： 4 1 5 2 6 3 7 4 8 5 9 610 711 812 9
1 for i in range(1,10,2):2 print(i)3 4 结果：5 16 37 58 79 9
1 for i in range(1,10,-2):2 print(i)3 结果：4 （为空，什么也没输出，因为范围的大小变化方向与步长方向相反）
1 for i in range(10,1,-2):2 print(i)3 结果：4 105 86 67 48 2
1 for i in range(10,1,2):2 print(i)3 结果：4 （为空，没有输出，因为范围的大小变化方向与步长方向相反）
8、字典
8.1 增
字典的增加就两种方式
第一种：直接按键来增加
1 my_dic = { 2 'name':['peng','quan'], 3 'age':[{ 'num':20,'num2':30}], 4 True:1, 5 (1,2,3):"junfei", 6 3:'B2' 7 } 8 9 my_dic['high'] = 175 #字典里面原来没有时候，就直接添加10 print(my_dic)11 my_dic['age'] = 25 #如果字典里面已经有了，那么就覆盖掉原来的12 print(my_dic)13 14 结果：15 { 'name': ['peng', 'quan'], 'age': [{ 'num': 20, 'num2': 30}], True: 1, (1, 2, 3): 'junfei', 3: 'B2', 'high': 175}16 { 'name': ['peng', 'quan'], 'age': 25, True: 1, (1, 2, 3): 'junfei', 3: 'B2', 'high': 175} 第二种：setdefault
1 my_dic.setdefault('weight')2 print(my_dic)3 my_dic.setdefault('name','li') #如果字典里面已经有相应的键值对，则不作任何改变，没有的话则添加4 print(my_dic)5 结果：6 { 'name': ['peng', 'quan'], 'age': [{ 'num': 20, 'num2': 30}], True: 1, (1, 2, 3): 'junfei', 3: 'B2', 'weight': None}7 { 'name': ['peng', 'quan'], 'age': [{ 'num': 20, 'num2': 30}], True: 1, (1, 2, 3): 'junfei', 3: 'B2', 'weight': None} 8.2 删
第一种：按确定键来删除某一个键值
1 my_dic = { 2 'name':['peng','quan'], 3 'age':[{ 'num':20,'num2':30}], 4 True:1, 5 (1,2,3):"junfei", 6 3:'B2' 7 } 8 print(my_dic.pop('age')) #有返回值，按键值去删除 9 print(my_dic)10 结果：11 [{ 'num': 20, 'num2': 30}]12 { 'name': ['peng', 'quan'], True: 1, (1, 2, 3): 'junfei', 3: 'B2'} 第二种：不确定将被删除的键是否在字典中
1 my_dic = { 2 'name':['peng','quan'], 3 'age':[{ 'num':20,'num2':30}], 4 True:1, 5 (1,2,3):"junfei", 6 3:'B2' 7 } 8 9 print(my_dic.pop('zhong',None)) #这里的None是在不确定字典里面是否有我们想删的键值时候用，即如果字典有10 # #要删的键则删除，如果没有不至于会报错，即可设置返回值11 print(my_dic)12 13 结果：14 None15 { 'name': ['peng', 'quan'], 'age': [{ 'num': 20, 'num2': 30}], True: 1, (1, 2, 3): 'junfei', 3: 'B2'} 第三种：直接删除最后一个键值
1 my_dic = { 2 'name':['peng','quan'], 3 'age':[{ 'num':20,'num2':30}], 4 True:1, 5 (1,2,3):"junfei", 6 3:'B2' 7 } 8 print(my_dic.popitem() ) #从3.6版本开始，就是直接删除最后一个，返回值为键值及Value组成的元组 9 print(my_dic)10 11 结果：12 (3, 'B2')13 { 'name': ['peng', 'quan'], 'age': [{ 'num': 20, 'num2': 30}], True: 1, (1, 2, 3): 'junfei'} 第四种：清空一个字典
1 my_dic = {2 'name':['peng','quan'],3 'age':[{ 'num':20,'num2':30}],4 True:1,5 (1,2,3):"junfei",6 3:'B2'7 }8 结果：9 为空，没有输出 第五钟：删除一个字典，删除以后，那个字典就不存在，如果还调勇print（）函数则报错
1 my_dic = { 2 'name':['peng','quan'], 3 'age':[{ 'num':20,'num2':30}], 4 True:1, 5 (1,2,3):"junfei", 6 3:'B2' 7 } 8 del my_dic 9 print(my_dic)10 11 结果：12 NameError: name 'my_dic' is not defined 8.3 改
第一种：覆盖
1 my_dic = { 2 'name':['peng','quan'], 3 'age':[{ 'num':20,'num2':30}], 4 True:1, 5 (1,2,3):"junfei", 6 3:'B2' 7 } 8 my_dic['age'] = 22 #改的第一种方式就是覆盖 9 print(my_dic)10 11 结果：12 { 'name': ['peng', 'quan'], 'age': 22, True: 1, (1, 2, 3): 'junfei', 3: 'B2'} 第二种：一个字典更新到另一个字典方式
1 my_dic2 = { "name":'peng','age':25,'hight':175} 2 my_dic3 = { 'name':'quan','sex':'fmale'} 3 4 my_dic3.update(my_dic2) #把my_dic2更新到my_dic3中，有键值的就覆盖，没有的就添加 5 print(my_dic2) 6 print(my_dic3) 7 8 结果： 9 { 'name': 'peng', 'age': 25, 'hight': 175}10 { 'name': 'peng', 'sex': 'fmale', 'age': 25, 'hight': 175} 8.4 查
第一种：查键
1 my_dic2 = { "name":'peng','age':25,'hight':175}2 print(my_dic2.keys(),type(my_dic2.keys())) #以列表形式保存键值3 4 结果：5 dict_keys(['name', 'age', 'hight']) 第二种：查值
1 my_dic2 = { "name":'peng','age':25,'hight':175}2 3 print(my_dic2.values(),type(my_dic2.values())) #以列表形式保存值4 5 结果：6 dict_values(['peng', 25, 175]) 第三种：查键值对
1 my_dic2 = { "name":'peng','age':25,'hight':175}2 print(my_dic2.items()) #以列表形式保存键值对3 4 结果：5 dict_items([('name', 'peng'), ('age', 25), ('hight', 175)]) 第四种：直接按键查找，查得到则返回键对应的值，查不到则报错
1 my_dic2 = { "name":'peng','age':25,'hight':175} 2 print(my_dic2['age']) #得到键对应的值 3 print(my_dic2['age3']) #如果没有这个键的话，就报错 4 5 结果： 6 25 7 Traceback (most recent call last): 8 File "E:/Python Project/05/Day5/dict.py", line 63, in 9 print(my_dic2['age3']) #如果没有这个键的话，就报错10 KeyError: 'age3' 第五种：get方法，查得到则返回键对应的值，查不到则返回None，或者返回自定义的值
1 print(my_dic2.get('hight'))2 print(my_dic2.get('age4')) #get的方法是查找这个键是否有，如果没有则返回None3 print(my_dic2.get('age4',"没有这个键")) #为了避免没有键时候返回None，我们加了“没有这个键”这个自定义返回值，辅助理解4 5 结果：6 1757 None8 没有这个键 8.5 字典在for循环引用中的不同
什么都不写，默认打印的是键
1 my_dic2 = { "name":'peng','age':25,'hight':175}2 for i in my_dic2:3 print(i) #什么都不写，默认打印的是键4 5 结果：6 name7 age8 hight 打印出键
1 my_dic2 = { "name":'peng','age':25,'hight':175}2 3 for i in my_dic2.keys(): #打印出键4 print(i)5 结果：6 name7 age8 hight 打印出值
my_dic2 = { "name":'peng','age':25,'hight':175}for i in my_dic2.values(): #打印出值 print(i)结果：peng25175 打印出元组形式的键值对
1 my_dic2 = { "name":'peng','age':25,'hight':175}2 for i in my_dic2.items(): #打印出键值对的元组，用括号包括3 print(i) #每次循环，i是元组4 5 结果：6 ('name', 'peng')7 ('age', 25)8 ('hight', 175) 直接打印出键及值，没有元组形式的那个括号
1 my_dic2 = { "name":'peng','age':25,'hight':175}2 for k,v in my_dic2.items():#直接打印出键值3 print(k,v)4 结果：5 name peng6 age 257 hight 175 8.6 字典的嵌套
1 my_dict = {2 'name':['peng','quan','li','zhang'],3 'chanpin':{ 'jiaoyan':10,4 "gongchen":4,5 "shengchan":86 },7 'age':258 } 直接改变值：
1 my_dict = { 2 'name':['peng','quan','li','zhang'], 3 'chanpin':{ 'jiaoyan':10, 4 "gongchen":4, 5 "shengchan":8 6 }, 7 'age':25 8 } 9 my_dict['age'] = 2210 print(my_dict)11 结果：12 { 'name': ['peng', 'quan', 'li', 'zhang'], 'chanpin': { 'jiaoyan': 10, 'gongchen': 4, 'shengchan': 8}, 'age': 22} 查找键对应的值
1 my_dict = { 2 'name':['peng','quan','li','zhang'], 3 'chanpin':{ 'jiaoyan':10, 4 "gongchen":4, 5 "shengchan":8 6 }, 7 'age':25 8 } 9 10 print(my_dict['chanpin'])11 结果：12 { 'jiaoyan': 10, 'gongchen': 4, 'shengchan': 8} 在相应键的值增加元素
1 my_dict = { 2 'name':['peng','quan','li','zhang'], 3 'chanpin':{ 'jiaoyan':10, 4 "gongchen":4, 5 "shengchan":8 6 }, 7 'age':25 8 } 9 my_dict["name"].append("liu")10 my_dict["chanpin"]["ruanjian"] = 1211 print(my_dict)12 结果：13 { 'name': ['peng', 'quan', 'li', 'zhang', 'liu'], 'chanpin': { 'jiaoyan': 10, 'gongchen': 4, 'shengchan': 8, 'ruanjian': 12}, 'age': 25} 9、集合
集合：可变的数据类型，它里面的元素必须是不可变的数据类型，且无序，不重复 假如要把列表里面的元素去重，那么直接把列表转变为集合即可。 增、删、查，没有改
set2 = set({1,2,3,4}) print(set2)set3 = {1,2,3,[4,5],{'name':'peng','age':20}} #集合里面不能是可变数据类型list、dict 9.1 增
第一种add
1 set2 = { 'peng','quan','li','zhang'}2 # #第一种add3 set2.add('lan')4 print(set2)5 6 结果：7 { 'li', 'quan', 'zhang', 'peng', 'lan'} 第二种updata
1 set2 = { 'peng','quan','li','zhang'}2 #第二种updata3 set2.update('zhu') #无序地把每个元素增加到集合中4 print(set2)5 结果：6 { 'z', 'h', 'zhang', 'li', 'quan', 'u', 'peng'} 9.2 删
pop()随机删除,返回被删除的元素
1 set2 = { 'peng','quan','li','zhang'}2 return2 = set2.pop()3 print(return2)4 print(set2)5 结果：6 li7 { 'peng', 'quan', 'zhang'} remove（），按元素去删,有则删，无则报错
1 set2 = { 'peng','quan','li','zhang'}2 set2.remove('peng')3 print(set2)4 结果：5 { 'quan', 'zhang', 'li'} clear()清空集合
1 set2 = { 'peng','quan','li','zhang'}2 set2.clear()3 print(set2)4 结果：5 set()6 set()表示空集合，是为了区分空字典set{} del 删除整个集合
1 set2 = { 'peng','quan','li','zhang'}2 del set23 print(set2)4 结果：5 Traceback (most recent call last):6 File "E:/Python Project/05/Day7/集合&深浅Copy.py", line 41, in 7 print(set2)8 NameError: name 'set2' is not defined 9.3 查
1 set2 = { 'peng','quan','li','zhang'}2 for i in set2:3 print(i)4 结果：5 peng6 quan7 li8 zhang9 这个结果每次是不一样的 9.4 交集
1 set3 = {2,3,4,5,6}2 set4 = {5,6,7,8,9,10}3 set5 = set3 & set44 print(set5)5 print(set3 & set4)6 print(set3.intersection(set4)) 结果：
1 {5, 6}2 {5, 6}3 {5, 6} 9.5并集
1 set3 = {2,3,4,5,6}2 set4 = {5,6,7,8,9,10}3 print(set3.union(set4)) 结果：
1 {2, 3, 4, 5, 6, 7, 8, 9, 10} 9.6反交集
1 set3 = {2,3,4,5,6}2 set4 = {5,6,7,8,9,10}3 print(set3 ^ set4)4 print(set3.symmetric_difference(set4)) 结果：
1 {2, 3, 4, 7, 8, 9, 10}2 {2, 3, 4, 7, 8, 9, 10} 9.7 差集
1 set3 = {2,3,4,5,6}2 set4 = {5,6,7,8,9,10}3 print(set3 - set4) #就是得到set3独有的元素 结果：
1 {2, 3, 4} 9.8 子集
1 set5 = {1,2,3}2 set6 = {1,2,3,4,5}3 print(set5 < set6) #需要set5里的元素全部包含在set6中4 print(set5.issubset(set6)) #说明set5是set6的子集 结果：
1 True2 True
9.9 超集
1 set5 = {1,2,3}2 set6 = {1,2,3,4,5}3 print(set6 > set5) #说明set6是set5的超集4 print(set6.issuperset(set5)) #说明set6是set5的超集 结果：
1 True2 True
9.10冻住
frozenet(),把set变为不可变数据类型（set本身是可变数据类型）
1 s2 = {1,2,3,'abc'}2 s2 = frozenset(s2)3 print(s2,type(s2)) 结果：
1 frozenset({1, 2, 3, 'abc'}) 10 深浅Copy
10.1 浅copy
在内存中重新创建了一个空间存放一个新列表，新列表中的元素与原列表中的元素是公用的。 例1：
1 l2 = [1,2,3]2 l3 = l2.copy()3 print(l2,l3)4 print(id(l2),id(l3))5 l3.append(4)6 print(l2,l3)
结果：
1 [1, 2, 3] [1, 2, 3]2 37365960 372172243 [1, 2, 3] [1, 2, 3, 4]
例2：
1 l2 = [1,2,'peng',[4,5,6],7]2 l3 = l2.copy()3 print(l2,id(l2))4 print(l3,id(l3))5 print(id(l2[-1]),id(l3[-1]))6 print(id(l2[-2]),id(l3[-2]))
结果：
1 [1, 2, 'peng', [4, 5, 6], 7] 435742162 [1, 2, 'peng', [4, 5, 6], 7] 437245523 1540514144 15405141444 43722952 43722952
10.2 深copy：deepcopy
新列表是在内存中新创建的，新列表中可变数据类型元素是新创建的，不可变数据类型元素是公用的 例1：
1 import copy 2 l2 = [1, 2, 'peng', [4, 5, 6], 7] 3 l3 = copy.deepcopy(l2) 4 print(l2,id(l2)) 5 print(l3,id(l3)) 6 print(id(l2[-1]),id(l3[-1])) 7 print(id(l2[-2]),id(l3[-2])) 8 print(id(l2[-3]),id(l3[-3])) 9 print(id(l2[-4]),id(l3[-4]))10 print(id(l2[-5]),id(l3[-5]))
结果：
1 [1, 2, 'peng', [4, 5, 6], 7] 440512082 [1, 2, 'peng', [4, 5, 6], 7] 440505043 1540514144 15405141444 44052232 440784085 35109440 351094406 1540513984 15405139847 1540513952 1540513952