目录

一、字典

1、字典的定义

2、字典的语法

3、获取字典的属性和方法

4、获取字典的帮助信息

5、字典的用法

5-1、创建字典

5-1-1、创建一个空字典

5-1-2、创建一个包含键值对的字典

5-1-3、创建一个嵌套字典

5-2、新增字典的键值对

5-3、删除字典中的键值对

5-4、修改字典中的值

5-5、访问字典中的值

5-6、遍历字典的键

5-7、遍历字典的键值对

5-8、检查键是否存在

5-9、字典的用法

5-9-1、clear()方法

5-9-2、copy()方法

5-9-3、fromkeys()方法

5-9-4、get()方法

5-9-5、items()方法

5-9-6、keys()方法

5-9-7、pop()方法

5-9-8、popitem()方法

5-9-9、setdefault()方法

5-9-10、update()方法

5-9-11、values()方法

二、推荐阅读

1、Python-VBA函数之旅-dict()函数

2、Python算法之旅

3、Python函数之旅

4、个人主页-神奇夜光杯-CSDN

一、字典

1、字典的定义

        在Python中，字典(Dictionary)是一种非常灵活且常用的数据结构，它是一个无序的键值对(key-value pair)集合。

2、字典的语法

        字典的每一个键值对都用冒号(:)分隔，键值对之间用逗号(,)分隔，整个字典包括在花括号({})中。

3、获取字典的属性和方法

        用dir()函数获取dict所有属性和方法的列表

print(dir(dict))# ['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', # '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', # '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', # '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', # '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', # 'pop', 'popitem', 'setdefault', 'update', 'values']

4、获取字典的帮助信息

        用help()函数获取dict的帮助信息

Help on class dict in module builtins:class dict(object) | dict() -> new empty dictionary | dict(mapping) -> new dictionary initialized from a mapping object's | (key, value) pairs | dict(iterable) -> new dictionary initialized as if via: | d = {} | for k, v in iterable: | d[k] = v | dict(**kwargs) -> new dictionary initialized with the name=value pairs | in the keyword argument list. For example: dict(one=1, two=2) | | Methods defined here: | | __contains__(self, key, /) | True if the dictionary has the specified key, else False. | | __delitem__(self, key, /) | Delete self[key]. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __gt__(self, value, /) | Return self>value. | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | __ior__(self, value, /) | Return self|=value. | | __iter__(self, /) | Implement iter(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __or__(self, value, /) | Return self|value. | | __repr__(self, /) | Return repr(self). | | __reversed__(self, /) | Return a reverse iterator over the dict keys. | | __ror__(self, value, /) | Return value|self. | | __setitem__(self, key, value, /) | Set self[key] to value. | | __sizeof__(...) | D.__sizeof__() -> size of D in memory, in bytes | | clear(...) | D.clear() -> None. Remove all items from D. | | copy(...) | D.copy() -> a shallow copy of D | | get(self, key, default=None, /) | Return the value for key if key is in the dictionary, else default. | | items(...) | D.items() -> a set-like object providing a view on D's items | | keys(...) | D.keys() -> a set-like object providing a view on D's keys | | pop(...) | D.pop(k[,d]) -> v, remove specified key and return the corresponding value. | | If the key is not found, return the default if given; otherwise, | raise a KeyError. | | popitem(self, /) | Remove and return a (key, value) pair as a 2-tuple. | | Pairs are returned in LIFO (last-in, first-out) order. | Raises KeyError if the dict is empty. | | setdefault(self, key, default=None, /) | Insert key with a value of default if key is not in the dictionary. | | Return the value for key if key is in the dictionary, else default. | | update(...) | D.update([E, ]**F) -> None. Update D from dict/iterable E and F. | If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] | If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v | In either case, this is followed by: for k in F: D[k] = F[k] | | values(...) | D.values() -> an object providing a view on D's values | | ---------------------------------------------------------------------- | Class methods defined here: | | __class_getitem__(...) from builtins.type | See PEP 585 | | fromkeys(iterable, value=None, /) from builtins.type | Create a new dictionary with keys from iterable and values set to value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __hash__ = None

5、字典的用法

5-1、创建字典

5-1-1、创建一个空字典

# 创建一个空字典my_dict = {}print(my_dict) # 输出：{}

5-1-2、创建一个包含键值对的字典

# 创建一个包含键值对的字典my_dict = {"name":"Myelsa", "age":18, "city":"Guangzhou"}print(my_dict) # 输出：{'name': 'Myelsa', 'age': 18, 'city': 'Guangzhou'}

5-1-3、创建一个嵌套字典

# 创建一个元组/字符串嵌套做键的嵌套字典my_dict = { (1, 2, 3): "value1", # 这是一个包含整数的元组作为键 ("key1", "key2"): "value2", # 这是一个包含字符串的元组作为键 # ([1, 2], "key"): "value", # 这是错误的，因为列表是可变的 # ({"nested_key": "nested_value"}, "key"): "value", # 这是错误的，因为字典是可变的}print(my_dict) # 输出：{(1, 2, 3): 'value1', ('key1', 'key2'): 'value2'}# 创建一个值嵌套字典my_dict = { "key1": "value1", "key2": "value2", "key3": 3, "key4": [1, 2, 3], # 字典的值可以是任何数据类型，包括列表、元组、字典等 "key5": {"nested_key": "nested_value"} # 字典的值也可以是另一个字典(嵌套字典)}print(my_dict) # 输出：{'key1': 'value1', 'key2': 'value2', 'key3': 3, 'key4': [1, 2, 3], 'key5': {'nested_key': 'nested_value'}}

5-2、新增字典的键值对

# 新增字典的键值对my_dict = { "key1": "value1", "key2": "value2", "key3": 3, "key4": [1, 2, 3], # 字典的值可以是任何数据类型，包括列表、元组、字典等 "key5": {"nested_key": "nested_value"} # 字典的值也可以是另一个字典(嵌套字典)}my_dict["key6"] = "value6"print(my_dict) # 输出：{'key1': 'value1', 'key2': 'value2', 'key3': 3, 'key4': [1, 2, 3], 'key5': {'nested_key': 'nested_value'}, 'key6': 'value6'}

5-3、删除字典中的键值对

# 删除字典中的键值对my_dict = { "key1": "value1", "key2": "value2", "key3": 3, "key4": [1, 2, 3], # 字典的值可以是任何数据类型，包括列表、元组、字典等 "key5": {"nested_key": "nested_value"} # 字典的值也可以是另一个字典(嵌套字典)}del my_dict["key2"]print(my_dict) # 输出：{'key1': 'value1', 'key3': 3, 'key4': [1, 2, 3], 'key5': {'nested_key': 'nested_value'}}

5-4、修改字典中的值

# 修改字典中的值my_dict = { "key1": "value1", "key2": "value2", "key3": 3, "key4": [1, 2, 3], # 字典的值可以是任何数据类型，包括列表、元组、字典等 "key5": {"nested_key": "nested_value"} # 字典的值也可以是另一个字典(嵌套字典)}my_dict["key1"] = "new_value1"print(my_dict) # 输出：{'key1': 'new_value1', 'key2': 'value2', 'key3': 3, 'key4': [1, 2, 3], 'key5': {'nested_key': 'nested_value'}}

5-5、访问字典中的值

# 访问字典中的值my_dict = { "key1": "value1", "key2": "value2", "key3": 3, "key4": [1, 2, 3], # 字典的值可以是任何数据类型，包括列表、元组、字典等 "key5": {"nested_key": "nested_value"} # 字典的值也可以是另一个字典(嵌套字典)}print(my_dict["key1"]) # 输出: value1

5-6、遍历字典的键

# 遍历字典的键my_dict = { "key1": "value1", "key2": "value2", "key3": 3, "key4": [1, 2, 3], # 字典的值可以是任何数据类型，包括列表、元组、字典等 "key5": {"nested_key": "nested_value"} # 字典的值也可以是另一个字典(嵌套字典)}for key in my_dict: print(key)# key1# key2# key3# key4# key5

5-7、遍历字典的键值对

# 遍历字典的键值对my_dict = { "key1": "value1", "key2": "value2", "key3": 3, "key4": [1, 2, 3], # 字典的值可以是任何数据类型，包括列表、元组、字典等 "key5": {"nested_key": "nested_value"} # 字典的值也可以是另一个字典(嵌套字典)}for key, value in my_dict.items(): print(key, value)# key1 value1# key2 value2# key3 3# key4 [1, 2, 3]# key5 {'nested_key': 'nested_value'}

5-8、检查键是否存在

# 检查键是否存在my_dict = { "key1": "value1", "key2": "value2", "key3": 3, "key4": [1, 2, 3], # 字典的值可以是任何数据类型，包括列表、元组、字典等 "key5": {"nested_key": "nested_value"} # 字典的值也可以是另一个字典(嵌套字典)}if "key3" in my_dict: print("key3 exists in the dictionary.") # 输出：key3 exists in the dictionary.

5-9、字典的用法

5-9-1、clear()方法

# 1、方法：dict.clear# 2、语法：dict.clear()# 3、参数：无# 4、功能：用于移除字典中的所有键值对，使其变为一个空字典# 5、返回值：一个空字典# 6、说明：# 6-1、clear()方法会直接修改原始字典，而不是返回一个新的字典# 6-2、如果你需要保留原始字典不变并得到一个清空后的新字典，你应该先复制原始字典，再对新字典调用clear()方法# 7、示例：# 创建一个字典my_dict = {"name":"Myelsa", "age":18, "city":"Guangzhou"}# 打印原始字典print("原始字典:", my_dict) # 输出：原始字典: {'name': 'Myelsa', 'age': 18, 'city': 'Guangzhou'}# 调用clear()方法清空字典my_dict.clear()# 打印清空后的字典print("清空后的字典:", my_dict) # 输出：清空后的字典: {}

5-9-2、copy()方法

# 1、方法：dict.copy# 2、语法：dict.copy()# 3、参数：无# 4、功能：用于创建字典的一个浅拷贝(shallow copy)# 5、返回值：浅拷贝会创建一个新的字典对象，并复制原字典中所有的键值对# 6、说明：# 6-1、如果原字典中的值是可变的(如列表、字典等)，则新字典中对应的值将是原值的引用，而不是副本，# 这意味着如果你修改了新字典中这些可变类型的值，原字典中的值也会受到影响# 7、示例：# 创建一个字典original_dict = {"name":"Myelsa", "age":[18, 15], "city":"Guangzhou"}# 使用copy()方法创建浅拷贝copied_dict = original_dict.copy()# 修改浅拷贝中的值(对于不可变类型)copied_dict['name'] = "Jimmy"# 修改浅拷贝中的列表(对于可变类型)copied_dict['age'].append(6)# 打印原字典和浅拷贝后的字典print("原字典:", original_dict) # 输出：原字典: {'name': 'Myelsa', 'age': [18, 15, 6], 'city': 'Guangzhou'}print("浅拷贝后的字典:", copied_dict) # 输出：浅拷贝后的字典: {'name': 'Jimmy', 'age': [18, 15, 6], 'city': 'Guangzhou'} 其中age为可变的列表，因此，会影响到原字典# 创建深拷贝(如果需要)# 如果你需要创建一个真正的“深拷贝”(即，拷贝所有的层次)，你可以使用copy模块中的deepcopy()函数import copy# 创建一个字典original_dict = {"name":"Myelsa", "age":[18, 15], "city":"Guangzhou"}# 使用deepcopy()方法创建深拷贝deep_copied_dict = copy.deepcopy(original_dict)# 修改深拷贝中的列表deep_copied_dict['age'].append(6)# 打印原字典和深拷贝后的字典print("原字典:", original_dict) # 输出：原字典: {'name': 'Myelsa', 'age': [18, 15], 'city': 'Guangzhou'} 原字典中的列表并未被修改，因为deepcopy()创建了原字典中所有层次的完全独立的副本print("深拷贝后的字典:", deep_copied_dict) # 输出：深拷贝后的字典: {'name': 'Myelsa', 'age': [18, 15, 6], 'city': 'Guangzhou'}

5-9-3、fromkeys()方法

# 1、方法：dict.fromkeys# 2、语法：dict.fromkeys(iterable, value=None, /)# 3、参数：# 3-1、iterable(必须)：一个可迭代对象，如列表、元组、集合等，其中的元素将作为新字典的键# 3-2、value(可选)：一个值，将作为新字典中所有键对应的初始值，默认为None# 4、功能：用于创建一个新字典，以给定的可迭代对象(如列表、元组等)中的元素作为键，并可以选择性地指定一个默认值作为所有键对应的初始值# 5、返回值：一个新字典# 6、说明：# 6-1、如果在创建新字典后修改了iterable对象(例如列表或元组)，这不会影响已经创建的新字典，因为iterable只是被用来提供键的初始集合# 6-2、fromkeys()方法返回的是一个新的字典对象，原字典(如果有的话)不会被修改# 6-3、如果iterable中包含的元素是不可哈希的(例如列表或字典本身)，则无法使用fromkeys()方法创建字典，因为字典的键必须是可哈希的# 7、示例：# 7-1、基本用法# 创建一个以列表元素为键，值为None的新字典keys = ['a', 'b', 'c']new_dict = dict.fromkeys(keys)print(new_dict) # 输出：{'a': None, 'b': None, 'c': None}# 创建一个以列表元素为键，值为'default'的新字典keys = ['a', 'b', 'c']new_dict = dict.fromkeys(keys, 'default')print(new_dict) # 输出：{'a': 'default', 'b': 'default', 'c': 'default'}# 7-2、使用集合作为键的源# 创建一个以集合元素为键，值为'value'的新字典keys = {'a', 'b', 'c'}new_dict = dict.fromkeys(keys, 'value')print(new_dict) # 输出可能是 {'a': 'value', 'b': 'value', 'c': 'value'} # 注意集合是无序的，所以输出的顺序可能不同# 7-3、使用元组作为键的源# 创建一个以元组元素为键，值为'x'的新字典keys = ('a', 'b', 'c')new_dict = dict.fromkeys(keys, 'x')print(new_dict) # 输出：{'a': 'x', 'b': 'x', 'c': 'x'}

5-9-4、get()方法

# 1、方法：dict.get# 2、语法：dict.get(key[, default=None])# 3、参数：# 3-1、key(必须)：要检索的键# 3-2、default(可选)：如果字典中不存在该键，则返回的值；如果未提供，则返回None# 4、功能：用于获取指定键的值# 5、返回值：一个新字典# 6、说明：# 6-1、如果键不存在于字典中，get()方法可以返回一个默认值(如果提供了)# 7、示例：# 7-1、基本用法my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}# 获取 'apple' 的值value = my_dict.get('apple')print(value) # 输出: 1# 尝试获取'orange'的值(不存在)，返回Nonevalue = my_dict.get('orange')print(value) # 输出: None# 7-2、使用默认值my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}# 尝试获取'orange'的值(不存在)，但返回'Not found'作为默认值value = my_dict.get('orange', 'Not found')print(value) # 输出: Not found# 7-3、在列表中使用get()my_list_of_dicts = [ {'name': 'Myelsa', 'age': 18}, {'name': 'Bruce', 'age': 6}, {'name': 'Jimmy'} # 注意：这个字典没有 'age' 键]for dict_item in my_list_of_dicts: age = dict_item.get('age', 'Age not provided') print(f"Name: {dict_item['name']}, Age: {age}")# Name: Myelsa, Age: 18# Name: Bruce, Age: 6# Name: Jimmy, Age: Age not provided

5-9-5、items()方法

# 1、方法：dict.items# 2、语法：dict.items()# 3、参数：无# 4、功能：用于返回一个视图对象，它反映了字典在调用时的状态# 5、返回值：返回一个可迭代的视图对象，展示字典中所有的键值对(key-value pairs)# 6、说明：# 7、示例：# 7-1、基本用法my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}# 获取所有的键值对items_view = my_dict.items()# 遍历并打印所有的键值对for key, value in items_view: print(f"Key: {key}, Value: {value}")# Key: apple, Value: 1# Key: banana, Value: 2# Key: cherry, Value: 3# 7-2、将items()的结果转换为列表my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}# 将items()的结果转换为列表items_list = list(my_dict.items())# 打印列表内容print(items_list)# 输出可能是(注意顺序可能因Python版本或实现而异):[('apple', 1), ('banana', 2), ('cherry', 3)]# 7-3、修改字典并检查items()视图my_dict = {'apple': 1, 'banana': 2}# 获取items()视图items_view = my_dict.items()# 修改字典my_dict['cherry'] = 3# 遍历并打印items_viewfor key, value in items_view: print(f"Key: {key}, Value: {value}")# Key: apple, Value: 1# Key: banana, Value: 2# Key: cherry, Value: 3# 重新调用items()for key, value in my_dict.items(): print(f"Key: {key}, Value: {value}")# Key: apple, Value: 1# Key: banana, Value: 2# Key: cherry, Value: 3

5-9-6、keys()方法

# 1、方法：dict.keys# 2、语法：dict.keys()# 3、参数：无# 4、功能：用于返回一个可迭代的视图对象，该对象包含了字典中所有的键(keys)# 5、返回值：返回一个可迭代的视图对象，该对象包含了字典中所有的键(keys)# 6、说明：由于字典的键是不可变的，所以即使你修改了字典的值，键的视图仍然保持不变；但是，如果你添加或删除了键，那么视图将会更新以反映这些变化# 7、示例：# 7-1、基本用法my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}# 获取所有的键keys_view = my_dict.keys()# 遍历并打印所有的键for key in keys_view: print(key)# apple# banana# cherry# 7-2、将keys()的结果转换为列表my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}# 将keys()的结果转换为列表keys_list = list(my_dict.keys())# 打印列表内容print(keys_list)# 输出可能是(注意顺序可能因Python版本或实现而异)：['apple', 'banana', 'cherry']# 7-3、修改字典并检查keys()视图my_dict = {'apple': 1, 'banana': 2}# 获取keys()视图keys_view = my_dict.keys()# 修改字典的一个值(这不会影响keys()视图)my_dict['apple'] = 10# 遍历并打印keys_view（输出与修改前相同）for key in keys_view: print(key)# 输出:# apple# banana# 添加一个新的键(这会影响keys()视图)my_dict['cherry'] = 3# 遍历并打印keys_view(现在会包含新添加的键)for key in keys_view: print(key)# 输出:# apple# banana# cherry # 新添加的键# 删除一个键(这也会影响keys()视图)del my_dict['banana']# 遍历并打印keys_view(现在不再包含被删除的键)for key in keys_view: print(key)# 输出:# apple# cherry # 'banana'键已被删除

5-9-7、pop()方法

# 1、方法：dict.pop# 2、语法：dict.pop(key[, default])# 3、参数：# 3-1、key(必须)：要从中删除并返回其值的键# 3-2、default(可选)：如果键不存在时返回的值；如果未指定并且键不存在，则会引发KeyError# 4、功能：用于从字典中删除并返回指定键的值# 5、返回值：返回指定键的值# 6、说明：# 7、示例：# 7-1、基本用法my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}# 从字典中删除并返回'apple'的值apple_value = my_dict.pop('apple')print(apple_value) # 输出: 1print(my_dict) # 输出: {'banana': 2, 'cherry': 3}# 尝试删除一个不存在的键(会引发KeyError)# my_dict.pop('orange') # KeyError: 'orange'# 7-2、使用默认值my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}# 尝试删除并返回'orange'的值，如果它不存在则返回默认值'not found'orange_value = my_dict.pop('orange', 'not found')print(orange_value) # 输出: not foundprint(my_dict) # 输出: {'apple': 1, 'banana': 2, 'cherry': 3}# 7-3、使用pop()进行条件删除my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}key_to_remove = 'banana'if key_to_remove in my_dict: value_removed = my_dict.pop(key_to_remove) print(f"Removed key '{key_to_remove}' with value {value_removed}")else: print(f"Key '{key_to_remove}' not found in the dictionary.") # 输出: Removed key 'banana' with value 2print(my_dict) # 输出: {'apple': 1, 'cherry': 3}

5-9-8、popitem()方法

# 1、方法：dict.popitem# 2、语法：dict.popitem()# 3、参数：无# 4、功能：用于随机删除并返回一个字典中的键值对(key-value pair)# 5、返回值：返回一个字典中的键值对(key-value pair)# 6、说明：在Python 3.7及以后的版本中，popitem()方法按照键(key)的插入顺序返回并删除最后插入的键值对(也称为“后进先出”或LIFO)，这被称为有序字典(ordered dictionaries)# 7、示例：# 7-1、基本用法my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}# 删除并返回一个键值对key, value = my_dict.popitem()print(f"Key: {key}, Value: {value}") # 输出可能是 "Key: cherry, Value: 3" 或其他，但在Python 3.7+中通常是最后插入的键值对print(my_dict) # 输出将是剩下的键值对，即：{'apple': 1, 'banana': 2}# 如果字典为空，调用popitem()会引发KeyError# 如果要安全地调用popitem()，可以检查字典是否为空if my_dict: key, value = my_dict.popitem()else: print("Dictionary is empty.")# 7-2、使用循环来清空字典my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}while my_dict: key, value = my_dict.popitem() print(f"Removed key: {key}, value: {value}")# 输出将是每个键值对被移除时的信息# 最后，my_dict将为空print(my_dict) # 输出: {}# 7-3、处理空字典my_dict = {}if my_dict: key, value = my_dict.popitem()else: print("Cannot pop item from an empty dictionary.") # 输出：Cannot pop item from an empty dictionary.

5-9-9、setdefault()方法

# 1、方法：dict.setdefault# 2、语法：dict.setdefault(key[, default=None])# 3、参数：# 3-1、key：需要查找或设置的键# 3-2、default(可选)：如果字典中没有该键，则返回该默认值，默认为None# 4、功能：用于获取指定键的值，如果该键不存在于字典中，则设置该键的值# 5、返回值：如果键存在于字典中，setdefault()返回该键的值，否则返回默认值# 6、说明：与get()方法不同的是，setdefault()在键不存在时还会将该键添加到字典中，并将其值设置为默认值# 7、示例：# 7-1、获取键的值my_dict = {'a': 1, 'b': 2}print(my_dict.setdefault('a', 3)) # 输出: 1，因为'a'已经存在，其值为1print(my_dict.setdefault('c', 3)) # 输出: 3，因为'c'不存在，返回默认值3，并将'c': 3添加到字典中print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3}# 7-2、使用setdefault()初始化字典# 假设我们有一个列表的键，我们想要初始化一个字典，其中这些键的值为0keys = ['apple', 'banana', 'cherry']my_dict = {}for key in keys: my_dict.setdefault(key, 0)print(my_dict) # 输出: {'apple': 0, 'banana': 0, 'cherry': 0}# 7-3、避免重复设置值my_dict = {}for i in range(5): my_dict.setdefault('count', 0) my_dict['count'] += 1print(my_dict) # 输出: {'count': 5}，尽管循环了5次，但'count'只被设置了一次

5-9-10、update()方法

# 1、方法：dict.update# 2、语法：# 2-1、dict.update(other_dict)# 2-2、dict.update(key=value, ...)# 3、参数：# 3-1、dict: 要被更新的字典# 3-2、other_dict: 另一个字典，其键值对将被添加到dict中，或者如果键已存在，则更新其值# 3-3、key=value: 可以直接传入关键字参数来更新字典中的值# 4、功能：用于将一个字典中的键值对更新到另一个字典中# 5、返回值：一个新的字典# 6、说明：# 6-1、如果新的字典中有与原始字典相同的键，那么原始字典中对应的值会被新的值所替代# 6-2、如果新的字典中的键在原始字典中不存在，那么这些键值对会被添加到原始字典中# 7、示例：# 7-1、使用另一个字典更新dict1 = {'a': 1, 'b': 2}dict2 = {'b': 3, 'c': 4}dict1.update(dict2)print(dict1) # 输出: {'a': 1, 'b': 3, 'c': 4}# 7-2、使用关键字参数更新dict1 = {'a': 1, 'b': 2}dict1.update(b=3, d=4)print(dict1) # 输出: {'a': 1, 'b': 3, 'd': 4}# 7-3、合并多个字典dict1 = {'a': 1, 'b': 2}dict2 = {'b': 3, 'c': 4}dict3 = {'d': 5, 'e': 6}# 合并dict2和dict3到dict1dict1.update(dict2, **dict3) # 注意：这里dict2的方式是不正确的，只是为了展示意图# 正确的合并方式是使用**解包每个字典dict1.update(dict2)dict1.update(**dict3)print(dict1) # 输出: {'a': 1, 'b': 3, 'c': 4, 'd': 5, 'e': 6}# 或者，你也可以使用{}和**运算符来一次性合并多个字典dict1 = {'a': 1, 'b': 2}dict2 = {'b': 3, 'c': 4}dict3 = {'d': 5, 'e': 6}# 使用{}和**运算符合并字典dict1 = {**dict1, **dict2, **dict3} # 在Python 3.5及以后的版本中，你可以使用{**dict1, **dict2}这种形式来直接合并字典print(dict1) # 输出: {'a': 1, 'b': 3, 'c': 4, 'd': 5, 'e': 6}

5-9-11、values()方法

# 1、方法：dict.values# 2、语法：dict.values()# 3、参数：无# 4、功能：用于返回字典中所有值的一个视图对象(view object)# 5、返回值：一个动态集合，它反映了字典在调用时的状态，但它不是一个列表# 6、说明：# 6-1、如果你需要一个列表，你可以通过list()函数将视图对象转换为列表# 6-2、虽然视图对象在大多数情况下可以像列表一样使用(例如，可以通过索引访问元素或检查长度)，但它们不是列表# 6-3、视图对象提供了对底层数据的动态视图，这意味着如果原始字典被修改，视图对象也会反映这些修改，然而，视图对象并不支持所有的列表方法(如append()或insert())，因为它们不是用于修改数据的# 7、示例：# 创建一个字典my_dict = { "key1": "value1", "key2": "value2", "key3": "value3"}# 使用values()方法获取所有的值values_view = my_dict.values()# 打印值的视图对象(它通常不会直接显示所有的值，但它是一个可迭代对象)print(values_view) # 输出类似于：dict_values(['value1', 'value2', 'value3'])# 将值的视图对象转换为列表并打印values_list = list(my_dict.values())print(values_list) # 输出：['value1', 'value2', 'value3']# 你可以直接迭代视图对象for value in my_dict.values(): print(value) # 输出：value1, value2, value3（按字典中的顺序或任意顺序）# 需要注意的是，如果字典在迭代过程中被修改，可能会引发RuntimeError# 但简单地从视图对象中获取值通常是安全的

二、推荐阅读

1、Python-VBA函数之旅-dict()函数

2、Python算法之旅

3、Python函数之旅

4、个人主页-神奇夜光杯-CSDN