字典6：其他方法实操

目录

1. len()

2. in、not in

3. list()

4. iter()

5. reversed()

6. copy()

7. 视图对象

6. 嵌套

7. 字典推导式

---

1. len()

返回字典 d 中的项数。

d = {'a': 1, 'b': 2, 'c': 3, 'x': 4, 'y': 5, 'z': 6}
len(d)
6

2. in、not in

key in d 如果 d 中存在键 key 则返回 True，否则返回 False，key not in d 等价于 not key in d；

对键key是否存在，需要比对key的完整数据，譬如key为元组则要比对整个元组，单个元素相同仍不能判定为存在。

d = {'a':'A',1:'1',0.1:10,(0,'b'):'0'}

#key in d 如果 d 中存在键 key 则返回 True
'a' in d
True
1 in d
True
0.1 in d
True
(0,'b') in d
True

#key in d 如果 d 中不存在键 key 则返回 False
'A' in d
False
'1' in d
False
0 in d
False
'b' in d
False

#key not in d 等价于 not key in d，如果 d 中不存在键 key 则返回 False
'a' not in d
False
1 not in d
False
0.1 not in d
False
(0,'b') not in d
False

#key not in d 如果 d 中不存在键 key 则返回 True
'A' not in d
True
'1' not in d
True
0 not in d
True
'b' not in d
True

3. list()

返回字典 d 中使用的所有键的列表；

list(d) 得到的是字典中所有的 “键” 构成的列表；要得到所有的 “值”，应该使用 list(d.values())；要得到所有的键值对，应该使用list(d.items())。

d = {'a':'A',1:'1',0.1:10,(0,'b'):'0'}

#返回字典 d 中使用的所有键的列表。
list(d)
['a', 1, 0.1, (0, 'b')]

#要得到所有的 “值”，应该使用 list(d.values())
list(d.values())
['A', '1', 10, '0']

#要得到所有的键值对，应该使用list(d.items())
list(d.items())
[('a', 'A'), (1, '1'), (0.1, 10), ((0, 'b'), '0')]

4. iter()

返回以字典的键为元素的迭代器。 

这是 iter(d.keys()) 的快捷方式，想获得字典键值对、值的迭代器，使用iter(d.items())、iter(d.values())。

d = {'a':'A',1:'1',0.1:10,(0,'b'):'0'}

x = iter(d)
x
<dict_keyiterator object at 0x0000026C5FEFDB80>
list(x)
['a', 1, 0.1, (0, 'b')]

5. reversed()

返回一个逆序获取字典键的迭代器。 

这是 reversed(d.keys()) 的快捷方式；要获得键值对、值的逆序，使用reversed(d.items)、reversed(d.values)。

从3.7 版更改: 字典顺序会确保为插入顺序，需注意更早版本不支持该方法。

d = {'a':'A',1:'1',0.1:10,(0,'b'):'0'}

#返回一个逆序获取字典键的迭代器。
reversed(d)
<dict_reversekeyiterator object at 0x0000026C5FF9C400>
list(reversed(d))
[(0, 'b'), 0.1, 1, 'a']

#要获得键值对、值的逆序，使用reversed(d.items)、reversed(d.values)
list(reversed(d.items()))
[((0, 'b'), '0'), (0.1, 10), (1, '1'), ('a', 'A')]
list(reversed(d.values()))
['0', 10, '1', 'A']

6. copy()

返回 d 字典的一个浅拷贝；

不同于列表，字典的浅拷贝，改变其中字典的某个键值对，不影响其浅拷贝的键值对；

如果某个键值对的值为列表、元组中附带列表等情况，则改变该值的某个子列表中某个元素，会影响其他浅拷贝对应键值对的值。

#返回 d 字典的一个浅拷贝
d = {'a': 'x', 'b': 'y', 'c': 'z'}
d2 = d.copy()
d2['a'] is d['a']
True

#不同于列表，字典的浅拷贝，改变其中字典的某个键值对，不影响其浅拷贝的键值对
d['a'] = 0
d
{'a': 0, 'b': 'y', 'c': 'z'}
d2
{'a': 'x', 'b': 'y', 'c': 'z'}

#如果某个键值对的值为列表、元组，则改变该值的某个元素，会影响其他浅拷贝对应键值对的值。
d = {'a': {'x':0.1,'y':0.2,'z':0.3}, 'b': [1,2,3,4,{'rrr':1}], 'c': ([1,2,3],4,5)}
d2 = d.copy()
d['a']['x'] = '变啦！'
d['b'][2] = '变啦！'
d['c'][0][1] = '变啦！'
d2
{'a': {'x': '变啦！', 'y': 0.2, 'z': 0.3}, 'b': [1, 2, '变啦！', 4, {'rrr': 1}], 'c': ([1, '变啦！', 3], 4, 5)}

7. 视图对象

items()、keys() 和 values() 三个方法分别用于获取字典的键值对、键和值三者的视图对象； 

视图对象就是字典的一个动态视图，这意味着当字典内容改变时，视图对象的内容也会相应地跟着改变；

可以通过list()、tuple()将视图对象转换为列表或元组；

视图对象，支持len()、tuple()、list()、iter()、reversed()等方法。

#items()、keys() 和 values() 三个方法分别用于获取字典的键值对、键和值三者的视图对象。

#items()、keys() 和 values() 三个方法分别用于获取字典的键值对、键和值三者的视图对象
d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
x1 = d.items()
x2 = d.keys()
x3 = d.values()
x1
dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
x2
dict_keys(['a', 'b', 'c', 'd'])
x3
dict_values([1, 2, 3, 4])

#改变字典内容，视图对象内容跟着改变
d.update(a=5,b=4,c=3,d=2,e=1)
x1
dict_items([('a', 5), ('b', 4), ('c', 3), ('d', 2), ('e', 1)])
x2
dict_keys(['a', 'b', 'c', 'd', 'e'])
x3
dict_values([5, 4, 3, 2, 1])

#可以通过list()、tuple()将视图对象转换为列表或元组
list(x1)
[('a', 5), ('b', 4), ('c', 3), ('d', 2), ('e', 1)]
tuple(x2)
('a', 'b', 'c', 'd', 'e')
list(x3)
[5, 4, 3, 2, 1]

6. 嵌套

字典也是可以嵌套的，某个键的值可以是另外一个字典或者序列。

d = {'a': {'x':0.1,'y':0.2,'z':0.3}, 'b': [1,2,3,4,{'rrr':1}], 'c': 3}

#字典嵌套字典
d['a']
{'x': 0.1, 'y': 0.2, 'z': 0.3}
d['a']['z']
0.3

#字典嵌套列表嵌套字典
d['b']
[1, 2, 3, 4, {'rrr': 1}]
d['b'][4]
{'rrr': 1}
d['b'][4]['rrr']
1

7. 字典推导式

参考列表推导式 expression for target in iterable ，字典也可以使用字典推导式。

d = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

#d2将d的键值做了交换
d2 = {x:y for y,x in list(d.items())}
d2
{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e'}

#d3将d的键做了逆序，每个键值对的值都从1*1、2*2、3*3、4*4、5*5依次赋值，最后都被覆盖为5*5=25
d3 = {x:y*y for x in list(reversed(d)) for y in list(d.values())}
d3
{'e': 25, 'd': 25, 'c': 25, 'b': 25, 'a': 25}