python3基础二——基本的数据类型三

1 word=‘字符串‘
2 sentence="字符串\n"  #python中单引号和双引号使用完全相同
3 paragraph="""这是一个段落
4 可以有多行组成"""   #使用三引号(‘‘‘或""")可以指定一个多行字符串
5 print(word,sentence,paragraph)
6 ----------------------------------------------------------------------------
7 字符串 字符串 
8 这是一个段落
9 可以有多行组成

 1 # 字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始
 2 str=‘Runoob‘ 
 3 print(str)        # 输出字符串
 4 print(str[0])     # 输出字符串第一个字符R
 5 print(str[0:-1])  # 输出第一个到倒数第二个的所有字符,0<=内容<-1
 6 print(str[2:5])   # 输出从第三个开始到第五个的字符
 7 print(str[2:])    # 输出从第三个开始的后的所有字符
 8 print(str[0:])    # 输出所有字符等同于print（str[:])等同于print(str)
 9 print(str*2)      # 输出字符串两次，用 * 运算符重复
10 print(str+‘你好‘) # 连接字符串，用 + 运算符连接在一起
11 print(str[::2])   # 第一个冒号两侧的数字是指截取字符串的范围,第二个冒号后面是指截取的步长。
12 
13 ---------------------------------------------------------------------
14 Runoob
15 R
16 Runoo
17 noo
18 noob
19 Runoob
20 RunoobRunoob
21 Runoob你好
22 Rno

1 str=‘Runoob\n‘      # 反斜杠 ‘\‘可以用来转义，\n换行
2 str2=r‘Runoob\n‘  # 使用r可以让反斜杠不发生转义
3 print(str)        # 输出字符串
4 print(str2)
5 ------------------------------------------------------
6 Runoob
7 
8 Runoob\n

1 print("我叫 %s 今年 %d 岁"%(‘小明‘,10))
2 ------------------------------------------
3 我叫 小明 今年 10 岁

 1 name="李璐"
 2 for i in name:
 3     print(i)#for循环每一个元素是“字符”
 4     print(bytes(i,encoding=‘utf-8‘))#把i转换为字节形式，以16进制表示，字符变字节
 5     for b in bytes(i,encoding=‘utf-8‘):
 6         print(b)#for循环输出每一个元素（字节）是以十进制形式
 7         print(bin(b))#bin()把一个字节（十进制的数）用二进制表示
 8 #一个汉字三个字节，
 9 #bytes可以将字符串准换位字节
10 #字节：用16进制表示的二进制
11 ----------------------------------------------------
12 李
13 b‘\xe6\x9d\x8e‘
14 230
15 0b11100110
16 157
17 0b10011101
18 142
19 0b10001110
20 璐
21 b‘\xe7\x92\x90‘
22 231
23 0b11100111
24 146
25 0b10010010
26 144
27 0b10010000

 1 #对于字符串只有encode编码功能，把字符串转换为bytes字节类型，16进制字节
 2 var1 = ‘你好，世界!‘
 3 print(var1)
 4 #encode(encoding=‘UTF-8‘,errors=‘strict‘)以指定的编码格式编码字符串,默认utf-8和strict
 5 # errors参数可以指定不同的错误处理方案,默认为 ‘strict‘,意为编码错误引起一个UnicodeError。
 6 # 其他可能得值有 ‘ignore‘, ‘replace‘, ‘xmlcharrefreplace‘,‘backslashreplace‘以及通过codecs.register_error()注册的任何值。
 7 print(var1.encode())#返回编码后的字符串，它是一个 bytes 对象
 8 
 9 
10 
11 #对于bytes字节类型只有解码功能，把bytes类型转换为字符串
12 print(var1.encode().decode())
13 --------------------------------------------------------------------------------
14 你好，世界!
15 b‘\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c!‘
16 你好，世界!

 1 a1=‘alex\tis Alph ‘
 2 print(len(a1))        #获取字符串长度
 3 print(a1.capitalize())#首字母变大写
 4 print(a1.center(20,"*"))#center(self, width, fillchar=None)内容居中，长度设定，其他填充设定
 5 print(a1.count(‘al‘,0,9))#count(self, sub, start=None, end=None)计算指定范围内子序列出现的次数
 6 print(a1.encode(‘utf-8‘))#encoding 指定的编码格式解码 str
 7 print(a1.endswith(‘l‘,0,2))#endswith(self, suffix, start=None, end=None)指定范围内是否以XXX结尾
 8 print(a1.expandtabs())#将tab转换成空格，默认一个tab转换成8个空格
 9 print(a1.find(‘ex‘))#find(self, sub, start=None, end=None)从左往右在指定范围寻找子序列位置，如果没找到，返回 -1
10 print(a1.format())#字符串格式化，动态参数
11 print(a1.index(‘a‘))#在指定范围寻找子序列位置，子序列位置，如果没找到，报错
12 print(a1.isalnum())#是否全是字母和数字
13 print(a1.isalpha())#是否全是字母
14 print(a1.isdigit())#是否全是数字
15 print(a1.islower())#是否小写
16 print(a1.isspace())#是否空格
17 print(a1.istitle())#是否标题，首字母全大写
18 print(a1.isupper())#是否全部大写
19 print(‘-‘.join(a1))#个个单位之间用符号连接
20 print(a1.join(‘333333‘))#字符串之间链接
21 print(a1.ljust(20,‘*‘))#内容左对齐，右侧填充
22 print(a1.lower())#变小写
23 print(a1.strip())#去除两边空格
24 print(a1.partition(‘s‘))#分割，前，中，后三部分
25 print(a1.replace(‘l‘,‘kb‘,2))#替换,从左往右几个
26 print(a1.split(‘l‘,1))#分割，有几个分几部分，可以指定几个分割
27 print(a1.startswith(‘a‘))#startswith(self, prefix, start=None, end=None)是否起始
28 print(a1.splitlines())#根据换行分割
29 print(a1.swapcase())#大写变小写，小写变大写
30 print(a1.title())#标题化
31 print(a1.upper())#全大写
32 --------------------------------------------------------------------------------------
33 13
34 Alex    is alph 
35 ***alex    is Alph ****
36 1
37 b‘alex\tis Alph ‘
38 True
39 alex    is Alph 
40 2
41 alex    is Alph 
42 0
43 False
44 False
45 False
46 False
47 False
48 False
49 False
50 a-l-e-x-    -i-s- -A-l-p-h- 
51 3alex    is Alph 3alex    is Alph 3alex    is Alph 3alex    is Alph 3alex    is Alph 3
52 alex    is Alph *******
53 alex    is alph 
54 alex    is Alph
55 (‘alex\ti‘, ‘s‘, ‘ Alph ‘)
56 akbex    is Akbph 
57 [‘a‘, ‘ex\tis Alph ‘]
58 True
59 [‘alex\tis Alph ‘]
60 ALEX    IS aLPH 
61 Alex    Is Alph 

 1 #zip（）遍历多个序列
 2 questions = [‘name‘, ‘quest‘, ‘favorite color‘]
 3 answers = [‘lancelot‘, ‘the holy grail‘, ‘blue‘]
 4 for q, a in zip(questions, answers):
 5      print(‘What is your {0}?  It is {1}.‘.format(q, a))
 6 
 7 #enumerate() 函数同时得到索引和值
 8 for i, v in enumerate([‘tic‘, ‘tac‘, ‘toe‘]):
 9     print(i, v)
10 
11 #reversed() 函数反向遍历
12 for i in reversed(range(1, 10, 2)):
13      print(i)
14 
15 #sorted() 函数 顺序遍历
16 basket = [‘apple‘, ‘orange‘, ‘apple‘, ‘pear‘, ‘orange‘, ‘banana‘]
17 for f in sorted(set(basket)):
18     print(f)
19 ------------------------------------------------------------------------------
20 What is your name?  It is lancelot.
21 What is your quest?  It is the holy grail.
22 What is your favorite color?  It is blue.
23 0 tic
24 1 tac
25 2 toe
26 9
27 7
28 5
29 3
30 1
31 apple
32 banana
33 orange
34 pear

1 #列表，方括号内,逗号分隔
2 # 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可
3 list1=[‘a‘,‘goole‘,1995,"2000"]#列表可包含任何数据类型的元素，单个列表中的元素无须全为同一类型
4 print(list1)
5 --------------------------------------------------------------
6 [‘a‘, ‘goole‘, 1995, ‘2000‘]

 1 list1=[‘a‘,‘goole‘,1995,"2000"]#列表可包含任何数据类型的元素，单个列表中的元素无须全为同一类型
 2 print(list1)
 3 print(list1[0])                #列表索引从0开始
 4 print(list1[1:5])              #使用方括号的形式截取字符成一个子列表，冒号使用和字符串中一样
 5 list1[2]=2001                  #直接赋值对列表的数据项进行修改或更新，
 6 print(list1)
 7 del list1[2]                   #del语句删除列表的元素
 8 print(list1)
 9 print(len(list1))              #len()表示列表的长度
10 print(list1+[1,2,3])           #+组合，拼接列表
11 print(list1*2)                 #*重复
12 print(‘a‘ in list1)            #in元素是否存在于列表中
13 for i in list1:
14     print(i,end=‘ ‘)           #迭代
15 ------------------------------------------------------------------------------
16 [‘a‘, ‘goole‘, 1995, ‘2000‘]
17 a
18 [‘goole‘, 1995, ‘2000‘]
19 [‘a‘, ‘goole‘, 2001, ‘2000‘]
20 [‘a‘, ‘goole‘, ‘2000‘]
21 3
22 [‘a‘, ‘goole‘, ‘2000‘, 1, 2, 3]
23 [‘a‘, ‘goole‘, ‘2000‘, ‘a‘, ‘goole‘, ‘2000‘]
24 True
25 a goole 2000 

 1 #嵌套
 2 a = [‘a‘, ‘b‘, ‘c‘]
 3 n = [1, 2, 3]
 4 x = [a, n]
 5 print(x)
 6 print(x[0])
 7 print(x[0][1])
 8 ----------------------------------------
 9 [[‘a‘, ‘b‘, ‘c‘], [1, 2, 3]]
10 [‘a‘, ‘b‘, ‘c‘]
11 b

 1 #append and extend
 2 list1=[‘google‘,1995,"Tabo"]
 3 list1.append(‘baidu‘)           #调用append()方法向列表的尾部添加一个新的元素,只能一个元素
 4 print(list1)                    #输出更新后的list1
 5 list1.extend([‘2‘,‘baidu ‘])    #list.extend(seq)， seq -- 元素列表
 6 list1.extend(range(5))          #只能是单个元素或单个列表
 7 print(list1)                    #调用extend()函数在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
 8 # 列表是以类的形式实现的。"创建"列表实际上是将一个类实例化。因此，列表有多种方法可以操作。
 9 # extend()方法只接受一个列表作为参数，并将该参数的每个元素都添加到原有的列表中。
10 -------------------------------------------------------------------------------------
11 [‘google‘, 1995, ‘Tabo‘, ‘baidu‘]
12 [‘google‘, 1995, ‘Tabo‘, ‘baidu‘, ‘2‘, ‘baidu ‘, 0, 1, 2, 3, 4]

1 age=[1,2,3,5,6,7]
2 age.insert(3,4)
3 #本来序号 3 的位置是5
4 #插入 4
5 #后面的元素向后移
6 print(age)
7 ----------------------------------------------------
8 [1, 2, 3, 4, 5, 6, 7]

1 #移除pop and remove
2 list1=[‘google‘,1995,"Tabo",‘2222‘,‘baidfu‘,3332]
3 list1.pop()      #pop()函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
4 print(list1)
5 list1.remove(1995)#remove()函数用于移除列表中某个值的第一个匹配项
6 print(list1)     #该方法没有返回值但是会移除列表中的某个值的第一个匹配项。
7 --------------------------------------------------------------------------------------------
8 [‘google‘, 1995, ‘Tabo‘, ‘2222‘, ‘baidfu‘]
9 [‘google‘, ‘Tabo‘, ‘2222‘, ‘baidfu‘]

1 #排序reverse and sort
2 list1=[‘google‘,‘1995‘,"Tabo",‘2222‘,‘baidfu‘,‘3332‘]
3 list1.reverse()  #reverse() 函数用于反向列表中元素
4 print(list1)     #该方法没有返回值，但是会对列表的元素进行反向排序。
5 list1.sort()     #sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
6 print(list1)      #sort排序必须列表中的元素要是同一类型
7 ------------------------------------------------------------------------------
8 [‘3332‘, ‘baidfu‘, ‘2222‘, ‘Tabo‘, ‘1995‘, ‘google‘]
9 [‘1995‘, ‘2222‘, ‘3332‘, ‘Tabo‘, ‘baidfu‘, ‘google‘]

1 #sort(self, key=None, reverse=False)
2 #sort默认从小到大（reverse=False）
3 #reverse=True则改为从大到小
4 l=[2,4,5,7,3,5,9,2,4]
5 l.sort(reverse=True)#从大到小
6 print(l)
7 ---------------------------------------------
8 [9, 7, 5, 5, 4, 4, 3, 2, 2]

 1 a1=[5,6,5,91,1,64,]
 2 print(a1)
 3 
 4 a2=sorted(a1)#sorted函数排序列表，但不改变列表
 5 print(a2)#排序后的列表
 6 print(a1)#列表本身没有改变
 7 ------------------------------------------------------------------
 8 [5, 6, 5, 91, 1, 64]
 9 [1, 5, 5, 6, 64, 91]
10 [5, 6, 5, 91, 1, 64]

 1 # 使用=直接赋值，是引用赋值，更改一个，另一个同样会变, 例子中的a,b改变两次都影响到了对方
 2 # copy() 则顾名思义，复制一个副本，原值和新复制的变量互不影响 「a,c」
 3 a=[0,1,2,3,4,5]
 4 b=a
 5 c=a.copy()
 6 del a[1]
 7 print(id(a),id(b),id(c))#copy后内存地址不同
 8 print(a,b,c)
 9 b.remove(4)
10 print(a,b,c)
11 c.append(9)
12 print(a,b,c)
13 ---------------------------------------------------
14 91198088 91198088 91198528
15 [0, 2, 3, 4, 5] [0, 2, 3, 4, 5] [0, 1, 2, 3, 4, 5]
16 [0, 2, 3, 5] [0, 2, 3, 5] [0, 1, 2, 3, 4, 5]
17 [0, 2, 3, 5] [0, 2, 3, 5] [0, 1, 2, 3, 4, 5, 9]

 1 a=[2,4,5,7,3,5,9,2,4]
 2 a2=a[:]#把列表重新拷贝一份，再把它赋值a2，a2和a不一样
 3 a3=a   #把a3指向a,相当于给a指向的列表又贴上a3这个标签，a3和a完全一样
 4 print(a,a2,a3,sep=‘\n‘)
 5 print(id(a),id(a2),id(a3))
 6 a.sort()
 7 print(a,a2,a3,sep=‘\n‘)
 8 ---------------------------------------------
 9 [2, 4, 5, 7, 3, 5, 9, 2, 4]
10 [2, 4, 5, 7, 3, 5, 9, 2, 4]
11 [2, 4, 5, 7, 3, 5, 9, 2, 4]
12 89328216 89329256 89328216
13 [2, 2, 3, 4, 4, 5, 5, 7, 9]
14 [2, 4, 5, 7, 3, 5, 9, 2, 4]
15 [2, 2, 3, 4, 4, 5, 5, 7, 9]

 1 list1=[‘google‘,1995,"Tabo",‘2222‘,‘baidfu‘,3332]
 2 print(list1.count(‘2‘))   #count()方法用于统计某个元素在列表中出现的次数。
 3 print(list1.index(1995))     #index()函数用于从列表中c从左往右找出某个值第一个匹配项的索引位置。
 4 # print(list1.index(7)) 如果没有找到对象则抛出异常
 5 list1.insert(1,‘baidu‘)   #insert()函数用于将指定对象插入列表的指定位置。
 6 print(list1)
 7 list1.copy()   #copy() 函数用于复制列表，类似于 a[:]。
 8 print(list1)
 9 list1.clear() #clear()函数用于清空列表，类似于 del a[:]。
10 print(list1)   #返回空列表
11 #d=a[:] 对于单一列表一般情况下复制得到一个新列表并改变新列表内元素而不影响原列表。
12 list_empty = [None]*10
13 print(list_empty)
14 -------------------------------------------------------
15 0
16 1
17 [‘google‘, ‘baidu‘, 1995, ‘Tabo‘, ‘2222‘, ‘baidfu‘, 3332]
18 [‘google‘, ‘baidu‘, 1995, ‘Tabo‘, ‘2222‘, ‘baidfu‘, 3332]
19 []
20 [None, None, None, None, None, None, None, None, None, None]

 1 # i=list()/i=[]创建空列表
 2 print([i for i in range(10)])
 3 #输出一个列表，对于range（10）中的每一个元素i，输出i，添加到列表
 4 print([i*i for i in range(10)])
 5 ##输出一个列表，对于range（10）中的每一个元素i，把i平方，添加到列表
 6 print([i*i for i in range(10)if i%2==0])
 7 #输出一个列表，对于range（10）中的每一个满足条件是偶数的元素i，把i平方，添加到列表
 8 print([1 if x%2==0 else -1 for x in range(10)])
 9 #输出一个列表，列表满足：对于在range(10)中的每一个元素x，判断是否是偶数，如果是输出1，否则输出-1
10 
11 
12 #相当于print([i for i in range(10)])
13 # for j in range(10):
14 #     i.append(j)
15 # print(i)
16 --------------------------------------------------------------------
17 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
18 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
19 [0, 4, 16, 36, 64]
20 [1, -1, 1, -1, 1, -1, 1, -1, 1, -1]

 1 a1=1#只有一个元素，表示创建一个int类型(或str类型)的元素
 2 print(a1,type(a1))
 3 a2=1,#不仅有一个元素，还有逗号，表示创建的是元组类型
 4 print(a2,type(a2))
 5 
 6 a3=(1)#虽然用括号括起，但只有一个元素，表示创建一个int类型(或str类型)的元素
 7 print(a3,type(a3))
 8 a4=(1,)#不但用括号括起，还有逗号，表示创建的是元组类型
 9 print(a4,type(a4))
10 
11 a5=2,3,4#虽然没有用括号括起，但它是用逗号隔开的一组元素，默认创建一个元组
12 print(a5,type(a5))
13 a6=(2,3,4)#既用括号括起，括号中又包含逗号，表示创建的是源自
14 print(a6,type(a6))
15 
16 a7=()#创建空元组，用空括号表示
17 print(a7,type(a7))
18 -----------------------------------------------------------------------------------
19 1 <class ‘int‘>
20 (1,) <class ‘tuple‘>
21 1 <class ‘int‘>
22 (1,) <class ‘tuple‘>
23 (2, 3, 4) <class ‘tuple‘>
24 () <class ‘tuple‘>

 1 tuple1=(‘google‘)
 2 print(type(tuple1))#不加逗号，被当成字符串或整型
 3 tuple2=(‘google‘,)
 4 print(type(tuple2))#元组中只包含一个元素时，需要在元素后面添加逗号
 5 tup1=(‘goole‘,1997,‘1203‘,"runboon")
 6 print(tup1[2])  #元组可以使用下标索引来访问元组中的值
 7 print(tup1[1:3])#切片
 8 
 9 #元组中的元素值是不允许修改的,比如赋值是不可操作的，但我们可以对元组进行连接组合,del删除，
10 tup2=(12,33)
11 print(tup1+tup2)  #+拼接
12 del tup2          #del删除
13 #count(计数)       index（索引查找）
14 --------------------------------------------------------------------
15 <class ‘str‘>
16 <class ‘tuple‘>
17 1203
18 (1997, ‘1203‘)
19 (‘goole‘, 1997, ‘1203‘, ‘runboon‘, 12, 33)

1 tup1=(‘goole‘,1997,‘1203‘,"runboon",1997,1997)
2 #计算并返回指定元素的数量
3 print(tup1.count(1997))
4 
5 #寻找并返回参数索引值
6 print(tup1.index(1997))
7 ----------------------------------------
8 3
9 1

1 aTuple=(123,‘goole‘,"taobaoo")
2 print(aTuple)
3 print(list(aTuple))             #将元组转换为列表，元素相对应
4 str="hello  world"
5 print(list(str))                #将字符串转换为列表，元素相对应
6 ----------------------------------------------------------------------------
7 (123, ‘goole‘, ‘taobaoo‘)
8 [123, ‘goole‘, ‘taobaoo‘]
9 [‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘ ‘, ‘ ‘, ‘w‘, ‘o‘, ‘r‘, ‘l‘, ‘d‘]

 1 a=(‘xi‘,‘212‘,14324,‘125‘)
 2 print(a,id(a))
 3 a=a[:2]+(‘s‘,)+a[2:]
 4 #元组的元素不能删除或修改
 5 #序列有切片和拼接操作
 6 #实质上是：先把a的前两位拿出来，再把a的后面元素拿出来，
 7 #再与要插入的元组进行拼接，形成一个新的元组，并把它赋值给a
 8 #a本来指向远离的元组，操作后让a指向一个新元组，实现形式上的更新
 9 print(a,id(a))
10 -----------------------------------------------------
11 (‘xi‘, ‘212‘, 14324, ‘125‘) 81034384
12 (‘xi‘, ‘212‘, ‘s‘, 14324, ‘125‘) 80194368

1 #元组可以用del函数来删除整个元组，但元组中的元素不能直接删除
2 #类似元组的更新，元组中的元素也可以使用切片拼接操作进行形式上的删除
3 a=(‘xi‘,‘212‘,14324,‘125‘)
4 print(a,id(a))
5 a=a[:1]+a[1:]
6 print(a,id(a))
7 ----------------------------------------------------------
8 (‘xi‘, ‘212‘, 14324, ‘125‘) 46759056
9 (‘xi‘, ‘212‘, 14324, ‘125‘) 82679008

 1 dict1={
 2     ‘Alice‘:‘2341‘,#键必须是唯一的，但值则不必。
 3     ‘Celf‘:8,      #值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
 4     333:(‘sc‘,‘ss‘),
 5 }
 6 print(dict1)
 7 print(dict1[‘Alice‘])#把相应的键放入熟悉的方括弧，访问字典里的值
 8 # print(dict1[‘s‘])如果用字典里没有的键访问数据，会输出错误
 9 dict1[‘name‘]=‘alex‘   #赋值添加信息
10 dict1[‘Celf‘]=100      #赋值更新
11 print(dict1)
12 del dict1[‘name‘]      # 删除键 ‘name‘
13 print(dict1)
14 dict1.clear()          # 清空字典
15 print(dict1)
16 # del dict1            # 删除字典，可能会引发异常
17 ------------------------------------------------------------------------------------
18 {‘Alice‘: ‘2341‘, ‘Celf‘: 8, 333: (‘sc‘, ‘ss‘)}
19 2341
20 {‘Alice‘: ‘2341‘, ‘Celf‘: 100, 333: (‘sc‘, ‘ss‘), ‘name‘: ‘alex‘}
21 {‘Alice‘: ‘2341‘, ‘Celf‘: 100, 333: (‘sc‘, ‘ss‘)}
22 {}

 1 # 字典内置函数len（）（计算键总数）  str(dict)   type(variable)
 2 dict1={
 3     ‘Name‘: ‘Runoob‘,
 4     ‘Age‘: 7,
 5     ‘Class‘: ‘First‘
 6 }
 7 print(dict1)
 8 print(len(dict1))  #计算字典元素个数，即键的总数
 9 print(str(dict1))  #输出字典，以可打印的字符串表示。
10 print(type(dict1)) #返回输入的变量类型，
11 ---------------------------------------------------------
12 {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
13 3
14 {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
15 <class ‘dict‘>

 1 #dict函数
 2 dict1={
 3     ‘Name‘: ‘Runoob‘,
 4     ‘Age‘: 7,
 5     ‘Class‘: ‘First‘
 6 }
 7 print(dict1.copy())           #Python 字典 copy() 函数返回一个字典的浅复制。
 8 print(dict1.fromkeys((‘name‘,‘age‘,‘sex‘,‘s‘),10))#创建一个新字典,改变键和值，旧字典不变
 9 print(dict1.get(‘name‘))      #get() 函数返回指定键的值，如果值不在字典中返回默认值
10 if ‘Age‘ in dict1:            # in 操作符用于判断键是否存在于字典中
11     print(‘zai‘)
12 print(dict1.setdefault(‘age‘))#如果键不存在于字典中，将会添加键并将值设为默认值。相当于get()
13 print(dict1.items())          #items() 方法以列表返回可遍历的(键, 值) 元组数组。
14 for i,j in dict1.items():
15     print(i, ":\t", j)
16 print(dict1.keys())           # keys()方法以列表返回一个字典所有的键
17 print(list(dict1.keys()))     #若要返回列表值还需调用list函数。
18 print(dict1.values())         #values()方法以列表返回字典中的所有值。
19 dict1.update({‘Sex‘:‘female‘})#update()函数把字典dict2的键/值对更新到dict里。
20 print(dict1)
21 dict1.pop(‘Name‘)             #pop()删除字典给定键key所对应的值，返回值为被删除的值。key值必须给出。
22 print(dict1)
23 print(dict1.popitem())        #popitem()随机返回并删除字典中的一对键和值(一般删除末尾对)
24 print(dict1)
25 ------------------------------------------------------------------------------
26 {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
27 {‘name‘: 10, ‘age‘: 10, ‘sex‘: 10, ‘s‘: 10}
28 None
29 zai
30 None
31 dict_items([(‘Name‘, ‘Runoob‘), (‘Age‘, 7), (‘Class‘, ‘First‘), (‘age‘, None)])
32 Name :     Runoob
33 Age :     7
34 Class :     First
35 age :     None
36 dict_keys([‘Name‘, ‘Age‘, ‘Class‘, ‘age‘])
37 [‘Name‘, ‘Age‘, ‘Class‘, ‘age‘]
38 dict_values([‘Runoob‘, 7, ‘First‘, None])
39 {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘, ‘age‘: None, ‘Sex‘: ‘female‘}
40 {‘Age‘: 7, ‘Class‘: ‘First‘, ‘age‘: None, ‘Sex‘: ‘female‘}
41 (‘Sex‘, ‘female‘)
42 {‘Age‘: 7, ‘Class‘: ‘First‘, ‘age‘: None}

1 # 字典生成式
2 zifu=‘beijing‘
3 print({letter:zifu.count(letter) for letter in zifu})
4 #对于zifu中的元素letter，生成一个字典，键是letter元素，只是出现的个数
5 -----------------------------------------------------------------------------------
6 {‘b‘: 1, ‘e‘: 1, ‘i‘: 2, ‘j‘: 1, ‘n‘: 1, ‘g‘: 1}

1 #适用于列表中字典都存在某一键
2 a=[{‘xuhao‘:34,‘age‘:27},
3    {‘xuhao‘:21,‘age‘:62},
4    {‘xuhao‘:2,‘age‘:19},
5    {‘xuhao‘:35,‘age‘:66}]
6 a.sort(key=lambda x:x[‘xuhao‘])
7 print(a)
8 -----------------------------------------------
9 [{‘xuhao‘: 2, ‘age‘: 19}, {‘xuhao‘: 21, ‘age‘: 62}, {‘xuhao‘: 34, ‘age‘: 27}, {‘xuhao‘: 35, ‘age‘: 66}]

1 a=[1,2,3,4,5]
2 b=[‘a‘,‘b‘,‘c‘,‘d‘]
3 c=dict(zip(a,b))
4 print(c)
5 ----------------------------------------
6 {1: ‘a‘, 2: ‘b‘, 3: ‘c‘, 4: ‘d‘}

 1 student = {‘Tom‘, ‘Jim‘, ‘Mary‘, ‘Tom‘, ‘Jack‘, ‘Rose‘}
 2 print(student)     # 输出集合，重复的元素被自动去掉
 3 #成员测试
 4 if(‘Rose‘ in student) :
 5     print(‘Rose 在集合中‘)
 6 else :
 7     print(‘Rose 不在集合中‘)
 8 ----------------------------------------------------------------------------
 9 {‘Rose‘, ‘Tom‘, ‘Mary‘, ‘Jack‘, ‘Jim‘}
10 Rose 在集合中

 1 # set可以进行集合运算
 2 a = set(‘abracadabra‘)
 3 b = set(‘alacazam‘)
 4 print(a)
 5 print(a - b)  # a和b的差集
 6 print(a | b)  # a和b的并集
 7 print(a & b)  # a和b的交集
 8 print(a ^ b)  # a和b中不同时存在的元素
 9 ---------------------------------------------------------------------------------
10 {‘r‘, ‘b‘, ‘d‘, ‘c‘, ‘a‘}
11 {‘d‘, ‘r‘, ‘b‘}
12 {‘r‘, ‘b‘, ‘m‘, ‘d‘, ‘c‘, ‘a‘, ‘z‘, ‘l‘}
13 {‘c‘, ‘a‘}
14 {‘r‘, ‘z‘, ‘m‘, ‘b‘, ‘l‘, ‘d‘}