60D6 – dict 和 set 的 15 个经典使用例子

1. update

实际使用字典时，需要批量插入键值对到已有字典中，使用 update 方法可实现批量插入。

已有字典中批量插入键值对：

In [23]: d = {'a': 1, 'b': 2}

# 方法 1
In [24]: d.update({'c':3,'d':4,'e':5})
In [25]: d
Out[25]: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

# 方法 2
In [31]: d = {'a': 1, 'b': 2}
    ...: d.update([('c',3),('d',4),('e',5)]) # 实现与方法 1 一样效果

In [32]: d
Out[32]: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

# 方法 3
In [33]: d = {'a': 1, 'b': 2}
    ...: d.update([('c',3),('d',4)],e=5) # 实现与方法 1 一样效果

In [34]: d
Out[34]: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

2. setdefault

如果仅当字典中不存在某个键值对时，才插入到字典中；如果存在，不必插入（也就不会修改键值对）。

这种场景，使用字典自带方法 setdefault：

In [35]: d = {'a':1,'b':2}

In [36]: r = d.setdefault('c',3) # r: 3

In [37]: r
Out[37]: 3

In [38]: d
Out[38]: {'a': 1, 'b': 2, 'c': 3}


In [39]: r = d.setdefault('c',33) # r:3，已经存在 'c':3 的键值对，所以 setdefault 时 d 无改变

In [40]: r
Out[40]: 3

In [41]: d
Out[41]: {'a': 1, 'b': 2, 'c': 3}

3. 字典并集

先来看这个函数 f，为了好理解，显示的给出参数类型、返回值类型，这不是必须的。

In [45]: def f(d:dict)->dict:
    ...:     return {**d}
    ...:

In [46]: f({'a':1,'b':2})
Out[46]: {'a': 1, 'b': 2}

{**d1, **d2} 实现合并 d1 和 d2，返回一个新字典：

In [47]: def merge(d1,d2):
    ...:     return {**d1,**d2}

In [48]: merge({'a':1,'b':2},{'c':3}) 
Out[48]: {'a': 1, 'b': 2, 'c': 3}

4. 字典差

In [51]: def difference(d1,d2):
    ...:     return dict([(k,v) for k,v in d1.items() if k not in d2])

In [53]: difference({'a':1,'b':2,'c':3},{'b':2}) 
Out[53]: {'a': 1, 'c': 3}

5. 按键排序

In [54]: def sort_by_key(d):
    ...:     return sorted(d.items(),key=lambda x: x[0])
    ...:

In [55]: sort_by_key({'a':3,'b':1,'c':2})
Out[55]: [('a', 3), ('b', 1), ('c', 2)]

sorted 函数返回列表，元素为 tuple：

6. 按值排序

与按照键排序原理相同，按照值排序时，key 函数定义为按值（x[1]）比较。

为照顾小白，解释为什么是 x[1]。

d.items() 返回元素为 (key, value) 的可迭代类型（Iterable），key 函数的参数 x 便是元素 (key, value)，所以 x[1] 取到字典的值。

In [59]: def sort_by_value(d):
    ...:     return sorted(d.items(),key=lambda x: x[1])
    ...:

In [60]: sort_by_value({'a':3,'b':1,'c':2})
Out[60]: [('b', 1), ('c', 2), ('a', 3)]