一.字符串str
1.创建字符串，为变量分配一个值
1 word='字符串'
2 sentence="字符串\n" #python中单引号和双引号使用完全相同
3 paragraph="""这是一个段落
4 可以有多行组成""" #使用三引号('''或""")可以指定一个多行字符串
5 print(word,sentence,paragraph)
6 ----------------------------------------------------------------------------
7 字符串 字符串
8 这是一个段落
9 可以有多行组成
2.字符串不能改变，只是创建了一个新的字符串，又重新给变量赋值，原字符串并不会改变
3.没有单独的字符类型，一个字符就是长度为 1 的字符串
4.Python 不支持单字符类型，单字符也在Python也是作为一个字符串使用
5.Python2中普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，Python3所有的字符串都是Unicode字符串。
6.Python 访问子字符串，可以使用方括号来截取字符串
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
7.转义字符以及使用r可以让反斜杠不发生转义
1 str='Runoob\n' # 反斜杠 '\'可以用来转义，\n换行
2 str2=r'Runoob\n' # 使用r可以让反斜杠不发生转义
3 print(str) # 输出字符串
4 print(str2)
5 ------------------------------------------------------
6 Runoob
7
8 Runoob\n
8.字符串运算符
9.字符串格式化：将一个值插入到一个有字符串格式符 %s 的字符串中。还可以用format()进行格式化
1 print("我叫 %s 今年 %d 岁"%('小明',10))
2 ------------------------------------------
3 我叫 小明 今年 10 岁
10.占位符
其他：%-左对齐、%+右对齐，%0用0补齐空格
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 你好，世界!
11.函数
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
12.str
(1)一般函数：startswith、endwith、count、find...
(2)判断字符串：islower、isupper、isdigit、isalpha...
(3)操作类函数：lower、upper、strip/rstrip/lstrip、swapcase(交换大小写)...
13.字符串函数分类：
(1).查找计算：len、find、rfind、index、rindex、count
(2).转换：replace、capitalize、title、lower、upper、
(3).填充压缩：ljust、rjust、center、lstrip、rstrip
(4).分割拼接：split、partition、rpartition、splitlines、join
(5).判定：isalpha、isdigit、isalnum、isspace、startswith、endswith、
二.序列
1.序列是Python中最基本的数据结构
2.序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。每个索引对应一个元素，最后一个索引是-1
3.Python包含6种内建的序列，包括列表、元组、字符串、Unicode字符串、buffer对象和xrange对象
4.序列通用操作：索引，切片，加，乘，成员检查，计算序列的长度，取序列中的最大、最小值
5.索引：获取单个元素[ ];切片：获取子序列[ : ];加：连接相同序列+；乘：重复序列中所有的元素*；成员检查in;计算长度len（）；取最大最小值max（），min()
6.索引和切片是不同的：比如list[0]返回第0个元素的值，list[0:1]返回一个只含第0个元素的列表
7.序列的遍历
（1）在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来
（2）在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到，以0开始
（3）同时遍历两个或更多的序列，可以使用 zip() 组合
（4）要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数
（5）要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值
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
8.序列的切片和拼接操作可以实现形式上的序列的更新和删除
三.列表
1.创建列表
1 #列表，方括号内,逗号分隔
2 # 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可
3 list1=['a','goole',1995,"2000"]#列表可包含任何数据类型的元素，单个列表中的元素无须全为同一类型
4 print(list1)
5 --------------------------------------------------------------
6 ['a', 'goole', 1995, '2000']
2.列表作为一个序列，有序列的通用功能：索引，切片，加，乘，成员检查，计算序列的长度，取序列中的最大、最小值
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
3.嵌套列表
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
4.列表元素可以通过直接赋值对列表的数据项进行修改或更新
5.添加末尾元素append and extend,其中append(一个列表元素)，extend(一个列表)
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]
6.在指定位置插入元素insert
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]
7.移除pop and remove,其中pop(索引值0，-1，3...),remove(单个列表对象)
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']
8.排序reverse and sort
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]
*sorted函数
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]
9.复制copy和赋值
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]
10.其他
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]
（列表推导式（列表解析）：各语句之间是嵌套关系，左边第二个语句是最外层，依次往右进一层）[有关A的表达式 for A in B]
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]
11.补充
（1）标准的python中列表保存一组值，实际上保存的是对象的指针，可以指向任何对象，即列表的元素可以是任何对象
（2）将列表当做堆栈使用，append添加，pop移除
（3）可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来，append添加，popleft移除
12.列表
(1).增：append、extend、insert
(2).删：del语句、pop、remove
(3).改：直接赋值改
(4).查：index、count
(5).其他：排序：sorted、反转：reverse
四.元组
1.Python 的元组与列表类似，不同之处在于元组的元素不能添加、删除或修改,但元素的元素可变
2.元组也是一组逗号隔开的序列，一般使用小括号（）括起来或直接用逗号隔开，表现出来的形式都是用小括号括起的序列；当仅有一个元素表示元组时，必须加逗号
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'>
3.元组
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)
4.元组仅有两个方法：count()和index()
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
5.元组与列表相互转换
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']
6.元组的‘更新’和‘元组元素的删除’，实质上删除了整个元组，又重新创建了一个元组
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
7.元组和列表
希望内容不被轻易改写时，用元组；当我们需要频繁修改数据，我们使用列表
五.字典
1.字典是另一种可变容器模型，且可存储任意类型对象，字典不是序列
2.字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
3.键必须是唯一的，但值则不必，值可以取任何数据类型，但键必须是不可变的数据类型，如字符串，数字或元组
4.字典
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 {}
5.字典内置函数
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'>
6.字典键和值的特性
(1)字典键必须是可哈希（Hash）的对象，不能是可变类型，必须为不可变对象
(2)键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
(3)不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
(4)字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的
(5)字典的键值是"只读"的，所以不能对键和值分别进行初始化
7.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}
8.字典推导式
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}
9.列表中字典按键排序
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}]
10.把两个列表变成一个字典
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'}
11.和list相比，dict的特点：（1）查找和插入的速度极快，不会随着key的增加而变慢；（2）需要占用大量的内存，内存浪费多。
12.总结字典的操作
(1).增：dict[key]=value（赋值）
(2).删：del语句、pop、popitem、clear
(3).改：（只能改值）赋值改、updata
(4).查：get、setdefault、values、keys、items
六.集合
1.集合是一个无序不重复元素的集合
2.可以使用大括号 { } 或者 set() 函数创建集合
3.set()可变集合、frozenset（）不可变集合
4.创建空集合时，使用set（）或frozenset（）不能使用s={}，因为 { } 是用来创建一个空字典
5.基本功能是进行成员关系测试和删除重复元素；元素为不可变类型，不能修改，
6.集合和字典的存储方式一样,集合中的元素必须是可哈希的值，如果元素重复出现，则会合并为一个
7.集合可以通过for in进行遍历，可以通过迭代器进行访问
8.成员关系测试和集合运算
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'}
9.集合对比字典：集合相当于一组key的集合，但不存储value。由于key不能重复，所以在set中，没有重复的key
10.集合的函数
add增加；discard删除；remove删除；pop随机删除；clear清空集合；intersection交集；union并集；updata更新；difference差集；difference_updata差集；
isdisjoint不相交；issuperset包含；issubset包含于
七.Python数据类型转换
八.可变对象和不可变对象
1.python中一切都是对象，通过变量标识来引用一个对象，对象为数据时，由于python中定义了数据的类型，所以可以称某种数据类型的对象，
2.对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，保证了不可变对象本身永远是不可变的。
对于可变对象来说，调用对象自身的任意方法，会改变该对象自身的内容
3.python中的不可变数据类型：整型、浮点型、布尔值、字符串、元组。
python中的可变数据类型：列表、字典
4.Python中的字符串不能改变；列表中的元素是可以改变的；元组的元素不能修改，但它可以包含可变的对象，比如list列表；字典可以被修改
5.对于可变数据类型，a=a+a和a+=a的不同：前一个是生成（赋值）一个新的内存，后一个在原有的基础上修改