入门第七课 Python的列表和字典详解
一、列表
1.1 从列表中取值
a=[1,2,3,4,5]
分析：a是一个变量，它的值是[1,2,3,4,5]
如果我们想提取第3个数，并把这个数赋值给b，要怎么写呢？
首先说明一个语法，a[0]代表a中第一个数，也就是1；之后a[1]代表a中第2个数，也就是2，以此类推。
那么上面的题目就有了答案：a中第三个数是a[2]，赋值给b，就可以写成b=a[2]
（大家别问why，因为Python就是这样设计的，真的想问，请发邮件给Python的创始人。。。）
2、创建列表
上面a的值，是[1,2,3,4,5]。列表中可以有1个值，可以有100个值，也可以没有值，也就是空的列表：[]。空列表同样可以赋值给变量：
>>> c=[]
这样c就是一个空列表，还可以这样写：
>>> c=list()
同样是创建了一个变量c，并赋值为一个空列表。
3、对于列表，可以做很多的操作和处理。
我们讲到字符串的时候，说字符串可以提取按要求提取一部分，列表也可以。格式是list[start:end:step]，start是开始位置，end是结束位置，step是步进数。
举个栗子-_-!!
>>> a=["Apple","Facebook","Oracle","Amazon","Microsoft","Baidu","Alibaba"] >>> a[0] 'Apple' >>> a[-1] 'Alibaba' >>> a[0:1] ['Apple'] >>> a[0:2] ['Apple', 'Facebook'] >>> a[1:] ['Facebook', 'Oracle', 'Amazon', 'Microsoft', 'Baidu', 'Alibaba'] >>> a[1::2] ['Facebook', 'Amazon', 'Baidu']
变量a是一个列表，列表中包含了7个值，对应的索引（也就是值在列表中的位置）分别是0、1、2、3、4、5和6，也可以是-7、-6、-5、-4、-3、-2和-1。所以：
a[0]的返回值是‘Apple’
a[-1]的返回值是‘Alibaba’
a[0:1]，这个和字符串的截取逻辑一致，即截取列表的一段。在这一段中，包含a[0]，但不包含a[1]。
a[0:2]，返回值是a[0]和a[1]，这里没有步进数，默认值为1。
a[1:]，对于索引范围带有冒号的，如果只有前面的start，后面没有end的，等同于从a[1]开始直至最后且步进数为1。大家试试看a[:-2]，看看结果是多少？
a[1::2]，意思是从a[1]开始取值直至列表的最后一个值，步进数是2，也就是每次跨过一个值取下一个。
4、列表可迭代的，不用纠结“什么是可迭代的？”，来，一起看示例：
>>> a ['Apple', 'Facebook', 'Oracle', 'Amazon', 'Microsoft', 'Baidu', 'Alibaba'] >>> for i in a: print(i) Apple Facebook Oracle Amazon Microsoft Baidu Alibaba
只要是可迭代的，就能使用for循环来逐个读取并打印可迭代对象中的每一个值。
6、其他
6.1 列表和字符串，都可以使用*来倍增。
>>> b=a*3 >>> b ['Apple', 'Facebook', 'Oracle', 'Amazon', 'Microsoft', 'Baidu', 'Alibaba', 'Apple', 'Facebook', 'Oracle', 'Amazon', 'Microsoft', 'Baidu', 'Alibaba', 'Apple', 'Facebook', 'Oracle', 'Amazon', 'Microsoft', 'Baidu', 'Alibaba']
6.2 列表和字符串一样，可以用+相连，组成新的列表。
>>> a ['Apple', 'Facebook', 'Oracle', 'Amazon', 'Microsoft', 'Baidu', 'Alibaba'] >>> b=['Tencent','JD'] >>> c=a+b >>> c ['Apple', 'Facebook', 'Oracle', 'Amazon', 'Microsoft', 'Baidu', 'Alibaba', 'Tencent', 'JD']
6.3 可以使用len()函数，来计算列表中有多少项。
>>> a ['Apple', 'Facebook', 'Oracle', 'Amazon', 'Microsoft', 'Baidu', 'Alibaba'] >>> len(a) 7
max()，返回列表中的最大值；
min()，返回列表中的最小值。
>>> a=[1,2,3,4,5,6,7,8,9] >>> max(a) 9 >>> min(a) 1
6.4 字符串中使用的in和not in，在列表中同样适用。
>>> a ['Apple', 'Facebook', 'Oracle', 'Amazon', 'Microsoft', 'Baidu', 'Alibaba'] >>> d='Amazon' >>> if d in a: print("a中包含d") a中包含d >>> e='IBM' >>> if e not in a: print("a中没有e") a中没有e
6.5 列表表达式
>>> a=[x+100 for x in range(10)] >>> a [100, 101, 102, 103, 104, 105, 106, 107, 108, 109]
分析一下：
1）for x in range(10)，返回的是一个列表，从0到9。
2）a的格式是[.......]，那么a也是一个列表，不过a的值是在上面这个列表值基础上加上了100。
6.6 列表的方法
所谓方法，就是列表改变自身的用法。
1）a.append(b)，a是列表，b是新的值。执行后，会把b加到a的最后一项。
>>> a [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> a.append(10) >>> a [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
2）a.count(b)，a是列表，b是1个值。执行后，返回b在a中出现的次数。
>>> f=[1,2,3,4,5,6,7,8,1,2,1,9] >>> f.count(1) 3
3）a.count(b)，a是列表，b也是列表。执行后，把b接在a的后面。
>>> a [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> f [1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 1, 9] >>> a.extend(f) >>> a [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 1, 9]
4）a.index(b)，a是列表，b是一个值。执行后，返回b在a中第一次出现时的索引值。
>>> a [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 1, 9] >>> a.index(8) 7
这里再次强调索引值，从0开始！！！
5）a.insert(b,c)，a是列表，b是索引值，c是一个值。执行后，把c按照索引值b插入a。
>>> a.insert(3,"JD") >>> a [1, 2, 3, 'JD', 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 1, 9]
6）a.remove(b)，a是列表，b是一个值。执行后，删除第一个匹配值。
>>> c ['Apple', 'Facebook', 'Oracle', 'JD', 'Amazon', 'Microsoft', 'Baidu', 'Alibaba', 'Tencent', 'JD'] >>> c.remove("JD") >>> c ['Apple', 'Facebook', 'Oracle', 'Amazon', 'Microsoft', 'Baidu', 'Alibaba', 'Tencent', 'JD']
7）a.reverse()，a是列表。执行后，列表a反转。
>>> c ['Apple', 'Facebook', 'Oracle', 'Amazon', 'Microsoft', 'Baidu', 'Alibaba', 'Tencent', 'JD'] >>> c.reverse() >>> c ['JD', 'Tencent', 'Alibaba', 'Baidu', 'Microsoft', 'Amazon', 'Oracle', 'Facebook', 'Apple']
8）a.pop(b)，a是列表，b是索引（默认值是-1）。执行后把a中指定的索引值删除，并返回删除的值。
>>> c ['JD', 'Tencent', 'Alibaba', 'Baidu', 'Microsoft', 'Amazon', 'Oracle', 'Facebook', 'Apple'] >>> c.pop() 'Apple' >>> c ['JD', 'Tencent', 'Alibaba', 'Baidu', 'Microsoft', 'Amazon', 'Oracle', 'Facebook'] >>> c.pop(1) 'Tencent' >>> c ['JD', 'Alibaba', 'Baidu', 'Microsoft', 'Amazon', 'Oracle', 'Facebook']
9）a.sort()，a是列表。执行后，a中的值按需排列。
>>> h=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 1, 9] >>> h.sort() >>> h [1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10]
再看这个例子：
>>> a=[9,6,2,5,1,7] >>> a [9, 6, 2, 5, 1, 7] >>> b=a.sort() >>> b >>> a [1, 2, 5, 6, 7, 9]
我们看到a.sort改变了a中元素的排列顺序。但是并未向b赋值！！！
另外，list.sort()这个函数可以有2个参数，即：list.sort(key,reverse)。其中key是一个函数，这个函数会在列表中每一个元素被调用时执行一次；reverse默认为False，即升序排列，如果写成reverse=True就会变成降序排列。
例如：
list_001=['apple','facebook','whatsapp','baidu','tencent']
list_001.sort(key=hanshu_001,reverse=True)
结果是什么呢？
a) 首先，list_001本身被修改、被排序、排倒序。
b) list_001中的元素在排序时：调用第一个元素‘apple’时，会执行hanshu_001(apple)，之后调用第二个元素‘facebook’，也会执行hanshu_001(facebook)......说白了就是排序并未按照list_00中的元素排序，而是按照hanshu_001把每个元素做了处理，然后再排序。
看示例：
>>> student_tuples = [ ('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10), ] >>> student_tuples.sort(key=lambda student: student[2]) >>> student_tuples [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
如果key函数指定的值相同，则顺序不变。
另外，key函数不仅可以访问需要排序元素的内部数据，还可以访问外部的资源，例如，如果学生的成绩是存储在dictionary中的，则可以使用此dictionary来对学生名字的list排序，看示例：
>>> students = ['dave', 'john', 'jane'] >>> newgrades = {'john': 'F', 'jane':'A', 'dave': 'C'} >>> students.sort(key=newgrades.__getitem__) >>> students ['jane', 'dave', 'john']
分析一下：key函数指定字典newgrades中值为排序参照，然后对students中的元素做排序，排升序。
10）a.clear()，a是列表。执行后，清空a中的值，使a称为一个空列表。
>>> h [1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10] >>> h.clear() >>> h []
11）a.copy()，a是列表。
>>> j=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 1, 9] >>> k=j.copy() >>> k [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 1, 9]
7、列表解析
什么是列表解析？
简单来说，列表解析（list comprehension）提供了一种优雅的生成列表的方法，能用一行代码代替十几行代码，而且不损失任何可读性。而且，性能还快很多很多。
简单给个例子，如果我们需要0~100所有偶数组成的列表，正常的代码应该是这样的：
>>> a=[] >>> for i in range(101): if i%2==0: a.append(i) >>> a [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]
用列表解析来做就是这样的：
>>> a=[x for x in range(101) if x%2==0] >>> a [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]
简单的一行代码代替了4行代码
从上面的例子来看列表解析的语法其实不难，可以把[ ]中的代码分成三个部分来看
1）x：我们需要的列表里面的结果(第一部分)
2）for x in range(101)：x来源——0~100的数字(第二部分)
3）if x%2==0：x成立的条件，如果不成立就不放在列表里了(第三部分)
>>> text="My house is full of flowers" >>> first_charts=[] >>> for word in text.split(): first_charts.append(word[0]) >>> first_charts ['M', 'h', 'i', 'f', 'o', 'f']
对比一下使用列表解析的代码：
>>> text='I wanna learn Python.'
>>> first_charts=[]
>>> for word in text.split():
first_charts.append(word[0])
>>> first_charts
['I', 'w', 'l', 'P']
可以看出，列表解析的第一部分也可以是任意一个表达式。
示例3：
来个复杂的，a=[6,7,8,9]；b=[1,2,3,4],想要得到a，b对应位的乘积：
>>> a=[6,7,8,9] >>> b=[1,2,3,4] >>> c=[i*j for i,j in zip(a,b)] >>> c [6, 14, 24, 36]
除了列表解析，还需要使用zip函数来帮忙，zip将a,b对应位打包起来，返回[[2,3][3,4][4,5][5,6]]
示例4：
带有if else的列表解析
list_a=['9','2','3','i','7']，现在想将a中所有能转化为数字的字符串转化为数字，不为数字的内容都转换成0，用列表解析可以这样写：
>>> list_a=['9','2','3','i','7'] >>> b=[int(i) if i.isdigit() else 0 for i in list_a] >>> b [9, 2, 3, 0, 7]
如果list_a=['7','2','3',8,125,'o','6']，如果不能转换成数字则为None，列表解析可以这样写：
>>> list_a=['7','2','3',8,125,'o','6'] >>> c=[int(i) if str(i).isdigit() else None for i in list_a] >>> c [7, 2, 3, 8, 125, None, 6]
可以看到，在第一个部分，可以嵌套若干if else的语句在表达式里面。
示例5：
有时候我们可能需要获取一个长度指定，全为某个值列表：
>>> a=['Python' for i in range(10)] >>> a ['Python', 'Python', 'Python', 'Python', 'Python', 'Python', 'Python', 'Python', 'Python', 'Python']
得到一个长度为10的，每个元素都是‘Python’的列表。
示例6：
略复杂的列表解析，获取列表中嵌套列表的元素，生成一个无嵌套的新列表：
这个例子说起来挺拗口，实际上是想从[[1,2],[3,4,5],[6,7]，[8]]这种列表中，把嵌套在列表中的元素解出来，得到[1,2,3,4,5,6,7,8]，用列表解析可以这样写：
>>> a=[[1,2],[3,4,5],[6,7],[8]] >>> b=[x for i in a for x in i] >>> b [1, 2, 3, 4, 5, 6, 7, 8]
理解起来略有一点麻烦，for i in a，i为子列表，for x in i，x得到每个子列表中的值。这样的列表解析写法确实很难理解，所以有时候我们不要过分的使用复杂的列表解析。
示例7：
获取笛卡尔积。
假设有三个配置列表：
>>> a=['4k','8k','12k'] >>> b=['1','2,','3'] >>> c=['libaio','bio','directio']
我们想获取其笛卡尔积，列表解析的写法，得到：
>>> a=['4k','8k','12k'] >>> b=['1','2,','3'] >>> c=['libaio','bio','directio'] >>> d=[{'blocksize':x,'numjobs':y,'ioengine':z} for x in a for y in b for z in c] >>> d [{'blocksize': '4k', 'numjobs': '1', 'ioengine': 'libaio'}, {'blocksize': '4k', 'numjobs': '1', 'ioengine': 'bio'}, {'blocksize': '4k', 'numjobs': '1', 'ioengine': 'directio'}, {'blocksize': '4k', 'numjobs': '2,', 'ioengine': 'libaio'}, {'blocksize': '4k', 'numjobs': '2,', 'ioengine': 'bio'}, {'blocksize': '4k', 'numjobs': '2,', 'ioengine': 'directio'}, {'blocksize': '4k', 'numjobs': '3', 'ioengine': 'libaio'}, {'blocksize': '4k', 'numjobs': '3', 'ioengine': 'bio'}, {'blocksize': '4k', 'numjobs': '3', 'ioengine': 'directio'}, {'blocksize': '8k', 'numjobs': '1', 'ioengine': 'libaio'}, {'blocksize': '8k', 'numjobs': '1', 'ioengine': 'bio'}, {'blocksize': '8k', 'numjobs': '1', 'ioengine': 'directio'}, {'blocksize': '8k', 'numjobs': '2,', 'ioengine': 'libaio'}, {'blocksize': '8k', 'numjobs': '2,', 'ioengine': 'bio'}, {'blocksize': '8k', 'numjobs': '2,', 'ioengine': 'directio'}, {'blocksize': '8k', 'numjobs': '3', 'ioengine': 'libaio'}, {'blocksize': '8k', 'numjobs': '3', 'ioengine': 'bio'}, {'blocksize': '8k', 'numjobs': '3', 'ioengine': 'directio'}, {'blocksize': '12k', 'numjobs': '1', 'ioengine': 'libaio'}, {'blocksize': '12k', 'numjobs': '1', 'ioengine': 'bio'}, {'blocksize': '12k', 'numjobs': '1', 'ioengine': 'directio'}, {'blocksize': '12k', 'numjobs': '2,', 'ioengine': 'libaio'}, {'blocksize': '12k', 'numjobs': '2,', 'ioengine': 'bio'}, {'blocksize': '12k', 'numjobs': '2,', 'ioengine': 'directio'}, {'blocksize': '12k', 'numjobs': '3', 'ioengine': 'libaio'}, {'blocksize': '12k', 'numjobs': '3', 'ioengine': 'bio'}, {'blocksize': '12k', 'numjobs': '3', 'ioengine': 'directio'}] >>>
这样就得到一个包含所有参数项目的字典列表，避免了写若干个for循环
示例8：
获取所有可能的组合。
假设有一个配置列表['a','b','c'],我们想获取所有的由a,b,c组成的字符串（可以重复使用，将顺序也考虑在内），列表解析需要配合itertools中的product函数：
>>> from itertools import product >>> x=['a','b','c'] >>> results = ["".join(i) for i in product(x, repeat=3)] >>> results ['aaa', 'aab', 'aac', 'aba', 'abb', 'abc', 'aca', 'acb', 'acc', 'baa', 'bab', 'bac', 'bba', 'bbb', 'bbc', 'bca', 'bcb', 'bcc', 'caa', 'cab', 'cac', 'cba', 'cbb', 'cbc', 'cca', 'ccb', 'ccc']
示例9：
矩阵转置
考虑一个矩阵，matrix=[[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12]]，现在要获得他的转置矩阵，用列表解析仍然是一行：
>>> matrix=[[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12]] >>> a=[list(row) for row in zip(*matrix)] >>> a [[1, 2, 3], [2, 4, 6], [3, 6, 9], [4, 8, 12]]
matrix使用zip解开（完成转置），列表解析负责将结果生成原来的列表嵌套列表的模式
这个case也可以不用列表解析：
>>> b=list(map(list, zip(*matrix))) >>> b [[1, 2, 3], [2, 4, 6], [3, 6, 9], [4, 8, 12]]
也可以使用map函数来实现
列表解析的运行速度
相比于for循环，列表解析的语法是由底层c语言实现的，它和使用for循环遍历对象相比，性能会有很大的提升。
列表解析的将会大大提高python代码的执行效率，在实际工作中感觉也同样明显，应该尽量多使用列表解析。
这是另外一篇关于列表解析的博文
https://www.cnblogs.com/liu-shuai/p/6098227.html
这里贴出示例，供大家学习。
要求：列出1~10所有数字的平方 #################################################### 1、普通方法： >>> L = [] >>> for i in range(1,11): ... L.append(i**2) ... >>> print L [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] #################################################### 2、列表解析 >>>L = [ i**2 for i in range(1,11)] >>>print L [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
要求：列出1~10中大于等于4的数字的平方 #################################################### 1、普通方法： >>> L = [] >>> for i in range(1,11): ... if i >= 4: ... L.append(i**2) ... >>> print L [16, 25, 36, 49, 64, 81, 100] #################################################### 2、列表解析 >>>L = [ i**2 for i in range(1,11) if i >= 4 ] >>>print L [16, 25, 36, 49, 64, 81, 100]
要求：列出1~10所有数字的平方除以2的值 #################################################### 1、普通方法 >>> L = [] >>> for i in range(1,11): ... L.append(i**2/2) ... >>> print L [0, 2, 4, 8, 12, 18, 24, 32, 40, 50] #################################################### 2、列表解析 >>> L = [i**2/2 for i in range(1,11) ] >>> print L [0, 2, 4, 8, 12, 18, 24, 32, 40, 50]
要求：列出"/var/log"中所有已'.log'结尾的文件 ################################################## 1、普通方法 >>>import os >>>file = [] >>> for file in os.listdir('/var/log'): ... if file.endswith('.log'): ... file.append(file) ... >>> print file ['anaconda.ifcfg.log', 'Xorg.0.log', 'anaconda.storage.log', 'Xorg.9.log', 'yum.log', 'anaconda.log', 'dracut.log', 'pm-powersave.log', 'anaconda.yum.log', 'wpa_supplicant.log', 'boot.log', 'spice-vdagent.log', 'anaconda.program.log'] ################################################## 2.列表解析 >>> import os >>> file = [ file for file in os.listdir('/var/log') if file.endswith('.log') ] >>> print file ['anaconda.ifcfg.log', 'Xorg.0.log', 'anaconda.storage.log', 'Xorg.9.log', 'yum.log', 'anaconda.log', 'dracut.log', 'pm-powersave.log', 'anaconda.yum.log', 'wpa_supplicant.log', 'boot.log', 'spice-vdagent.log', 'anaconda.program.log']
要求：实现两个列表中的元素逐一配对。 1、普通方法: >>> L1 = ['x','y','z'] >>> L2 = [1,2,3] >>> L3 = [] >>> for a in L1: ... for b in L2: ... L3.append((a,b)) ... >>> print L3 [('x', 1), ('x', 2), ('x', 3), ('y', 1), ('y', 2), ('y', 3), ('z', 1), ('z', 2), ('z', 3)] #################################################### 2、列表解析: >>> L1 = ['x','y','z'] >>> L2 = [1,2,3] L3 = [ (a,b) for a in L1 for b in L2 ] >>> print L3 [('x', 1), ('x', 2), ('x', 3), ('y', 1), ('y', 2), ('y', 3), ('z', 1), ('z', 2), ('z', 3)]
使用列表解析生成 9*9 乘法表
>>> print('\n'.join([''.join(['%s*%s=%-2s '%(y,x,x*y)for y in range(1,x+1)])for x in range(1,10)])) 1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
二、字典
1、创建字典
>>> d={"name":"zhaoyun","age":30,"height":190,"weight":80}
创建一个变量d，并赋值一个字典给d。
前面说过“name”、“age”这些是键，“zhaoyun”和30这些是值。
2、创建空字典。
f=dict()
f就是一个变量，它得值是一个空白的字典。
3、从字典中取值。
>>> d {'name': 'zhaoyun', 'age': 30, 'height': 190, 'weight': 80} >>> d['name'] 'zhaoyun' >>> d['age'] 30
4、修改字典。可以修改既有的值，也可以增加键和值。
>>> d {'name': 'zhaoyun', 'age': 30, 'height': 190, 'weight': 80} >>> d['age']=40 >>> d['address']='China' >>> d {'name': 'zhaoyun', 'age': 40, 'height': 190, 'weight': 80, 'address': 'China'}
5、删除字典中的项或者删除字典。
>>> d {'name': 'zhaoyun', 'age': 40, 'height': 190, 'weight': 80, 'address': 'China'} >>> del d['age'] >>> d {'name': 'zhaoyun', 'height': 190, 'weight': 80, 'address': 'China'} >>> d.clear() >>> d {} >>> del d >>> d Traceback (most recent call last): File "<pyshell#103>", line 1, in <module> d NameError: name 'd' is not defined
del d['age']，删除键‘age’即对应值。
d.clear()，清空字典d，但d扔是一个字典，只不过没有值。
del d，删除d这个字典对象，所以执行后再看d的值，系统报错，因为d已经被删除。
6、字典的键，不能使列表，可以是数字、字符串或元组。
7、创建字典时，字典中的键不能重复，否则取值的时候，只能取最后一个值。
>>> f={'name': 'zhaoyun', 'age': 40, 'height': 190, 'weight': 80, 'address': 'China','height':195,'height':200}
>>> f['height']
200
>>> f
{'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'}
8、函数
和列表类似，字典也有适用的函数和方法
8.1 len(f)，返回字典键的个数。
>>> f {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'} >>> len(f) 5
8.2 str(f),输出字典
>>> f {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'} >>> str(f) "{'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'}"
8.3 type(f)
>>> f {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'} >>> type(f) <class 'dict'>
9、字典适用的方法
**下列中的f都是指一个字典。
9.1 f.clear()
删除字典内所有元素
>>> f {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'} >>> f.clear() >>> f {}
9.2 f.copy()
返回一个字典的浅复制
>>> f={'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'}
>>> h=f.copy()
>>> h
{'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'}
再执行
>>> g=f >>> g {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'} >>> f['age']=35 >>> f {'name': 'zhaoyun', 'age': 35, 'height': 200, 'weight': 80, 'address': 'China'} >>> g {'name': 'zhaoyun', 'age': 35, 'height': 200, 'weight': 80, 'address': 'China'} >>> h {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'}
我们看到，浅复制得到的字典h，并未随着f的修改而改变，g却随着f的修改而变化。
9.3 f.fromkeys([a],b)
创建一个新字典，以序列a中元素做字典的键，b为字典所有键对应的初始值。其中b可以不填写，则生成的字典有键，值都是None。
>>> j {} >>> j.fromkeys(['name','age'],"Tom") {'name': 'Tom', 'age': 'Tom'}
9.4 f.get(key, b)
返回指定键的值，如果值不在字典中返回b。
>>> h {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'} >>> h.get('age') 40 >>> h.get('age',111) 40 >>> h.get('salary',111) 111
9.5 key in f
如果键在字典dict里返回true，否则返回false。
>>> h {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'} >>> 'name' in h True >>> 'salary' in h False
9.6 f.items()
以列表返回可遍历的(键, 值) 元组数组。
>>> h.items() dict_items([('name', 'zhaoyun'), ('age', 40), ('height', 200), ('weight', 80), ('address', 'China')])
9.7 f.keys()
以列表返回一个字典所有的键。
>>> h {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'} >>> h.keys() dict_keys(['name', 'age', 'height', 'weight', 'address'])
9.8 f.setdefault(key, b)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为b。
>>> h {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'} >>> h.setdefault('age',111) 40 >>> h.setdefault('salary',111) 111
9.9 f.update(i)
把字典i的键/值对更新到字典f中。
>>> h {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'} >>> i=h >>> i['salary']=10000 >>> i {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China', 'salary': 10000} >>> h.update(i) >>> h {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China', 'salary': 10000}
9.10 f.values()
以列表返回字典中的所有值。
>>> h {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China', 'salary': 10000} >>> h.values() dict_values(['zhaoyun', 40, 200, 80, 'China', 10000])
9.11 f.pop(key,b)
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回b。
>>> h {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China', 'salary': 10000} >>> h.pop('salary',111) 10000 >>> h {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'} >>> h.pop('salary',111) 111
9.12 f.popitem()
随机返回并删除字典中的一对键和值(一般删除末尾对)。
>>> h {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80, 'address': 'China'} >>> h.popitem() ('address', 'China') >>> h {'name': 'zhaoyun', 'age': 40, 'height': 200, 'weight': 80}
10、上面讲到了列表解析，下面介绍下字典解析。
10.1 交换键和值
>>> a={'name':'zhaoyun','age':23,'height':180}
>>> b={value:key for key,value in a.items()}
>>> b
{'zhaoyun': 'name', 23: 'age', 180: 'height'}
10.2 生成字典时，有个问题，一起来看下
>>> {key:value for key in "ABC" for value in range(1,10)}
{'A': 9, 'B': 9, 'C': 9}
>>> {key:value for key in "ABC" for value in "JKL"}
{'A': 'L', 'B': 'L', 'C': 'L'}
按照此方法生成的字典，所有键对应的值都是相同的。
10.3 字典解析的几种方法
a) 使用for
>>> aList={'a','b','c','d'}
>>> bList={1,2,3,4}
>>> aDict={x:y for (x,y) in zip(aList,bList)}
>>> aDict
{'a': 1, 'd': 2, 'c': 3, 'b': 4}
b) 使用dict函数
>>> aList={'a','b','c','d'}
>>> bList={1,2,3,4}
>>> aDict=dict(zip(aList,bList))
>>> aDict
{'a': 1, 'd': 2, 'c': 3, 'b': 4}
c) 使用运算结果生成字典
>>> aList={'a','b','c','d'}
>>> bList={1,2,3,4}
>>> aDict={x:y**2 for (x,y) in zip(aList,bList)}
>>> aDict
{'a': 1, 'd': 4, 'c': 9, 'b': 16}
>>> aList={x*x for x in range(5) if x%2==0}
>>> aList
{0, 16, 4}
11、遍历字典的集中方法
a）遍历键
>>> a
{'a': '1', 'b': '2', 'c': '3'}
>>> for key in a:
print(key+':'+a[key])
a:1
b:2
c:3
>>> for key in a.keys():
print(key+':'+a[key])
a:1
b:2
c:3
在使用上，for key in a和 for key in a.keys():完全等价。
b）遍历值
>>> for value in a.values():
print(value)
1
2
3
c）遍历字典项
>>> for kv in a.items():
print(kv)
('a', '1')
('b', '2')
('c', '3')
d）遍历键值对儿
>>> for key,value in a.items():
print(key+':'+value)
a:1
b:2
c:3
>>> for (key,value) in a.items():
print(key+':'+value)
a:1
b:2
c:3
在使用上for key,value in a.items()与for (key,value) in a.items()完全等价。
>>> a={'name':'zhaoyun','age':23,'height':200}
>>> for i in a:
print(i)
#遍历字典对象，返回值是“键”，而不是“值”
name
age
height
>>> for i in a.values():
print(i)
#通过.values()可以遍历字典的值
zhaoyun
23
200
#下列2种方法均可遍历字典
>>> for i in a:
print(i,':',a[i])
name : zhaoyun
age : 23
height : 200
>>> for i,j in a.items():
print(i,':',j)
name : zhaoyun
age : 23
height : 200
