
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'的值(不存在)，返回None
value = 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_view
for 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)  # 输出: 1
print(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 found
print(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 2
print(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'已经存在，其值为1
print(my_dict.setdefault('c', 3))  # 输出: 3，因为'c'不存在，返回默认值3，并将'c': 3添加到字典中
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}
# 7-2、使用setdefault()初始化字典
# 假设我们有一个列表的键，我们想要初始化一个字典，其中这些键的值为0
keys = ['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'] += 1
print(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到dict1
dict1.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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/629125