c++中判断某个值在字典的value中_Python核心知识系列：字典

1 定义

字典是一种映射对象类型，由键值对构成的一个可变容器。字典中的每个键值对内用冒号 ( : ) 分隔，键值对间用逗号 ( , ) 分隔，所有键值对包括在{}中。字典的键必须是唯一的，只有可散列的数据类型才能用作这些映射里的键，而值则不必是唯一的。

可散列数据类型：一个对象是可散列的，那么在它的生命周期中它的hash值是不变的。Python所有内置的不可变的对象都是可散列的（hashable），如数字、字符串等；可变的容器（比如list或dict）不是hashable；对于元组，只有它包含的所有元素都是可散列类型的情况下，它才是可散列的。

 # 判断对象是不是可散列数据类型t = (1, 2, 3)hash(t)   # 有hash值t = (1, 2, [1, 2])hash(t)   # TypeError: unhashable type: 'list'

创建字典的方法：

• 根据定义创建：使用一对中括号 {}，键值对中间用冒号，每项间使用逗号分隔。

 d = {}  # 空字典d = {'a':1, 'b':2, 'c':3}

• 使用dict()构造函数

 # 键值对d1 = dict({'name':'Tom', 'age':'18', 'gender':'male'})# 关键字参数d2 = dict('name'='Tom', 'age'='18', 'gender'='male')# 元素为元组或列表的元组、元素为元组或列表的列表d3 = dict([(name', 'Tom'), ('age', '18'), ('gender', 'male')])# zip(seq1, seq2)seq1 = ['name', 'age', 'gender']seq2 = ['Tom', '18', 'male']d4 = dict(zip(seq1, seq2))

• fromkeys() 方法

 """用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。语法：dict.fromkeys(seq, value)参数：seq为字典键值列表，value为键序列对应的值，默认为None。返回值：返回一个新的字典。"""seq = ['a', 'b', 'c']value = [1, 2]d1 = dict.fromkeys(seq, value)d2 = {}.fromkeys(seq, value)d3 = {'A':1, 'B':2}.fromkeys(seq, value)print(d1)  # {'a': [1, 2], 'b': [1, 2], 'c': [1, 2]}print(d2)  # {'a': [1, 2], 'b': [1, 2], 'c': [1, 2]}print(d3)  # {'a': [1, 2], 'b': [1, 2], 'c': [1, 2]}

• 字典推导构建新字典

字典推导可以从任何以键值对作为元素的可迭代对象中构建出字典。

 # 利用元组列表生成字典lt = [('a', 1), ('b', 2), ('c', 3)]d = {key: value for key, value in lt}  # {'a': 1, 'b': 2, 'c': 3}# 利用一个字典生成另一个字典d1 = {key.upper(): value for key, value in d.items()}  # {'A': 1, 'B': 2, 'C': 3}

2 基本操作

2.1 访问字典

• 根据字典的键来访问字典，如果不存在，则会抛出异常。

 d = {'name':'Tom', 'age':'18', 'gender':'male'}d['name']  # Tomd['nationality']  # 报异常  KeyError: 'nationality'

• 使用get()函数访问字典，如果键不存在，返回默认值，而不会报错。

 """语法：dict.get(key, default=None)参数：key为要查找的键，default为键不存在时返回的默认值。返回：返回指定键的值，若不存在，则返回默认值default，default默认为None。"""d = {'name':'Tom', 'age':'18', 'gender':'male'}d.get('nationality', 'Chinese')  # Chinese

2.2 修改字典

2.2.1 更新字典元素

 # 更新指定键对应的值d = {'name':'Tom', 'age':'18', 'gender':'male'}d['name'] = 'Henry'print(d)Out:{'name': 'Henry', 'age': '18', 'gender': 'male'}

2.2.2 添加字典元素

 d = {'name':'Tom', 'age':'18', 'gender':'male'}d['nationality'] = 'Chinese'  # 添加元素print(d)Out:{'name': 'Tom', 'age': '18', 'gender': 'male', 'nationality': 'Chinese'}

2.2.3 setdefault()添加元素

与get()方法类似，如果key在字典中，返回对应的值，不修改已存在的键对应值。如果key不在字典中，则插入key及设置的默认值default，并返回 default，default默认值为None。

 """语法：dict.setdefault(key, default=None)参数：key为要添加的键，default为key在字典dict中不存在时插入的值，默认为None。返回值：如果key在字典中，则返回对应的值，若不存在则插入键值对，并返回插入的值。"""d = {'name':'Tom', 'age':'18', 'gender':'male'}r = d.setdefault('name', 'Henry')   # r = Tom，字典不变r = d.setdefault('nationality', 'Chinese')  print(r)print(d)Out:Chinese{'name': 'Tom', 'age': '18', 'gender': 'male', 'nationality': 'Chinese'}

2.2.4 update()添加或更新元素

update()用于更新字典中的键值对，可以修改存在的键对应的值，也可以添加新的键值对到字典中。

 """语法：dict.update(data)参数：data为要更新或添加的键值对数据，可以是字典、关键字参数、元组列表等。返回值：无"""# 更新存在键对应的值，传入字典d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}d.update({'name': 'Henry'})print(d)Out: # 打印d的结果{'name': 'Henry', 'age': '18', 'sex': 'Male'}# 添加键值对，传入关键字参数 d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}d.update(stature='188', nationality='Chinese')print(d)Out:{'name': 'Tom', 'age': '18', 'sex': 'Male', 'stature': '188', 'nationality': 'Chinese'}# 传入元组列表d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}d.update([('stature', '188'), ('nationality', 'Chinese')])print(d)Out:{'name': 'Tom', 'age': '18', 'sex': 'Male', 'stature': '188', 'nationality': 'Chinese'}

2.3 删除字典

• 删除单个字典元素

 # del 删除指定键的元素d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}del d['sex']print(d)Out:{'name': 'Tom', 'age': '18'}# dict.pop(key, default) 删除啊指定键key对应的值，并返回被删除的值。若key不存在，default要给出，否则报错。d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}d.pop('sex')print(d)Out:{'name': 'Tom', 'age': '18'}

• 清空字典所有元素

 d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}d.clear()print(d)Out:{}

• 删除整个字典

 d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}del d

2.4 字典视图

字典自带的三个方法 dict.items()、dict.keys()、dict.values()，它们返回的对象都是原字典的视图，修改原字典对象，视图对象的值也会发生改变。

2.4.1 dict.items()

 """语法：dict.items()参数：无返回值：返回可遍历的元组数组，元组由键值对构成。"""d = {'a': 1, 'b': 2, 'c': 3}r = d.items()print(r)print(list(r))Out:dict_items([('a', 1), ('b', 2), ('c', 3)])[('a', 1), ('b', 2), ('c', 3)]

2.4.2 dict.keys()

 """语法： dict.keys()参数：无返回值：返回一个由字典键构成的迭代器，使用list()可转换为列表。"""d = {'a': 1, 'b': 2, 'c': 3}print(d.keys())Out:dict_keys(['a', 'b', 'c'])# 获取所有键集合set(d)set(d.keys())

2.4.3 dict.values()

 """语法： dict.values()参数：无返回值：返回一个由字典值构成的迭代器，使用list()可转换为列表。"""d = {'a': 1, 'b': 2, 'c': 3}print(d.values())Out:dict_values([1, 2, 3])

2.5 字典遍历

字典遍历常与 dict.items()、dict.keys()、dict.values()等三个方法配合使用。

 # items()d = {'a': 1, 'b': 2, 'c': 3}for key, value in d.items():print(f'key = {key}, value = {value}')Out:key = a, value = 1key = b, value = 2key = c, value = 3# 字典推导d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}d_new = {k: v for k, v in d.items() if v%2 == 0}print(d_new)Out:{'b': 2, 'd': 4}

2.6 字典排序

 # 根据字典键排序d = {'b': 2, 'a': 1, 'c': 3}d_new = dict(sorted(d.items(), key=lambda x: x[0], reverse=True))print(d_new)Out:{'c': 3, 'b': 2, 'a': 1}# 根据字典值排序d = {'b': 2, 'a': 1, 'c': 3}d_new = dict(sorted(d.items(), key=lambda x: x[1]))print(d_new)Out:{'a': 1, 'b': 2, 'c': 3}

2.7 统计元素个数

 d = {'b': 2, 'a': 1, 'c': 3}print(len(d))Out:3

3 进阶知识

3.1 collections模块中字典类型

3.1.1 collections.defaultdict

通过字典key访问字典元素时，如果key不存在，则会引发‘KeyError‘异常。为了避免这种情况，前面介绍的get()和setdefault()方法是通过指定默认值。除此之外，我们也可以使用 collections模块中的defaultdict类（dict的子类）来处理找不到的键的情况。使用defaultdict()可以用于以下两种场合：

1. 在key不存在时，不报异常，而是返回一个默认值。
2. 在key不存在时，也可以赋值，而不报异常。

collections.defaultdict(default_factory,...): defaultdict是内置的dict类的一个子类，返回一个新的类字典的对象，第一个参数提供了default_factory属性的初始值，默认为None。default_factory可以设置为：

1. 使用类型名称来作为初始化函数的参数，当所访问的键不存在的时候，根据传入类型实例化一个初始值作为默认值。
2. 使用不带参数的可调用函数作为初始化函数参数，以该函数返回值作为默认值。

下面，通过一个统计列表中单词次数的示例来看如何处理键不存在的情况。

• KeyError异常

 """在Python中如果访问字典里不存在的键，会出现KeyError异常。"""# 统计列表中单词出现次数，并记录在字典count中fruits = ['apple', 'orange', 'cherry', 'apple', 'apple', 'cherry', 'blueberry']fruit_count = {}for fruit in fruits:fruit_count[fruit] += 1  # KeyError: 'apple'

• 使用判断语句检查

 fruits = ['apple', 'orange', 'cherry', 'apple', 'apple', 'cherry', 'blueberry']fruit_count = {}for fruit in fruits:if fruit not in fruit_count:fruit_count[fruit] = 1else:fruit_count[fruit] += 1print(fruit_count)Out:{'apple': 3, 'orange': 1, 'cherry': 2, 'blueberry': 1}

• 使用dict.setdefault()方法

 fruits = ['apple', 'orange', 'cherry', 'apple', 'apple', 'cherry', 'blueberry']fruit_count = {}for fruit in fruits:fruit_count.setdefault(fruit, 0)fruit_count[fruit] += 1print(fruit_count)Out:{'apple': 3, 'orange': 1, 'cherry': 2, 'blueberry': 1}

• 使用collections.defaultdict类

 # 指定字典的值类型为int，用于计数from collections import defaultdictfruits = ['apple', 'orange', 'cherry', 'apple', 'apple', 'cherry', 'blueberry']fruit_count = defaultdict(int)for fruit in fruits:fruit_count[fruit] += 1print(fruit_count)Out:defaultdict(, {'apple': 3, 'orange': 1, 'cherry': 2, 'blueberry': 1})# 指定字典的值类型为listseq = [('A', 1), ('B', 2), ('A', 3), ('B', 4), ('C', 1)]d = defaultdict(list)print(d['D'])  Out:[]for k, v in seq:d[k].append(v)print(d)Out:defaultdict(, {'A': [1, 3], 'B': [2, 4], 'C': [1]})# 使用不带参数的可调用函数from collections import defaultdictdef zero():return 0d = defaultdict(zero)print(d['A'])print(d)Out:0defaultdict(, {'A': 0})# 计数from collections import defaultdictfruits = ['apple', 'orange', 'cherry', 'apple', 'apple', 'cherry', 'blueberry']fruit_count = defaultdict(lambda: 0)   # 使用lambda来定义简单的函数for fruit in fruits:fruit_count[fruit] += 1print(dict(fruit_count))Out:{'apple': 3, 'orange': 1, 'cherry': 2, 'blueberry': 1}

3.1.2 collections.OrderedDict

使用dict时，key是无序的。在对dict做迭代时，我们无法确定key的顺序。如果要保持Key的顺序，可以用OrderedDict。

 from collections import OrderedDictod = OrderedDict([('A', 1), ('B', 2), ('C', 3)])od['D'] = 4od['E'] = 5od['F'] = 6print(od)Out:OrderedDict([('A', 1), ('B', 2), ('C', 3), ('D', 4), ('E', 5), ('F', 6)])# 按键排序，创建排序字典d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}od = OrderedDict(sorted(d.items(), key=lambda t: t[0])) print(od)Out:OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])# 按值排序，创建排序字典d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}od = OrderedDict(sorted(d.items(), key=lambda t: t[1])) print(od)Out:OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])# 按键的字符长度排序，创建排序字典d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}od = OrderedDict(sorted(d.items(), key=lambda t: len(t[0]))) print(od)Out:OrderedDict([('pear', 1), ('apple', 4), ('banana', 3), ('orange', 2)])

3.1.3 collections.ChainMap

ChainMap 用来成合并多个字典，但和 update 不同，它不会改变原对象，而且效率更高。

 from collections import ChainMapa = {'a': 1, 'b': 2}b = {'b': 3, 'c': 4}c = ChainMap(a, b)print(c)Out:ChainMap({'a': 1, 'b': 2}, {'b': 3, 'c': 4})# ChainMap读取和更新：ChainMap内部存储了一个名为maps的list用以维护mapping关系, 这个list可以直接查看和修改，修改之后相应ChainMap值也就修改了。print(c.maps)Out:[{'a': 1, 'b': 2}, {'b': 3, 'c': 4}]c.maps[0]['b'] = 5c.maps[1]['b'] = 6print(c)Out:ChainMap({'a': 1, 'b': 5}, {'b': 6, 'c': 4})# 如果不是修改maps这个list，对ChainMap的修改只会影响第一个map，读取的时候会从第一个map开始读，直到遇到指定的key。print(c['b'])Out:5# new_child(m=None): 生成一个新的ChainMap, m指定mappings作为第一个mapping，后面跟着原先的mappings。print(c.new_child())print(c.new_child({'d': 10}))Out:ChainMap({}, {'a': 1, 'b': 5}, {'b': 6, 'c': 4})ChainMap({'d': 10}, {'a': 1, 'b': 5}, {'b': 6, 'c': 4})# 返回父ChainMap，由除了第一个map之后的其它mappings组成d = c.new_child({'d': 10})print(d.parents)Out:ChainMap({'a': 1, 'b': 5}, {'b': 6, 'c': 4})

3.1.4 collections.Counter

Counter是dict的一个子类，用于可哈希对象的计数。它是一个无序键值对的集合，其中以元素为键，值为元素的计数值。

 from collections import Counter# 创建Counter对象c = Counter()  # 创建一个空counter对象c = Counter(['apple', 'orange', 'apple', 'pear', 'orange'])  # 从一个可迭代对象（list、tuple、dict、字符串等）创建c = Counter({'A': 1, 'B': 2}) # 从一个映射对象（字典对象）创建c = Counter(cats=4, dogs=8)   # 根据关键字参数创建# Counter对象有字典接口，当不存在指定键时，返回的计数为0c = Counter({'A': 1, 'B': 2})c['C']Out:0# 统计列表中单词出现次数cnt = Counter()seq = ['red', 'blue', 'red', 'green', 'blue', 'blue']for color in seq:cnt[color] += 1print(cnt)Out:Counter({'blue': 3, 'red': 2, 'green': 1})# 将counter中元素置0或删除元素seq = ['red', 'blue', 'red', 'green', 'blue', 'blue']cnt = Counter(seq)cnt['green'] = 0print(cnt)del cnt['green']print(cnt)Out:Counter({'blue': 3, 'red': 2, 'green': 0})Counter({'blue': 3, 'red': 2})# 按照元素出现次数返回一个迭代器，如果元素计数小于1，则忽略。c = Counter(a=4, b=2, c=0, d=-2)print(c.elements())print(sorted(c.elements()))Out:['a', 'a', 'a', 'a', 'b', 'b']# 使用most_common(n)返回一个list, list中包含Counter对象中出现最多前n个元素。c = Counter('abracadabra')print(c.most_common(3))Out:[('a', 5), ('b', 2), ('r', 2)]# subtractc1 = Counter(a=2, b=3)c2 = Counter(a=1, b=4)c1.subtract(c2)print(c1)Out:Counter({'a': 1, 'b': -1})

3.2 字典并集

 def merge(d1, d2):return {**d1, **d2}d1 = {'a':1, 'b':2}d2 = {'c':3, 'd':4}r = merge(d1, d2)print(r)Out:{'a': 1, 'b': 2, 'c': 3, 'd': 4}

3.3 字典差集

 def diff(d1, d2):return dict([(k, v) for k, v in d1.items() if k not in d2])d1 = {'a':1, 'b':2, 'c':3}d2 = {'c':3, 'd':4}r = diff(d1, d2) # r = {'a': 1, 'b': 2}

3.4 获取字典前n个最大值对应的键

 from heapq import nlargestdef topn_dict(d, n):return nlargest(n, d, key=lambda k: d[k])# 调用函数d = {'a':5, 'b':6, 'c':8, 'd':4}r =  topn_dict(d, 2) # r = ['c', 'b']

3.5 一键对多值字典

 lst = [('a', 1), ('b', 2), ('a', 3), ('b', 4), ('c', 5)]d = {}for k, v in lst:if k not in d:d[k] = []d[k].append(v)print(d)Out:{'a': [1, 3], 'b': [2, 4], 'c': [5]}# 使用 collections模块中的defaultdictfrom collections import defaultdictd = defaultdict(list)for k, v in lst:d[k].append(v)print(d)Out:defaultdict(, {'a': [1, 3], 'b': [2, 4], 'c': [5]})

3.6 在字典中根据条件筛选数据

 # 生成数据from random import randintd = {"student%d" % i : randint(70, 100) for i in range(1,6)}print(d)# 使用字典解析res= {k:v for k, v in d.items() if v >= 90}print(res)# 使用filter()函数res = dict(filter(lambda item: item[1] >= 90, d.items()))print(res)Out:{'student1': 75, 'student2': 85, 'student3': 91, 'student4': 84, 'student5': 98}{'student3': 91, 'student5': 98}{'student3': 91, 'student5': 98}

--END--

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！