一.创建和使用字典
列表 元组
共同点：都是通过索引引用元素值
不同点：列表是可读写的，元组是只读的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| 1names = ["Bill", "Mike", "John", "Mary"]
2numbers = ["1234", "4321", "6789", "6543"]
3print(numbers[names.index("Mike")])
4print(names[numbers.index("6543")])
5结果：
64321
7Mary
8# key和value
9phoneBook = {"Bill":"1234","Mike":"4321","John":"6645","Mary":"7753"}
10print(phoneBook)
11print(phoneBook["Bill"])
12结果：
13{'Bill': '1234', 'Mike': '4321', 'John': '6645', 'Mary': '7753'}
141234
15
16 |
1.1.1 dict函数
1
2
3
4
5
6
7
| 1items = [['Bill',"4321"],("Mike","7891"),['John','4567']]
2d = dict(items)
3print(d)
4结果：
5{'Bill': '4321', 'Mike': '7891', 'John': '4567'}
6
7 |
1、为dict函数传入一个列表类型参数值，列表的每一个元素（或者是一个列表，或者是一个元祖）包含两个值，第一个表示键，第二个表示值。
2、dict函数通过关键字来创建字典
1
2
3
4
5
6
7
| 1在这里插入代码片
2dict1 = dict(name="Bill", number=6543, age=34)
3print(dict1)
4结果：
5{'name': 'Bill', 'number': 6543, 'age': 34}
6
7 |
1.1.2字典的格式化字符串
1
2
3
4
5
6
7
8
| 1# 用format_map方法格式化字符串
2values1 = (1,2,'hello')
3str1 = "abc %d xyz, %d %s world"
4print(str1 % values1)
5结果：
6abc 1 xyz, 2 hello world
7
8 |
1.1.3 序列与迭代
1.获取字典中key的列表
1
2
3
4
5
6
| 1dict={"x":1,"y":2,"z":3}
2for key in dict:
3 print(key,end=" ")
4结果：x y z
5
6 |
2.获取字典中key—value对的列表
如果要同时获取字典中的key和value，除了在上面的代码中使用dict[ ]获取值外，还可以使用字典中的items方法同时获取key和value。
1
2
3
4
5
6
7
8
9
| 1dict={"x":1,"y":2,"z":3}
2for key,value in dict.items():
3 print(key,value)
4结果：
5x 1
6y 2
7z 3
8
9 |
1
2
3
4
5
6
| 1dict={"x":1,"y":2,"z":3}
2for key,value in dict.items():
3 print(key,value,end=" ")
4结果：x 1 y 2 z 3
5
6 |
3.并行迭代
如果同时迭代两个或者多个序列，那么可以使用range函数获取序列索引的范围，然后使用for语句进行迭代。对多个序列进行迭代，一般要求序列中的元素个数相同。
1
2
3
4
5
6
7
8
9
10
| 1names=["Bill","Mary","John"]
2ages=[30,40,20]
3for i in range(len(names)):
4 print(names[i],ages[i])
5结果：
6Bill 30
7Mary 40
8John 20
9
10 |
4.压缩序列
这里的压缩序列是指使用zip函数将两个或者多个序列的对应元素作为一个元祖放到一起，进行压缩的两个或者多个序列的元素个数如果不相同，以元素个数最少的为准。
1
2
3
4
5
6
7
8
9
| 1company=["百度","谷歌","小米"]
2web=["https://www.baidu.com","https://www.google.com"]
3for i in zip(company,web):
4 print(i)
5结果：
6('百度', 'https://www.baidu.com')
7('谷歌', 'https://www.google.com')
8
9 |
5.反转序列迭代
通过reversed函数将一个序列反转
1
2
3
4
5
| 1company=reversed(["百度","谷歌","小米"])
2print(company)
3结果：<list_reverseiterator object at 0x0000000001D86550>
4
5 |
1
2
3
4
5
6
7
| 1company=reversed(["百度","谷歌","小米"])
2for i in company:
3 print(i,end=" ")
4结果：小米 谷歌 百度
5
6
7 |
二.字典方法
2.1.1 clear方法
1
2
3
4
5
6
7
8
9
10
11
| 1names1 = {"Bill":20, "Mike":30,"John":50}
2names2 = names1
3names1["Bill"] = 45
4print(names2)
5names1.clear()
6print(names2)
7结果：
8{'Bill': 45, 'Mike': 30, 'John': 50}
9{}
10
11 |
2.1.2 copy方法和deepcopy方法
浅拷贝（copy）
浅拷贝是对于一个对象的顶层拷贝—-通俗的理解是：拷贝了引用，并没有拷贝内容
其中，C语言是真正的复制对象中的内容
1
2
3
4
5
6
7
8
9
10
11
12
| 1import copy
2a=[11,12]
3b=[22,23]
4c=[a,b]
5print(c) 结果：[[11, 12], [22, 23]]
6
7e=copy.copy(c)
8print(id(c)) 结果：165886536
9print(id(e)) 结果:31244488
10print(e) 结果：[[11, 12], [22, 23]]
11
12 |
深拷贝
深拷贝是对于一个对象所有层次的拷贝(递归)
进一步理解深拷贝
拷贝的其他方式
分片表达式可以赋值一个序列
字典的copy方法可以拷贝一个字典
注意点：
浅拷贝对不可变类型和可变类型的copy不同
①copy.copy对于可变类型，会进行浅拷贝
②copy.copy对于不可变类型，不会拷贝，仅仅是指向
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| 1In [88]: a = [11,22,33]
2In [89]: b = copy.copy(a)
3In [90]: id(a)
4Out[90]: 59275144
5In [91]: id(b)
6Out[91]: 59525600
7In [92]: a.append(44)
8In [93]: a
9Out[93]: [11, 22, 33, 44]
10In [94]: b
11Out[94]: [11, 22, 33]
12-----------------------------------------------------------
13In [95]: a = (11,22,33)
14In [96]: b = copy.copy(a)
15In [97]: id(a)
16Out[97]: 58890680
17In [98]: id(b)
18Out[98]: 58890680
19
20 |
2.1.3 fromkeys方法
fromkeys方法用于根据key建立新的字典（该方法的返回值就是新的字典）。在新的字典中，所有的key都有相同的默认值。在默认情况下，fromkeys方法会为每一个key指定None为其默认值。不过可以使用fromkeys方法的第2个参数设置新的默认值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| 1#在一个空字典上调用fromkeys方法创建一个新的字典（newdict），通过列表指定key
2newdict1 = {}.fromkeys(['name','age','company'])
3print(newdict1)
4#输出结果：{'name': None, 'age': None, 'company': None}
5
6
7#在newdict1上调用fromkeys方法创建一个新的字典（newdict2），通过元组指定key
8newdict2 = newdict1.fromkeys(('name','age','company'))
9print(newdict2)
10#输出结果：{'name': None, 'age': None, 'company': None}
11
12
13#通过fromkeys方法的第2个参数指定key的默认值，通过列表指定key
14newdict3 = newdict1.fromkeys(['name','age','company'],'没有值')
15print(newdict3)
16#输出结果：{'name': '没有值', 'age': '没有值', 'company': '没有值'}
17
18 |
2.1.4 get( )方法
当使用dict[key]形式从字典获取value时，如果key在dict中不存在，那么程序会抛出异常。
1
2
3
4
5
6
7
8
9
10
11
| 1dict = {"name":"Bill", "age":30}
2print(dict["age"])
3#dict['salary'] = 3000
4print(dict['salary'])
5结果：
6Traceback (most recent call last):
7 File "D:/pycharm/工程/网页爬虫/练习.py", line 5, in <module>
8 print(dict['salary'])
9KeyError: 'salary'
10
11 |
get()方法用于更宽松的访问字典项的方法。如果Key不存在，使用get()没有任何异常，仅仅返回None值.
1
2
3
4
5
6
7
8
9
| 1dict = {"name":"Bill", "age":30}
2print(dict["age"])
3#dict['salary'] = 3000
4print(dict.get('salary',3000))
5结果：
630
73000
8
9 |
2.1.5 items( )方法和keys( )方法
items方法用于返回字典中所有key-value对。获得的每一个key-value对用一个元组表示。items方法返回的值是一个被称为字典视图的特殊类型，可以被用于迭代（如果用在for循环中）。items方法的返回值与字典使用了同样的值，也就是说，修改了字典或items方法的返回值，修改的结果就会反映在另一个方法上。keys方法用于返回字典中所有的key，返回值类型与items方法类似，可以用于迭代。
【2.1.4】本例演示了如何使用items方法获取字典中的key-value对，以及使用keys方法获取字典中所有的key，并通过for循环迭代items方法和keys方法的返回值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| 1#定义一个字典
2dict = {'help':'帮助','bike':'自行车','banana':'香蕉','China':'中国'}
3
4#在控制台输出字典中所有的key-value对
5print(dict.items())
6
7#通过for循环对dict中所有的值对进行迭代
8for key_value in dict.items():
9 print('key','=',key_value[0],'value','=',key_value[1])
10
11#判断('bike','自行车')是否在items方法的返回值中
12print(('bike','自行车') in dict.items())
13
14
15#获取key-value对
16dict_items = dict.items()
17#修改字典中的值
18dict['bike'] = '自行车;摩托车;电动车;'
19
20#修改字典中的值后，dict_items中的值也会随着变化
21print(dict_items)
22
23#输出字典中所有的key
24print(dict.keys())
25
26#对字典中所有的key进行迭代
27for key in dict.keys():
28 print(key,end = ' ')
29
30
31 |
结果：
1
2
3
4
5
6
7
8
9
10
11
12
| 1dict_items([('help', '帮助'), ('bike', '自行车'), ('banana', '香蕉'), ('China', '中国')])
2key = help value = 帮助
3key = bike value = 自行车
4key = banana value = 香蕉
5key = China value = 中国
6True
7dict_items([('help', '帮助'), ('bike', '自行车;摩托车;电动车;'), ('banana', '香蕉'), ('China', '中国')])
8dict_keys(['help', 'bike', 'banana', 'China'])
9help bike banana China
10Process finished with exit code 0
11
12 |
2.1.6 pop( )方法和popitem( )方法
pop方法与popitem方法都用于弹出字典中的元素。pop方法用于获取指定key的值，并从字典中弹出这个key-value对。popitem方法用于返回字典中最后一个key-value对，并弹出这个key-value对。对于字典来说，里面的元素并没有顺序的概念，也没有append或类似的方法，所以这里所说的最后一个key-value对，也就是为字典添加key-value对时的顺序，最后一个添加的key-value对就是最后一个元素。
1
2
3
4
5
6
7
8
9
10
11
12
13
| 1# pop方法，用于获取指定的key的值，并从字典中弹出这个key-value对
2# popitem方法用于返回字典中最后一个key-value对，并弹出key-value对
3d = {'c':10,'a':40,'b':12,'x':45}
4d['1'] = 20
5d['5'] = 100
6
7print(d.pop('a'))
8print(d)
9
10for i in range(len(d)):
11 print(d.popitem())
12
13 |
结果：
1
2
3
4
5
6
7
8
9
| 140
2{'c': 10, 'b': 12, 'x': 45, '1': 20, '5': 100}
3('5', 100)
4('1', 20)
5('x', 45)
6('b', 12)
7('c', 10)
8
9 |
2.1.7 setdefault()方法
setdefault方法用于设置key的默认值。该方法接收两个参数，第1个参数表示key，第2个参数表示默认值。如果key在字典中不存在，那么setdefault方法会向字典中添加这个key，并用第2个参数作为key的值。该方法会返回这个默认值。如果未指定第2个参数，那么key的默认值是None。如果字典中已经存在这个key，setdefault不会修改key原来的值，而且该方法会返回key原来的值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| 1d = {"name":"Bill", "age":30}
2d['salary'] = 2000
3d['age'] = 50
4
5# None
6print(d.setdefault("location","中国"))
7print(d)
8print(d.setdefault("location", "德国"))
9print(d)
10
11print(d.setdefault("abc"))
12print(d)
13
14 |
结果：
1
2
3
4
5
6
7
8
| 1中国
2{'name': 'Bill', 'age': 50, 'salary': 2000, 'location': '中国'}
3中国
4{'name': 'Bill', 'age': 50, 'salary': 2000, 'location': '中国'}
5None
6{'name': 'Bill', 'age': 50, 'salary': 2000, 'location': '中国', 'abc': None}
7
8 |
2.1.8 update( )方法
1.用一个字典中的key-value对更新另外一个字典，该方法接收一个参数
2.该参数表示用作更新数据的字典数据源。
3.dict1.update(dict2),dict2中的元素更新dict1。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 1d1 = {
2 'title':'美好',
3 'website':'小米',
4 'description':'手机'
5}
6
7d2 = {
8 'title':'百度',
9 'products':['贴吧','博客','读书频道','百度文库'],
10 'description':'搜索'
11 }
12d1.update(d2)
13print(d1)
14
15 |
结果：
1
2
3
| 1{'title': '百度', 'website': '小米', 'description': '搜索', 'products': ['贴吧', '博客', '读书频道', '百度文库']}
2
3 |
2.1.9 values( ) 方法
values方法用于以迭代器形式返回字典中值的列表。与keys方法不同的是，values方法返回的值的列表可以有重复。而keys方法返回的键值列表不会有重复的key。
1
2
3
4
5
6
7
8
9
10
11
12
13
| 1d = {
2 'a':1,
3 'b':2,
4 'c':2,
5 'd':4,
6 'e':1,
7}
8print(d.values())
9#对值列表进行迭代
10for value in d.values():
11 print(value)
12
13 |
结果：
1
2
3
4
5
6
7
8
| 1dict_values([1, 2, 2, 4, 1])
21
32
42
54
61
7
8 |
进一步理解深拷贝
