d = {'Bob': 1, 'Mary': 2, 'Lisa': 4, 'Ken': 5} print(key_in_dict(d, 'Hello')) print(key_in_dict(d, 'Lisa'))

False

2、获取字典中所有值组成的列表

这里需要使用 dict.values() 获取字典中的所有值，然后通过 list() 转换为列表。

def values_only(d): return list(d.values()) d = {'Bob': 1, 'Mary': 2, 'Lisa': 4, 'Ken': 5} print(values_only(d))

[1, 4, 2, 5]

3、获取字典中所有键组成的列表

这里需要使用 dict.keys() 获取字典中的所有键，然后通过 list() 转换为列表。

def keys_only(d):
    return list(d.keys())
d = {'Bob': 1, 'Mary': 2, 'Lisa': 4, 'Ken': 5}
print(keys_only(d))
['Lisa', 'Mary', 'Ken', 'Bob']
4、将字典所有键值对转换为元组列表
这里需要使用 dict.items() 获取字典中的所有键值对，然后通过 list() 转换为元祖列表。
def dict_to_list(d):
    return list(d.items())
d = {'Bob': 1, 'Mary': 2, 'Lisa': 4, 'Ken': 5}
print(dict_to_list(d))
[('Ken', 5), ('Lisa', 4), ('Bob', 1), ('Mary', 2)]
5、将字典中的键值进行互换
这里仍然需要借助 dict.items() 分别获取字典的键和值，互换位置，来创建一个新字典。
def invert_dictionary(d):
    return { value: key for key, value in d.items() }
d = {'Bob': 1, 'Mary': 2, 'Lisa': 4, 'Ken': 5}
print(invert_dictionary(d))
{1: 'Bob', 2: 'Mary', 4: 'Lisa', 5: 'Ken'}
6、使用 dict.get(key)，而不是 dict[key]
通过键获取对应的值，dict[key] 是最常用的方法，但是如果 key 不存在，则会引发 KeyError 错误。
那么你可以使用 dict.get(key) 来规避这个问题，dict.get() 可以接受第二个参数，表示该键对应的默认值，当 key 不存在时，就返回该默认值。
d = {'Bob': 1, 'Mary': 2, 'Lisa': 4, 'Ken': 5}
print(d.get('Mary'))
print(d.get('mary', 2))
print(d['mary'])  # KeyError
7、将字典列表转换为指定键对应的值列表
如果你有多个字典，且字典的键都相同，则可以根据指定键，获取每个字典该键的值组成的列表。
需要使用到 dict.get() 来得到键对应的值。
def get_values_by_key(dicts, key):
  return [x.get(key) for x in dicts]
students = [
  { 'name': 'Bob',  'id': 10 },
  { 'name': 'Mary', 'id': 20 },
  { 'name': 'Lisa', 'id': 30 },
  { 'name': 'Ken',  'id': 40 }
print(get_values_by_key(students, 'name'))
print(get_values_by_key(students, 'id'))
['Bob', 'Mary', 'Lisa', 'Ken']

[10, 20, 30, 40]
8、查找字典中最小值对应的键
使用 min() 函数，同时设置参数 key 为 dict.get()。同理，要获取最大值，则使用 max()。
def key_of_min(d):
    return min(d, key = d.get)
d = {'Bob': 1, 'Mary': 2, 'Lisa': 4, 'Ken': 5}
print(key_of_min(d))
9、合并多个字典
创建一个新字典，并使用 dict.update() 将传入的每个字典添加到新字典中。
def merge_dicts(*dicts):
    res = dict()
    for d in dicts:
        res.update(d)
    return res
stud1 = {'Bob': 1, 'Mary': 2}
stud2 = {'Lisa': 4, 'Ken': 5}
stud3 = {'Vivi': 7}
print(merge_dicts(stud1, stud2, stud3))

{'Lisa': 4, 'Vivi': 7, 'Mary': 2, 'Ken': 5, 'Bob': 1}
10、根据值查找对应的键
使用 dict.items() 和 next() 找到字典中具有给定值的第一个键。
如果想找到字典中具有给定值的所有键，则将 next() 更改为 list()。
def find_key(d, val):
    return next(key for key, value in d.items() if value == val)
d = {'Bob': 1, 'Mary': 2, 'Lisa': 4, 'Ken': 5, 'Vivi': 2}
print(find_key(d, 2))
11、将两个列表组合为一个字典
这里有两个列表，第一个列表存放键，第二个列表存放值，要将这两个列表转换为一个字典。
def lists_to_dict(keys, values):
    return dict(zip(keys, values))
names = ['Bob', 'Mary', 'Lisa', 'Ken']
ids = [1, 2, 4, 5]
print(lists_to_dict(names, ids))

{'Ken': 5, 'Lisa': 4, 'Bob': 1, 'Mary': 2}
12、根据给定的函数对列表中的元素进行分组
对列表中的每个元素执行相同的操作，并根据结果对元素进行分组。
需要使用 collections.defaultdict 初始化一个特殊字典，其中的值都是列表。
下面例子是根据每个名字的长度进行分组。
from collections import defaultdict
def group_by(items, fn):
    d = defaultdict(list)
    for el in items:
        d[fn(el)].append(el)
    return dict(d)
print(group_by(['Bob', 'Mary', 'Lisa'], len))
{3: ['Bob'], 4: ['Mary', 'Lisa']}