记录python字典dictionary常见操作

1. 创建字典

1.1 dict(**kwarg)

• 通过传入dict函数关键字参数来创建字典，注意key是字符串的话也不用加引号，相当于变量。

dict_1 = dict(a=1,b=2)
print(dict_1) # 输出{'a': 1, 'b': 2}

1.2 dict(mapping,**kwarg)

• 通过传入一个映射对象（字典）以及关键字参数来创建字典

dict_2 = {'a':1,'b':2} 	 #等价于 dict_2 =dict({'a':1,'b':2} )

# 也可以同时传入一个字典以及关键字参数创建字典，关键字参数要在最后面
dict_3 =dict({'a':1,'b':2},c=3,d=4 )
print(dict_3) # 输出{'a': 1, 'b': 2, 'c': 3, 'd': 4}

1.3 dict(iterable,**kwarg)

• 通过传入dict函数一个双值子序列以及关键字参数来创建字典。
• 双值子序列：首先是一个序列对象，比如元祖、列表等，而且这个序列对象的每一个元素也是一个含有两个元素的序列。比如((1,2),(3,4),(5,6))、[[‘a’,‘b’]]。

dict_4 = dict([('a',1),('b',2)])
print(dict_4) # {'a': 1, 'b': 2}
# 双值子序列和关键字参数同时传入
dict_5 = dict([('a',1),('b',2)],c=3, d=4)
print(dict_5)
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

1.4 fromkeys(iterable[,value])

• 作用：用于创建一个key为iterable里面元素的字典，不传入value的值的话就默认value是None。

keys = ['a','b','c']
dict_1 = dict.fromkeys(keys)
print(dict_1) # {'a': None, 'b': None, 'c': None}
# 也可以创建的时候传入一个值value,但是没意义，因为这个value是所有key都一样的
values = [1,2,3] 
dict_1 = dict.fromkeys(keys,values)
# 注意不会将value分配到对应的key
print(dict_1) # {'a': (1, 2, 3), 'b': (1, 2, 3), 'c': (1, 2, 3)}

2. 字典常用操作

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

list(d)、tuple(d)、set(d)

• 获取到字典的key组成的列表、元祖、集合

list(d)  # ['a', 'b', 'c']
tuple(d) #('a', 'b', 'c')
set(d) # {'a', 'b', 'c'}

len(d)

• 获取到字典key的键值对共有几对。

len(d) # 3

d[key]

• 通过字典d的某个key来查询对应的value。

d['b'] # 2

d[key] = value

• 因为字典是可变对象，多有可以进行修改操作。通过赋值来修改对应key的值。

d['a'] = 99
print(d) # {'a': 99, 'b': 2, 'c': 3}

• 若key不存在于字典d里，那么会新增加一组键值对 key:value

d['d'] = 4
print(d) # {'a': 99, 'b': 2, 'c': 3, 'd': 4}

del d[key]

• 删除某个键值对

del d['d']
print(d) # {'a': 99, 'b': 2, 'c': 3}

key in d

• 检查一个key是否存在于字典d中

'a' in d # True
'e' in d # Flase

iter(d)

• 返回一个由字典d的所有key组成的迭代器

for i in iter(d):
    print(i)
# 输出为
a
b
c

clear()

• 清空字典d的键值对 ，但是不会删除字典d这个对象，操作完d为一个空字典。

d.clear()
print(d) # {}

copy()

• 返回一个d的副本dd。为浅复制。一般修改副本dd不会对d产生影响，但是也有特例。

d = {'a':[1,2],'b':(1,2),'c':3}
dd = d.copy()

# 修改dd的某对键值对，它的value为不可变对象，那么对d没影响
dd['b'] = (99,98)
dd['c'] = 999
print(dd) # {'a': [1, 2], 'b': (99, 98), 'c': 999} 
print(d) # {'a': [1, 2], 'b': (1, 2), 'c': 3}  依旧没变

# 修改dd的某对键值对，它的value为可变对象，那么也会修改d的这个value。
# 浅复制就是浅在没有复制到可变对象的value，两个字典的可变对象的value的id还是一样的
dd['a'][0] = 99
print(dd)  # {'a': [99, 2], 'b': (99, 98), 'c': 999}
print(d)   # {'a': [99, 2], 'b': (1, 2), 'c': 3} 这时d也变了

get(key[, default ])

• 获取到字典d里key对应的值，若这个key不存在也不会报错，和直接用d[key]查询的区别就在这。可以设置default，使得key不存在时返回的值。

d = {'a':1,'b':2,'c':3}
d.get('b',0) # 若'b'是字典d的key，返回其值。若不是则返回0.这里返回 2
d.get('e',0) # 若'e'是字典d的key，返回其值。若不是则返回0.这里返回 0
d['e'] # 报错，KeyError: 'e'

items()，keys()，values()

• 分别为获取到字典d的键值对，所有键，所有值。注意他们的格式不是元祖、列表。

d = {'a':1,'b':2,'c':3}
print(d.items()) # dict_items([('a', 1), ('b', 2), ('c', 3)])
print(d.keys())  # dict_keys(['a', 'b', 'c'])
print(d.values()) # dict_values([1, 2, 3])

pop(key[, default ])

• 删除对应key的那个键值对。当不设置defaul时，若key不存在会报错。设置default时，若key不存在会返回设置的default的值。
• 和 del d[key] 的区别。区别就是这个pop方法可以通过设置default来使得key不存在的情况下不报错，而是返回设置的default的值。

d = {'a':1,'b':2,'c':3}
d.pop('a',0) # 'a'存在于d，所以删除键值对'a':1
d.pop('e',0) # 'e'不存在于d，设置了key不存在时返回0，所以返回0

popitem()

• 作用：从后向前逐一删除字典d里的键值对，并且以双值元祖形式返回该键值对。当删除了所有键值对，d为空字典时，再调用该方法会报错。

reversed(d)

• python3.8更新的，之前没有。返回由字典d的所有keys组成的迭代器，然后是反序的。其实就相当于 reversed(d.keys()) ,两者没区别。

setdefault(key[, default ])

• 作用：当key存在于字典d中时，会返回key对应的值。若key不存在于字典d中，则会创建一个以key为键的键值对，对应的value分两种情况：
  • 没设置default，value为None，即增加键值对 key:None。
  • 设置了default的值为 x，则增加键值对 key:x。

update([other ])

• 作用：更新字典d。

d = {'a': 1, 'b': 2, 'c': 3}
# 以下三种写法等价
d.update(a = 99, e = 999)
d.update({'a':99,'e':999})
d.update([('a',99),('b',999)])
print(d) # {'a': 99, 'b': 2, 'c': 3, 'e': 999}

• 原理：当key存在于d，则更新其值。若key不存在于d，则添加这个键值对

d | other_d

• python 3.9 新增
• 作用：返回两个字典的并集。
• 当key重复时，只取other_d的key对应的键值对