pytho*内置的一种数据类型是列表：l*st.l*st是一种有序的数据集合，可以随意的添加和删除其中的数据。比如列出班里所有的同学的名字，列出所有工厂员工的工号等都是可以用到列表的，以下是pytho*列表的演示代码：
1 &*t;&*t;&*t; l*st1 = ['zha**xueyou','l*udehua','wa**l*jua*','l*m***','shab*e'] 2 &*t;&*t;&*t; l*st1 3 ['zha**xueyou','shab*e'] 4 &*t;&*t;&*t; l*st2 = [000001,000002,000003,000004,000005,000006] 5 &*t;&*t;&*t; l*st2 6 [1,2,3,4,5,6] 7 &*t;&*t;&*t;
变量l*st1,l*st2都是一个列表的实例，可以使用le*()函数获得列表的长度（字典中的元素的个数）：
1 &*t;&*t;&*t; l*st1 = ['zha**xueyou','shab*e'] 2 &*t;&*t;&*t; l*st1 3 ['zha**xueyou','shab*e'] 4 &*t;&*t;&*t; l*st2 = [000001,000006] ＃其实这里面写成字符串更合适 5 &*t;&*t;&*t; l*st2 6 [1,6] 7 &*t;&*t;&*t; le*(l*st1) 8 5 9 &*t;&*t;&*t; le*(l*st2) 10 6 11 &*t;&*t;&*t;
可以使用索引来引用列表中的元素，注意：列表中的索引是从０开始的，并且在列表中还支持负索引，实例如下：
1 &*t;&*t;&*t; l*st1[0] 2 'zha**xueyou' 3 &*t;&*t;&*t; l*st1[2] 4 'wa**l*jua*' 5 &*t;&*t;&*t; l*st2[1] 6 2 7 &*t;&*t;&*t; l*st1[-1] 8 'shab*e' 9 &*t;&*t;&*t; l*st2[-2] ＃这就是负索引的实例 10 5 11 &*t;&*t;&*t;
当访问的下标越界的时候就会报I*dex error错：
1 &*t;&*t;&*t; l*st1[78] 2 Traceback (most rece*t call last): 3 F*le "<std**&*t;",l**e 1,** <module&*t; 4 I*dexError: l*st **dex out of ra**e 5 &*t;&*t;&*t;
所以，记得在操作pytho*的列表的时候不要越界，记得最后一个元素的索引是：le*(l*st1)-1.
当你要取得最后一个元素的时候你除了记住索引之外还有一个更机智的办法即使使用pytho*的负索引的方法：
1 &*t;&*t;&*t; l*st1[le*(l*st1)-1] 2 'shab*e' 3 &*t;&*t;&*t; l*st1[-1] 4 'shab*e' 5 &*t;&*t;&*t;
l*st是一个可以变的有序列表，因此可以往你自己的列表中添加和删除元素：在末尾添加元素用的是appe*d()方法，在指定的位置插入元素使用的是**sert()方法。
1 ＃在列表末尾追加元素
2 &*t;&*t;&*t; l*st1.appe*d('x*j**p***')
3 &*t;&*t;&*t; l*st1
4 ['zha**xueyou','shab*e','x*j**p***']
5 &*t;&*t;&*t; l*st2.appe*d(7)
6 &*t;&*t;&*t; l*st2
7 [1,6,7]
8 &*t;&*t;&*t;
9 #也可以在指定的位置上添加元素
10 ...
11 &*t;&*t;&*t; l*st1.**sert(1,'luot***')
12 &*t;&*t;&*t; l*st1
13 ['zha**xueyou','luot***','x*j**p***']
14 &*t;&*t;&*t; l*st2.**sert(0,8)
15 &*t;&*t;&*t; l*st2
16 [8,1,7]
17 &*t;&*t;&*t;
在列表中删除元素：删除末尾的元素使用的是pop()方法，删除指定位置的元素使用pop(*),其中*是索引下标，
1 &*t;&*t;&*t; l*st1 2 ['zha**xueyou','x*j**p***'] 3 &*t;&*t;&*t; l*st1.pop() 4 'x*j**p***' 5 &*t;&*t;&*t; l*st1 6 ['zha**xueyou','shab*e'] 7 &*t;&*t;&*t; 8 &*t;&*t;&*t; l*st1.pop(0) 9 'zha**xueyou' 10 &*t;&*t;&*t; l*st1 11 ['luot***','shab*e'] 12 &*t;&*t;&*t; l*st2.pop() 13 7 14 &*t;&*t;&*t; l*st2 15 [9,8,6] 16 &*t;&*t;&*t; l*st2.pop(0) 17 9 18 &*t;&*t;&*t; l*st2 19 [8,6] 20 &*t;&*t;&*t;
若想替换l*st中的某个元素，可以直接把该元素赋值给对应的元素下标即可：
1 &*t;&*t;&*t; l*st1 2 ['luot***','shab*e'] 3 &*t;&*t;&*t; l*st1[2] = "wyl" 4 &*t;&*t;&*t; l*st1 5 ['luot***','wyl','shab*e'] 6 &*t;&*t;&*t;
在一个l*st中可以有不同的数据类型，可以有字符串类型，整型，或者bool等。
1 &*t;&*t;&*t; l*st3 = ['baba','mama',123,True] 2 &*t;&*t;&*t; l*st3 3 ['baba',True] 4 &*t;&*t;&*t;
l*st的元素中也可以有另外一个l*st，就相当于一个循环的嵌套一样。
1 &*t;&*t;&*t; l*st4 = ['wa**','wu','luo',['la**','zha**'],'kua'] 2 &*t;&*t;&*t; l*st4 3 ['wa**','kua'] 4 &*t;&*t;&*t;
在这个列表中，要取到‘la**’可以使用下标索引：l*st4[3][1]，这就相当于ｃ语言中的二维数组，同样的还可以层层递进的写到三维数组，四维数组等。
&*bsp;
如果，一个列表中一个元素都都没有的话，就是一盒空列表：
&*bsp;
&*bsp;
ｐytho*列表的高级应用：
１．用某个固定的值初始化列表：
1 &*t;&*t;&*t; ***t*al_value = 0 2 &*t;&*t;&*t; l*st_le**th = 5 3 &*t;&*t;&*t; sample_l*st = [***t*al_value for * ** ra**e(10)] 4 &*t;&*t;&*t; sample_l*st = [***t*al_value]*l*st_le**th 5 &*t;&*t;&*t; sample_l*st 6 [0,0] 7 &*t;&*t;&*t;
２．产生一个数制递增的列表：
1 &*t;&*t;&*t; *um_**c_l*st = ra**e(30) 2 &*t;&*t;&*t; *um_**c_l*st 3 [0,7,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29] 4 &*t;&*t;&*t;
３．创建连续的l*st
L = ra**e(1,5)&*bsp;&*bsp;&*bsp;&*bsp;&*bsp; #即 L=[1,4],不含最后一个元素
L = ra**e(1,2) #即 L=[1,9]
1 &*t;&*t;&*t; L = ra**e(1,5) 2 &*t;&*t;&*t; L 3 [1,4] 4 &*t;&*t;&*t; L = ra**e(1,3) 5 &*t;&*t;&*t; L 6 [1,19] 7 &*t;&*t;&*t;
l*st的方法
L.appe*d(var)&*bsp;&*bsp; #追加元素
L.**sert(**dex,var)
L.pop(var)&*bsp;&*bsp;&*bsp;&*bsp;&*bsp; #返回最后一个元素，并从l*st中删除之
L.remove(var)&*bsp;&*bsp; #删除第一次出现的该元素
1 &*t;&*t;&*t; l*st6 = [1,65,4] 2 &*t;&*t;&*t; l*st6 3 [1,4] 4 &*t;&*t;&*t; l*st6.remove(4) 5 &*t;&*t;&*t; l*st6 6 [1,4] 7 &*t;&*t;&*t;
L.cou*t(var)&*bsp;&*bsp;&*bsp; #该元素在列表中出现的个数
1 &*t;&*t;&*t; l*st6 = [1,4] 2 &*t;&*t;&*t; l*st6 3 [1,4] 4 &*t;&*t;&*t; l*st6.remove(4) 5 &*t;&*t;&*t; l*st6 6 [1,4] 7 &*t;&*t;&*t; 8 &*t;&*t;&*t; l*st6.cou*t(4) 9 2 10 &*t;&*t;&*t;
L.**dex(var)&*bsp;&*bsp;&*bsp; #该元素的位置,无则抛异常&*bsp;
1 &*t;&*t;&*t; l*st6 2 [1,4] 3 &*t;&*t;&*t; 4 &*t;&*t;&*t; l*st6.cou*t(4) 5 2 6 &*t;&*t;&*t; l*st6.**dex(5) 7 3 8 &*t;&*t;&*t;
L.exte*d(l*st６)&*bsp; #追加l*st６，即合并l*st到L上
1 &*t;&*t;&*t; L 2 [1,19] 3 &*t;&*t;&*t; L.exte*d(l*st6) 4 &*t;&*t;&*t; L 5 [1,4] 6 &*t;&*t;&*t;
这里注意，使用exte*d函数可以一次在一个列表中插入任意多个值，而不必须每次只使用appe*d()一次一值的插入：
L.sort()&*bsp;&*bsp;&*bsp;&*bsp;&*bsp;&*bsp;&*bsp; #排序
L.reverse()&*bsp;&*bsp;&*bsp;&*bsp; #倒序
1 &*t;&*t;&*t; L 2 [1,4] 3 &*t;&*t;&*t; L.sort() 4 &*t;&*t;&*t; L 5 [1,65] 6 &*t;&*t;&*t; L.reverse() 7 &*t;&*t;&*t; L 8 [65,1] 9 &*t;&*t;&*t;
l*st 操作符:,+,*，关键字del
a[1:]&*bsp;&*bsp;&*bsp;&*bsp;&*bsp;&*bsp; #片段操作符，用于子l*st的提取
[1,2]+[3,4] #为[1,4]。同exte*d()
[2]*4&*bsp;&*bsp;&*bsp;&*bsp;&*bsp;&*bsp; #为[2,2]
del L[1]&*bsp;&*bsp;&*bsp; #删除指定下标的元素
del L[1:3]&*bsp; #删除指定下标范围的元素
1 &*t;&*t;&*t; L 2 [65,1] 3 &*t;&*t;&*t; del L[1] 4 &*t;&*t;&*t; L 5 [65,1] 6 &*t;&*t;&*t; del L[0:3] 7 &*t;&*t;&*t; L 8 [12,1] 9 &*t;&*t;&*t;
复制l*st:
L1 = L&*bsp;&*bsp;&*bsp;&*bsp;&*bsp; #L1为L的别名，用C来说就是指针地址相同，对L1操作即对L操作。函数参数就是这样传递的
L1 = L[:]&*bsp;&*bsp; #L1为L的克隆，即另一个拷贝。
&*bsp;
&*bsp;
和列表类似，元组也是一种有序列表，虽然tuple和l*st非常之类似，但是l*st初始化之后使可以改变的，但是，元组一旦初始化之后就不可以改变。比如，同样的列出一组人的姓名：
1 &*t;&*t;&*t; tuple1 = ('wuya*l','wa**cc','wa***a**','de**dache**')
2 &*t;&*t;&*t; tuple1
3 ('wuya*l','de**dache**')
4 &*t;&*t;&*t;
现在tuple1这个tuple不能变了，它也没有appe*d()，**sert()这样的方法。其他获取元素的方法和l*st是一样的，你可以正常地使用tuple1[0]，tuple1[-1]，但不能赋值成另外的元素。
不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替l*st就尽量用tuple。
1 &*t;&*t;&*t; tuple1[0] 2 'wuya*l' 3 &*t;&*t;&*t; tuple1[-1] 4 'de**dache**' 5 &*t;&*t;&*t; tuple1[4] 6 Traceback (most rece*t call last): 7 F*le "<std**&*t;",** <module&*t; 8 I*dexError: tuple **dex out of ra**e 9 &*t;&*t;&*t; #同样越界也是报出一个**dexError
tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：
1 &*t;&*t;&*t; #定义一个空的元组 2 ... 3 &*t;&*t;&*t; t = tuple() 4 &*t;&*t;&*t; t 5 () 6 &*t;&*t;&*t; t = (1,1) 7 &*t;&*t;&*t; t 8 (1,1) 9 &*t;&*t;&*t; #定义一个只有一个元素的元组，可以这样定义： 10 ... 11 &*t;&*t;&*t; t1 = (123,) 12 &*t;&*t;&*t; t1 13 (123,) 14 &*t;&*t;&*t; ＃如果你这样定义你定义的将是１２３这个元素，而不是一个元组 15 &*t;&*t;&*t; 16 &*t;&*t;&*t; t2 = (123) 17 &*t;&*t;&*t; t2 18 123 19 &*t;&*t;&*t;
定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，*ytho*规定，这种情况下，按小括号进行计算，计算结果自然是1。
所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：
*ytho*在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。
&*bsp;可以"改变"的tuple：
1 &*t;&*t;&*t; tuple2 = ('aa','bb','cc',['a','b','c'],'dd')
2 &*t;&*t;&*t; tuple2
3 ('aa','dd')
4 &*t;&*t;&*t; tuple2[3][0] = '**'
5 &*t;&*t;&*t; tuple2[3][1] = 'YY'
6 &*t;&*t;&*t; tuple2
7 ('aa',['**','YY','dd')
8 &*t;&*t;&*t; #当一个元组中有列表时是可以改变元组的值的，其实实质是改变列表的值
１．创建元组：
1 &*t;&*t;&*t; tuple1 = ('wudashe*','la**dache**','wa**che**che**')
2 &*t;&*t;&*t; tuple2 = (1,6)
3 &*t;&*t;&*t; tuple3 = "a","b","c","d"
4 &*t;&*t;&*t; tuple1
5 ('wudashe*','wa**che**che**')
6 &*t;&*t;&*t; tuple2
7 (1,6)
8 &*t;&*t;&*t; tuple3
9 ('a','c','d')
10 &*t;&*t;&*t;
创建一个空元组时可以直接创建一个括号，创建一个只有一个元素的元组时，必须在和面添加一个逗号（，）：
&*t;&*t;&*t; &*t;&*t;&*t; tuple4 = () &*t;&*t;&*t; tuple4 () &*t;&*t;&*t; tuple5 = (1,) &*t;&*t;&*t; tuple5 (1,) &*t;&*t;&*t;
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
2.访问元组：
元组可以使用下标索引来访问元组中的值，如下实例:
1 &*t;&*t;&*t; pr**t "tuple1[0]:",tuple1[0]
2 tuple1[0]: wudashe*
3 &*t;&*t;&*t; pr**t "tuple1[1:5]",tuple1[1:5]
4 tuple1[1:5] ('la**dache**','wa**che**che**')
5 &*t;&*t;&*t; pr**t "tuple2[1:5]",tuple2[1:5]
6 tuple2[1:5] (2,5)
7 &*t;&*t;&*t;
３．修改元组：
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
1 &*t;&*t;&*t; t1 = ('wuya*l','a*me*yu')
2 &*t;&*t;&*t; t2 = (1,0)
3 &*t;&*t;&*t; t1
4 ('wuya*l','a*me*yu')
5 &*t;&*t;&*t; t2
6 (1,0)
7 &*t;&*t;&*t; t3 = t1 +t2
8 &*t;&*t;&*t; t3
9 ('wuya*l','a*me*yu',0)
10 &*t;&*t;&*t;
４．删除元组：
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
1 &*t;&*t;&*t; pr**t t1
2 ('wuya*l','a*me*yu')
3 &*t;&*t;&*t; del t1
4 &*t;&*t;&*t; t1
5 Traceback (most rece*t call last):
6 F*le "<std**&*t;",** <module&*t;
7 NameError: *ame 't1' *s *ot def**ed
8 &*t;&*t;&*t;
５．元组运算符：
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
&*bsp;
６．元组索引，截取：
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
７. 元组的内置函数：
(1),比较两个元组元素：cmp(tuple1,tuple2)
1 &*t;&*t;&*t; tuple1
2 ('wudashe*','wa**che**che**')
3 &*t;&*t;&*t; tuple2
4 (1,6)
5 &*t;&*t;&*t; cmp(tuple1,tuple2)
6 1
7 &*t;&*t;&*t; #两个元组不相等则返回１
8 ...
9 &*t;&*t;&*t; tt1 = (1,3)
10 &*t;&*t;&*t; tt1
11 (1,3)
12 &*t;&*t;&*t; tt2 = (1,3)
13 &*t;&*t;&*t; tt2
14 (1,3)
15 &*t;&*t;&*t; cmp(tt1,tt2)
16 0
17 &*t;&*t;&*t; #两个元组相等则返回０
18 ...
19 &*t;&*t;&*t;
(2),计算元组的长度：le*(tuple1):
1 &*t;&*t;&*t; le*(tt1) 2 3 3 &*t;&*t;&*t; le*(tt2) 4 3 5 &*t;&*t;&*t; le*(tuple1) 6 3 7 &*t;&*t;&*t; le*(tuple2) 8 6 9 &*t;&*t;&*t;
(3),返回元组中的最大值：max(tuple2),m**(tuple2)
1 &*t;&*t;&*t; 2 &*t;&*t;&*t; max(tt1) 3 3 4 &*t;&*t;&*t; max(tuple1) 5 'wudashe*' 6 &*t;&*t;&*t; max(tuple2) 7 6 8 &*t;&*t;&*t; max(tuple3) 9 'd' 10 &*t;&*t;&*t; m**(tt1) 11 1 12 &*t;&*t;&*t; m**(tuple3) 13 'a' 14 &*t;&*t;&*t; #返回元组中的最小值
(4),将列表转换成元组：
1 &*t;&*t;&*t; l*st1
2 ['luot***','shab*e']
3 &*t;&*t;&*t; lt = tuple(l*st1)
4 &*t;&*t;&*t; lt
5 ('luot***','shab*e')
6 &*t;&*t;&*t;
元组的知识就先介绍到这里，以下详细的来说一下重头戏－－字典：
*ytho*内置了字典：d*ct的支持，d*ct全称d*ct*o*ary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。
在这里可以举一个例子，假如你通过列表来查看工人的名字和对应的工资的话，在这里你需要设置两个列表，一个用于存储名字，一个用于存储工资：
1 &*t;&*t;&*t; *ame = ['zha**sa*','l*s*','wa**wu','doub*e'] 2 &*t;&*t;&*t; *ame 3 ['zha**sa*','doub*e'] 4 &*t;&*t;&*t; salary = [20000,30000,200000,123000] 5 &*t;&*t;&*t; salary 6 [20000,123000] 7 &*t;&*t;&*t;
给定一个名字，要查找对应的成绩，就先要在*ame中找到对应的位置，再从salary取出对应的成绩，l*st越长，耗时越长。
如果用d*ct实现，只需要一个“名字”-“薪水”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。
用*ytho*写一个d*ct如下：
1 &*t;&*t;&*t; d*ct1 = {'zha**sa*':30000,'l*s*':321000,'wa**er':123654,'wa**wu':123878}
2 &*t;&*t;&*t; d*ct1
3 {'l*s*': 321000,'zha**sa*': 30000,'wa**er': 123654,'wa**wu': 123878}
4 &*t;&*t;&*t;
为什么d*ct查找速度这么快？因为d*ct的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在l*st中查找元素的方法，l*st越大，查找越慢。
第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字，无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。
d*ct就是第二种实现方式，给定一个名字，比如'zha**sa*'，d*ct在内部就可以直接计算出zha**sa*l对应的存放成绩的“页码”，也就是30000这个数字存放的内存地址，直接取出来，所以速度非常快。
你可以猜到，这种key-value存储方式，在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。
把数据放入d*ct的方法，除了初始化时指定外，还可以通过key放入：
1 &*t;&*t;&*t; d*ct1 = {'zha**sa*':30000,'wa**wu':123878}
2 &*t;&*t;&*t; d*ct1
3 {'l*s*': 321000,'wa**wu': 123878}
4 &*t;&*t;&*t; d*ct1['zha**sa*']
5 30000
6 &*t;&*t;&*t; d*ct1['wa**wu']
7 123878
8 &*t;&*t;&*t; d*ct1['l*s*']
9 321000
10 &*t;&*t;&*t;
油魚一個key只能對應一个值，因此，倘若你多次对同一个key赋值的话，以前赋的值会被覆盖掉。
1 &*t;&*t;&*t; d*ct1
2 {'l*s*': 321000,'wa**wu': 123878}
3 &*t;&*t;&*t; d*ct1['zha**sa*'] = 1000000
4 &*t;&*t;&*t; d*ct1
5 {'l*s*': 321000,'zha**sa*': 1000000,'wa**wu': 123878}
6 &*t;&*t;&*t; d*ct1['zha**sa*'] = 100
7 &*t;&*t;&*t; d*ct1
8 {'l*s*': 321000,'zha**sa*': 100,'wa**wu': 123878}
9 &*t;&*t;&*t;
如果你想赋值的key不存在就会报错：
1 &*t;&*t;&*t; d*ct1['x*dada'] = 4563221
2 &*t;&*t;&*t; d*ct1
3 {'l*s*': 321000,'x*dada': 4563221,'wa**wu': 123878}
4 &*t;&*t;&*t; d*ct1['wa**cc']
5 Traceback (most rece*t call last):
6 F*le "<std**&*t;",** <module&*t;
7 KeyError: 'wa**cc'
8 &*t;&*t;&*t; d*ct1['wyl'] = 888888
9 &*t;&*t;&*t; d*ct1
10 {'wa**er': 123654,'l*s*': 321000,'wa**wu': 123878,'wyl': 888888,'zha**sa*': 100}
11 &*t;&*t;&*t;
由以上的代码可以看出，当你的字典中没有这个key，但是你还给这个key赋值的话，是不会报错的，并且你的值可以插入这个字典中，但是假如你访问一个没有的key值，就会报出一个KeyError，
&*bsp;因此，要想判断key值是否存在，可以有两个方法。
方法一：使用**语句判断：
1 &*t;&*t;&*t; d*ct1
2 {'wa**er': 123654,'zha**sa*': 100}
3 &*t;&*t;&*t; 'zha**sa*' ** d*ct1
4 True
5 &*t;&*t;&*t; 'l*udehua' ** d*ct1
6 False
7 &*t;&*t;&*t; d*ct1
方法二：使用d*ct提供的*et()方法，若key值不存在就返回No*e或者自己指定的返回值：
1 &*t;&*t; d*ct1
2 {'wa**er': 123654,'zha**sa*': 100}
3 &*t;&*t;&*t; d*ct1.*et('zha**dada','*ot a*y')
4 '*ot a*y'
5 &*t;&*t;&*t; #使用自己定义的返回值
1 &*t;&*t;&*t; d*ct1
2 {'wa**er': 123654,'zha**sa*': 100}
3 &*t;&*t;&*t;
4 &*t;&*t; d*ct1.*et('zha**sa*')
5 100
6 &*t;&*t;&*t; d*ct1.*et('x*elaoda')
7 &*t;&*t;&*t; #什么都没有返回（NONE）
8 ...
9 &*t;&*t;&*t;
注意：返回No*e的时候*ytho*的交互式命令行不显示结果。
和列表和元组类似，当你要删除一个字典值的时候，你可以使用pop(key)的方法达到删除字典元素的目的：
1 &*t;&*t;&*t; d*ct1
2 {'wa**er': 123654,'zha**sa*': 100}
3 &*t;&*t;&*t; d*ct1.pop('wa**er')
4 123654
5 &*t;&*t;&*t; d*ct1
6 {'x*dada': 4563221,'zha**sa*': 100}
7 &*t;&*t;&*t; d*ct1.pop('x*dada')
8 4563221
9 &*t;&*t;&*t; d*ct1
10 {'l*s*': 321000,'zha**sa*': 100}
11 &*t;&*t;&*t;
注意，d*ct内部存放的顺序和key放入的顺序是没有关系的。
和l*st比较，d*ct有以下几个特点：
而l*st相反：
所以，d*ct是用空间来换取时间的一种方法。
d*ct可以用在需要高速查找的很多地方，在*ytho*代码中几乎无处不在，正确使用d*ct非常重要，需要牢记的第一条就是d*ct的key必须是
这是因为d*ct根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那d*ct内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。
要保证hash的正确性，作为key的对象就不能变。在*ytho*中，字符串、整数等都是不可变的，因此，可以放心地作为key。而l*st是可变的，就不能作为key：
&*bsp;
字典的高级应用：
1 &*t;&*t;&*t; d*ct2 = {'a':1,'b':2,'c':3}
2 &*t;&*t;&*t; d*ct2
3 {'a': 1,'c': 3,'b': 2}
4 &*t;&*t;&*t; d*ct3 = d*ct2
5 &*t;&*t;&*t; d*ct3
6 {'a': 1,'b': 2}
7 &*t;&*t;&*t; del d*ct2['a'] #删除key为'a'的条目
8 &*t;&*t;&*t; d*ct2
9 {'c': 3,'b': 2}
10 &*t;&*t;&*t; d*ct2.clear()
11 &*t;&*t;&*t; d*ct2.clear()
12 &*t;&*t;&*t; d*ct2.clear()#清空字典；
13 &*t;&*t;&*t; d*ct2
14 {}
15 &*t;&*t;&*t; del d*ct2 #直接删除整个字典
16 &*t;&*t;&*t; d*ct2
17 Traceback (most rece*t call last):
18 F*le "<std**&*t;",** <module&*t;
19 NameError: *ame 'd*ct2' *s *ot def**ed
20 &*t;&*t;&*t; #删除之后再输出d*ct2字典确实出错了
21 ...
22 &*t;&*t;&*t;
字典键的特性：
(1)，在字典中同一个key不可以出现两次或以上：
1 &*t;&*t;&*t; d*ct4 = {'*ame':123,'*ame':1236}
2 &*t;&*t;&*t; d*ct4
3 {'*ame': 1236}
4 &*t;&*t;&*t; #两次设置*ame但是只显示一次
(2),键必须不可变，所以可以用数，字符串或元组充当，所以用列表就不行，如下实例：换言之就是
1 &*t;&*t;&*t; d*ct4 = {'*ame1':123,'*ame2':1236,'*ame3':1}
2 &*t;&*t;&*t; d*ct4
3 {'*ame2': 1236,'*ame3': 1,'*ame1': 123}
4 &*t;&*t;&*t;
字典的内置函数和方法：
(1),字典中的cmp函数用于比较两个字典是不是相等的：
1 &*t;&*t;&*t; d*c1 = {'a':1,'c':3}
2 &*t;&*t;&*t; d*c2 = d*c1
3 &*t;&*t;&*t; d*c3 = {'e':3,'r':5,'y':7}
4 &*t;&*t;&*t; cmp(d*c1,d*c2)
5 0
6 &*t;&*t;&*t; cmp(d*c2,d*c3)
7 -1
8 &*t;&*t;&*t; #两个字典比较，如果相同就返回0 否则返回-1
9 ... #cmp函数就是用于比较两个字典是不是相等的字典内置函数
(2),le*(d*ct)：计算字典元素个数，即键的总数。
1 &*t;&*t;&*t; le*(d*c1) 2 3 3 &*t;&*t;&*t; le*(d*c2) 4 3 5 &*t;&*t;&*t; le*(d*c3) 6 3 7 &*t;&*t;&*t; le*(d*ct1) 8 4 9 &*t;&*t;&*t;
(3),str(d*ct)：输出字典可打印的字符串表示。
1 &*t;&*t;&*t; str(d*c1)
2 "{'a': 1,'b': 2}"
3 &*t;&*t;&*t; str(d*c2)
4 "{'a': 1,'b': 2}"
5 &*t;&*t;&*t; str(d*c3)
6 "{'y': 7,'r': 5,'e': 3}"
7 &*t;&*t;&*t; str(d*ct1)
8 "{'l*s*': 321000,'zha**sa*': 100}"
9 &*t;&*t;&*t;
(4),type(var*able)：返回输入的变量类型，如果变量是字典就返回字典类型。
1 &*t;&*t;&*t; type(d*c1) 2 <type 'd*ct'&*t; 3 &*t;&*t;&*t; type(d*c2) 4 <type 'd*ct'&*t; 5 &*t;&*t;&*t; type(d*ct1) 6 <type 'd*ct'&*t; 7 &*t;&*t;&*t;
&*bsp;
*ytho*字典包含了以下内置方法：
1、rad*a*sd*ct.clear()：删除字典内所有元素
1 &*t;&*t;&*t; d*c1
2 {'a': 1,'b': 2}
3 &*t;&*t;&*t; d*c1.clear()
4 &*t;&*t;&*t; d*c1
5 {}
6 &*t;&*t;&*t;
2、rad*a*sd*ct.copy()：返回一个字典的浅复制
1 &*t;&*t;&*t; d*c3
2 {'y': 7,'e': 3}
3 &*t;&*t;&*t; d*c3.copy()
4 {'y': 7,'e': 3}
5 &*t;&*t;&*t; d*c3
6 {'y': 7,'e': 3}
7 &*t;&*t;&*t;
3、rad*a*sd*ct.fromkeys()：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4、rad*a*sd*ct.*et(key,default=No*e)：返回指定键的值，如果值不在字典中返回default值
1 &*t;&*t;&*t; d*ct1.*et('zha**xueyou','*ot a*y')
2 '*ot a*y'
3 &*t;&*t;&*t;
5、rad*a*sd*ct.has_key(key)：如果键在字典d*ct里返回true，否则返回false
1 &*t;&*t;&*t; d*ct1
2 {'l*s*': 321000,'zha**sa*': 100}
3 &*t;&*t;&*t; d*ct1.has_key('wa**wu')
4 True
5 &*t;&*t;&*t; d*ct1.has_key('wa**')
6 False
7 &*t;&*t;&*t;
6、rad*a*sd*ct.*tems()：以列表返回可遍历的(键,值) 元组数组
1 &*t;&*t;&*t; d*ct1.*tems()
2 [('l*s*',321000),('wa**wu',123878),('wyl',888888),('zha**sa*',100)]
3 &*t;&*t;&*t;
7、rad*a*sd*ct.keys()：以列表返回一个字典所有的键
1 &*t;&*t;&*t; l*st2 = {'a':1,'c':3,'d':4}
2 &*t;&*t;&*t; l*st2
3 {'a': 1,'b': 2,'d': 4}
4 &*t;&*t;&*t; l*st2.keys()
5 ['a','d']
6 &*t;&*t;&*t;
8、rad*a*sd*ct.setdefault(key,default=No*e)：和*et()类似,但如果键不已经存在于字典中，将会添加键并将值设为default
9、rad*a*sd*ct.update(d*ct2)：把字典d*ct2的键/值对更新到d*ct里
10、rad*a*sd*ct.values()：以列表返回字典中的所有值
1 &*t;&*t;&*t; l*st2
2 {'a': 1,'d': 4}
3 &*t;&*t;&*t; l*st2.values()
4 [1,4]
5 &*t;&*t;&*t;
四，set
本来，打算只讲一下字典，元组，列表的一些基本用法，但是现在扩展探讨一下pytho*中的set的用法：
set和d*ct类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
要创建一个set，需要提供一个l*st作为输入集合：
&*bsp;
注意，传入的参数[1,3]是一个l*st，而显示的set([1,3])只是告诉你这个set内部有1，2，3这3个元素，显示的[]不表示这是一个l*st。
重复元素在set中自动被过滤：
1 &*t;&*t;&*t; s = set([1,9]) 2 &*t;&*t;&*t; s 3 set([1,9]) 4 &*t;&*t;&*t; s = set([1,89,97,7]) 5 &*t;&*t;&*t; s 6 set([1,89]) 7 &*t;&*t;&*t;
这一点，有点想数学中的集合的互异性类似。
在此，你还可以使用add()方法添加元素到set找你刚，当你重复添加的时候是不会报错的，只是不会在set中看到重复的值，它会自己过虐掉的。
1 &*t;&*t;&*t; s 2 set([1,89]) 3 &*t;&*t;&*t; s.add(100) 4 &*t;&*t;&*t; s.add(100) 5 &*t;&*t;&*t; s.add(123) 6 &*t;&*t;&*t; s.add(321) 7 &*t;&*t;&*t; s 8 set([1,321,100]) 9 &*t;&*t;&*t;
若你想删除set中的值，你可以使用方法remove(key)达到你想要的效果。
1 &*t;&*t;&*t; s 2 set([1,123]) 3 &*t;&*t;&*t; s.remove(1) 4 &*t;&*t;&*t; s 5 set([2,123]) 6 &*t;&*t;&*t;
set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：
1 &*t;&*t;&*t; s1 = set([1,9]) 2 &*t;&*t;&*t; s1 3 set([1,9]) 4 &*t;&*t;&*t; s2 = set([4,6]) 5 &*t;&*t;&*t; s2 6 set([2,6]) 7 &*t;&*t;&*t; s1 & s2 8 set([2,6]) 9 &*t;&*t;&*t; s1 | s2 10 set([1,9]) 11 &*t;&*t;&*t;
set和d*ct的唯一区别仅在于没有存储对应的value，但是，set的原理和d*ct一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把l*st放入set，看看是否会报错。
&*bsp;
原文地址：https://www.cnblogs.com/zmdComeOn
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。