Python筑基之旅-字典

目录

一、字典

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所有属性和方法的列表

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

4、获取字典的帮助信息

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

  1. Help on class dict in module builtins:
  2.  
  3. class dict(object)
  4.  |  dict() -> new empty dictionary
  5.  |  dict(mapping) -> new dictionary initialized from a mapping object's
  6.  |      (key, value) pairs
  7.  |  dict(iterable) -> new dictionary initialized as if via:
  8.  |      d = {}
  9.  |      for k, v in iterable:
  10.  |          d[k] = v
  11.  |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
  12.  |      in the keyword argument list.  For example:  dict(one=1, two=2)
  13.  |  
  14.  |  Methods defined here:
  15.  |  
  16.  |  __contains__(self, key, /)
  17.  |      True if the dictionary has the specified key, else False.
  18.  |  
  19.  |  __delitem__(self, key, /)
  20.  |      Delete self[key].
  21.  |  
  22.  |  __eq__(self, value, /)
  23.  |      Return self==value.
  24.  |  
  25.  |  __ge__(self, value, /)
  26.  |      Return self>=value.
  27.  |  
  28.  |  __getattribute__(self, name, /)
  29.  |      Return getattr(self, name).
  30.  |  
  31.  |  __getitem__(...)
  32.  |      x.__getitem__(y) <==> x[y]
  33.  |  
  34.  |  __gt__(self, value, /)
  35.  |      Return self>value.
  36.  |  
  37.  |  __init__(self, /, *args, **kwargs)
  38.  |      Initialize self.  See help(type(self)) for accurate signature.
  39.  |  
  40.  |  __ior__(self, value, /)
  41.  |      Return self|=value.
  42.  |  
  43.  |  __iter__(self, /)
  44.  |      Implement iter(self).
  45.  |  
  46.  |  __le__(self, value, /)
  47.  |      Return self<=value.
  48.  |  
  49.  |  __len__(self, /)
  50.  |      Return len(self).
  51.  |  
  52.  |  __lt__(self, value, /)
  53.  |      Return self
  54.  |  
  55.  |  __ne__(self, value, /)
  56.  |      Return self!=value.
  57.  |  
  58.  |  __or__(self, value, /)
  59.  |      Return self|value.
  60.  |  
  61.  |  __repr__(self, /)
  62.  |      Return repr(self).
  63.  |  
  64.  |  __reversed__(self, /)
  65.  |      Return a reverse iterator over the dict keys.
  66.  |  
  67.  |  __ror__(self, value, /)
  68.  |      Return value|self.
  69.  |  
  70.  |  __setitem__(self, key, value, /)
  71.  |      Set self[key] to value.
  72.  |  
  73.  |  __sizeof__(...)
  74.  |      D.__sizeof__() -> size of D in memory, in bytes
  75.  |  
  76.  |  clear(...)
  77.  |      D.clear() -> None.  Remove all items from D.
  78.  |  
  79.  |  copy(...)
  80.  |      D.copy() -> a shallow copy of D
  81.  |  
  82.  |  get(self, key, default=None, /)
  83.  |      Return the value for key if key is in the dictionary, else default.
  84.  |  
  85.  |  items(...)
  86.  |      D.items() -> a set-like object providing a view on D's items
  87.  |  
  88.  |  keys(...)
  89.  |      D.keys() -> a set-like object providing a view on D's keys
  90.  |  
  91.  |  pop(...)
  92.  |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
  93.  |      
  94.  |      If the key is not found, return the default if given; otherwise,
  95.  |      raise a KeyError.
  96.  |  
  97.  |  popitem(self, /)
  98.  |      Remove and return a (key, value) pair as a 2-tuple.
  99.  |      
  100.  |      Pairs are returned in LIFO (last-in, first-out) order.
  101.  |      Raises KeyError if the dict is empty.
  102.  |  
  103.  |  setdefault(self, key, default=None, /)
  104.  |      Insert key with a value of default if key is not in the dictionary.
  105.  |      
  106.  |      Return the value for key if key is in the dictionary, else default.
  107.  |  
  108.  |  update(...)
  109.  |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
  110.  |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
  111.  |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
  112.  |      In either case, this is followed by: for k in F:  D[k] = F[k]
  113.  |  
  114.  |  values(...)
  115.  |      D.values() -> an object providing a view on D's values
  116.  |  
  117.  |  ----------------------------------------------------------------------
  118.  |  Class methods defined here:
  119.  |  
  120.  |  __class_getitem__(...) from builtins.type
  121.  |      See PEP 585
  122.  |  
  123.  |  fromkeys(iterable, value=None, /) from builtins.type
  124.  |      Create a new dictionary with keys from iterable and values set to value.
  125.  |  
  126.  |  ----------------------------------------------------------------------
  127.  |  Static methods defined here:
  128.  |  
  129.  |  __new__(*args, **kwargs) from builtins.type
  130.  |      Create and return a new object.  See help(type) for accurate signature.
  131.  |  
  132.  |  ----------------------------------------------------------------------
  133.  |  Data and other attributes defined here:
  134.  |  
  135.  |  __hash__ = None

5、字典的用法

5-1、创建字典
5-1-1、创建一个空字典
  1. # 创建一个空字典
  2. my_dict = {}
  3. print(my_dict) # 输出：{}
5-1-2、创建一个包含键值对的字典
  1. # 创建一个包含键值对的字典
  2. my_dict = {"name":"Myelsa", "age":18, "city":"Guangzhou"}
  3. print(my_dict) # 输出：{'name': 'Myelsa', 'age': 18, 'city': 'Guangzhou'}
5-1-3、创建一个嵌套字典
  1. # 创建一个元组/字符串嵌套做键的嵌套字典
  2. my_dict = {
  3.     (1, 2, 3): "value1",  # 这是一个包含整数的元组作为键
  4.     ("key1", "key2"): "value2",  # 这是一个包含字符串的元组作为键
  5.     # ([1, 2], "key"): "value",  # 这是错误的，因为列表是可变的
  6.     # ({"nested_key": "nested_value"}, "key"): "value",  # 这是错误的，因为字典是可变的
  7. }
  8. print(my_dict) # 输出：{(1, 2, 3): 'value1', ('key1', 'key2'): 'value2'}
  9. # 创建一个值嵌套字典
  10. my_dict = {
  11.     "key1": "value1",
  12.     "key2": "value2",
  13.     "key3": 3,
  14.     "key4": [1, 2, 3],  # 字典的值可以是任何数据类型，包括列表、元组、字典等
  15.     "key5": {"nested_key": "nested_value"}  # 字典的值也可以是另一个字典(嵌套字典)
  16. }
  17. print(my_dict) # 输出：{'key1': 'value1', 'key2': 'value2', 'key3': 3, 'key4': [1, 2, 3], 'key5': {'nested_key': 'nested_value'}}
5-2、新增字典的键值对
  1. # 新增字典的键值对
  2. my_dict = {
  3.     "key1": "value1",
  4.     "key2": "value2",
  5.     "key3": 3,
  6.     "key4": [1, 2, 3],  # 字典的值可以是任何数据类型，包括列表、元组、字典等
  7.     "key5": {"nested_key": "nested_value"}  # 字典的值也可以是另一个字典(嵌套字典)
  8. }
  9. my_dict["key6"] = "value6"
  10. print(my_dict) # 输出：{'key1': 'value1', 'key2': 'value2', 'key3': 3, 'key4': [1, 2, 3], 'key5': {'nested_key': 'nested_value'}, 'key6': 'value6'}
5-3、删除字典中的键值对
  1. # 删除字典中的键值对
  2. my_dict = {
  3.     "key1": "value1",
  4.     "key2": "value2",
  5.     "key3": 3,
  6.     "key4": [1, 2, 3],  # 字典的值可以是任何数据类型，包括列表、元组、字典等
  7.     "key5": {"nested_key": "nested_value"}  # 字典的值也可以是另一个字典(嵌套字典)
  8. }
  9. del my_dict["key2"]
  10. print(my_dict) # 输出：{'key1': 'value1', 'key3': 3, 'key4': [1, 2, 3], 'key5': {'nested_key': 'nested_value'}}
5-4、修改字典中的值
  1. # 修改字典中的值
  2. my_dict = {
  3.     "key1": "value1",
  4.     "key2": "value2",
  5.     "key3": 3,
  6.     "key4": [1, 2, 3],  # 字典的值可以是任何数据类型，包括列表、元组、字典等
  7.     "key5": {"nested_key": "nested_value"}  # 字典的值也可以是另一个字典(嵌套字典)
  8. }
  9. my_dict["key1"] = "new_value1"
  10. print(my_dict) # 输出：{'key1': 'new_value1', 'key2': 'value2', 'key3': 3, 'key4': [1, 2, 3], 'key5': {'nested_key': 'nested_value'}}
5-5、访问字典中的值
  1. # 访问字典中的值
  2. my_dict = {
  3.     "key1": "value1",
  4.     "key2": "value2",
  5.     "key3": 3,
  6.     "key4": [1, 2, 3],  # 字典的值可以是任何数据类型，包括列表、元组、字典等
  7.     "key5": {"nested_key": "nested_value"}  # 字典的值也可以是另一个字典(嵌套字典)
  8. }
  9. print(my_dict["key1"])  # 输出: value1
5-6、遍历字典的键
  1. # 遍历字典的键
  2. my_dict = {
  3.     "key1": "value1",
  4.     "key2": "value2",
  5.     "key3": 3,
  6.     "key4": [1, 2, 3],  # 字典的值可以是任何数据类型，包括列表、元组、字典等
  7.     "key5": {"nested_key": "nested_value"}  # 字典的值也可以是另一个字典(嵌套字典)
  8. }
  9. for key in my_dict:
  10.     print(key)
  11. # key1
  12. # key2
  13. # key3
  14. # key4
  15. # key5
5-7、遍历字典的键值对
  1. # 遍历字典的键值对
  2. my_dict = {
  3.     "key1": "value1",
  4.     "key2": "value2",
  5.     "key3": 3,
  6.     "key4": [1, 2, 3],  # 字典的值可以是任何数据类型，包括列表、元组、字典等
  7.     "key5": {"nested_key": "nested_value"}  # 字典的值也可以是另一个字典(嵌套字典)
  8. }
  9. for key, value in my_dict.items():
  10.     print(key, value)
  11. # key1 value1
  12. # key2 value2
  13. # key3 3
  14. # key4 [1, 2, 3]
  15. # key5 {'nested_key': 'nested_value'}
5-8、检查键是否存在
  1. # 检查键是否存在
  2. my_dict = {
  3.     "key1": "value1",
  4.     "key2": "value2",
  5.     "key3": 3,
  6.     "key4": [1, 2, 3],  # 字典的值可以是任何数据类型，包括列表、元组、字典等
  7.     "key5": {"nested_key": "nested_value"}  # 字典的值也可以是另一个字典(嵌套字典)
  8. }
  9. if "key3" in my_dict:
  10.     print("key3 exists in the dictionary.") # 输出：key3 exists in the dictionary.
5-9、字典的用法
5-9-1、clear()方法
  1. # 1、方法：dict.clear
  2. # 2、语法：dict.clear()
  3. # 3、参数：无
  4. # 4、功能：用于移除字典中的所有键值对，使其变为一个空字典
  5. # 5、返回值：一个空字典
  6. # 6、说明：
  7. # 6-1、clear()方法会直接修改原始字典，而不是返回一个新的字典
  8. # 6-2、如果你需要保留原始字典不变并得到一个清空后的新字典，你应该先复制原始字典，再对新字典调用clear()方法
  9. # 7、示例：
  10. # 创建一个字典
  11. my_dict = {"name":"Myelsa", "age":18, "city":"Guangzhou"}
  12. # 打印原始字典
  13. print("原始字典:", my_dict) # 输出：原始字典: {'name': 'Myelsa', 'age': 18, 'city': 'Guangzhou'}
  14. # 调用clear()方法清空字典
  15. my_dict.clear()
  16. # 打印清空后的字典
  17. print("清空后的字典:", my_dict) # 输出：清空后的字典: {}
5-9-2、copy()方法
  1. # 1、方法：dict.copy
  2. # 2、语法：dict.copy()
  3. # 3、参数：无
  4. # 4、功能：用于创建字典的一个浅拷贝(shallow copy)
  5. # 5、返回值：浅拷贝会创建一个新的字典对象，并复制原字典中所有的键值对
  6. # 6、说明：
  7. # 6-1、如果原字典中的值是可变的(如列表、字典等)，则新字典中对应的值将是原值的引用，而不是副本，
  8. #     这意味着如果你修改了新字典中这些可变类型的值，原字典中的值也会受到影响
  9. # 7、示例：
  10. # 创建一个字典
  11. original_dict = {"name":"Myelsa", "age":[18, 15], "city":"Guangzhou"}
  12. # 使用copy()方法创建浅拷贝
  13. copied_dict = original_dict.copy()
  14. # 修改浅拷贝中的值(对于不可变类型)
  15. copied_dict['name'] = "Jimmy"
  16. # 修改浅拷贝中的列表(对于可变类型)
  17. copied_dict['age'].append(6)
  18. # 打印原字典和浅拷贝后的字典
  19. print("原字典:", original_dict) # 输出：原字典: {'name': 'Myelsa', 'age': [18, 15, 6], 'city': 'Guangzhou'}
  20. print("浅拷贝后的字典:", copied_dict) # 输出：浅拷贝后的字典: {'name': 'Jimmy', 'age': [18, 15, 6], 'city': 'Guangzhou'} 其中age为可变的列表，因此，会影响到原字典
  21.  
  22. # 创建深拷贝(如果需要)
  23. # 如果你需要创建一个真正的“深拷贝”(即，拷贝所有的层次)，你可以使用copy模块中的deepcopy()函数
  24. import copy
  25. # 创建一个字典
  26. original_dict = {"name":"Myelsa", "age":[18, 15], "city":"Guangzhou"}
  27. # 使用deepcopy()方法创建深拷贝
  28. deep_copied_dict = copy.deepcopy(original_dict)
  29. # 修改深拷贝中的列表
  30. deep_copied_dict['age'].append(6)
  31. # 打印原字典和深拷贝后的字典
  32. print("原字典:", original_dict) # 输出：原字典: {'name': 'Myelsa', 'age': [18, 15], 'city': 'Guangzhou'}  原字典中的列表并未被修改，因为deepcopy()创建了原字典中所有层次的完全独立的副本
  33. print("深拷贝后的字典:", deep_copied_dict) # 输出：深拷贝后的字典: {'name': 'Myelsa', 'age': [18, 15, 6], 'city': 'Guangzhou'}
5-9-3、fromkeys()方法
  1. # 1、方法：dict.fromkeys
  2. # 2、语法：dict.fromkeys(iterable, value=None, /)
  3. # 3、参数：
  4. # 3-1、iterable(必须)：一个可迭代对象，如列表、元组、集合等，其中的元素将作为新字典的键
  5. # 3-2、value(可选)：一个值，将作为新字典中所有键对应的初始值，默认为None
  6. # 4、功能：用于创建一个新字典，以给定的可迭代对象(如列表、元组等)中的元素作为键，并可以选择性地指定一个默认值作为所有键对应的初始值
  7. # 5、返回值：一个新字典
  8. # 6、说明：
  9. # 6-1、如果在创建新字典后修改了iterable对象(例如列表或元组)，这不会影响已经创建的新字典，因为iterable只是被用来提供键的初始集合
  10. # 6-2、fromkeys()方法返回的是一个新的字典对象，原字典(如果有的话)不会被修改
  11. # 6-3、如果iterable中包含的元素是不可哈希的(例如列表或字典本身)，则无法使用fromkeys()方法创建字典，因为字典的键必须是可哈希的
  12. # 7、示例：
  13. # 7-1、基本用法
  14. # 创建一个以列表元素为键，值为None的新字典
  15. keys = ['a', 'b', 'c']
  16. new_dict = dict.fromkeys(keys)
  17. print(new_dict)  # 输出：{'a': None, 'b': None, 'c': None}
  18. # 创建一个以列表元素为键，值为'default'的新字典
  19. keys = ['a', 'b', 'c']
  20. new_dict = dict.fromkeys(keys, 'default')
  21. print(new_dict)  # 输出：{'a': 'default', 'b': 'default', 'c': 'default'}
  22. # 7-2、使用集合作为键的源
  23. # 创建一个以集合元素为键，值为'value'的新字典
  24. keys = {'a', 'b', 'c'}
  25. new_dict = dict.fromkeys(keys, 'value')
  26. print(new_dict)  # 输出可能是 {'a': 'value', 'b': 'value', 'c': 'value'}
  27.                  # 注意集合是无序的，所以输出的顺序可能不同
  28. # 7-3、使用元组作为键的源
  29. # 创建一个以元组元素为键，值为'x'的新字典
  30. keys = ('a', 'b', 'c')
  31. new_dict = dict.fromkeys(keys, 'x')
  32. print(new_dict)  # 输出：{'a': 'x', 'b': 'x', 'c': 'x'}
5-9-4、get()方法
  1. # 1、方法：dict.get
  2. # 2、语法：dict.get(key[, default=None])
  3. # 3、参数：
  4. # 3-1、key(必须)：要检索的键
  5. # 3-2、default(可选)：如果字典中不存在该键，则返回的值；如果未提供，则返回None
  6. # 4、功能：用于获取指定键的值
  7. # 5、返回值：一个新字典
  8. # 6、说明：
  9. # 6-1、如果键不存在于字典中，get()方法可以返回一个默认值(如果提供了)
  10. # 7、示例：
  11. # 7-1、基本用法
  12. my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
  13. # 获取 'apple' 的值
  14. value = my_dict.get('apple')
  15. print(value)  # 输出: 1
  16. # 尝试获取'orange'的值(不存在)，返回None
  17. value = my_dict.get('orange')
  18. print(value)  # 输出: None
  19. # 7-2、使用默认值
  20. my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
  21. # 尝试获取'orange'的值(不存在)，但返回'Not found'作为默认值
  22. value = my_dict.get('orange', 'Not found')
  23. print(value)  # 输出: Not found
  24. # 7-3、在列表中使用get()
  25. my_list_of_dicts = [
  26.     {'name': 'Myelsa', 'age': 18},
  27.     {'name': 'Bruce', 'age': 6},
  28.     {'name': 'Jimmy'}  # 注意：这个字典没有 'age' 键
  29. ]
  30. for dict_item in my_list_of_dicts:
  31.     age = dict_item.get('age', 'Age not provided')
  32.     print(f"Name: {dict_item['name']}, Age: {age}")
  33. # Name: Myelsa, Age: 18
  34. # Name: Bruce, Age: 6
  35. # Name: Jimmy, Age: Age not provided
5-9-5、items()方法
  1. # 1、方法：dict.items
  2. # 2、语法：dict.items()
  3. # 3、参数：无
  4. # 4、功能：用于返回一个视图对象，它反映了字典在调用时的状态
  5. # 5、返回值：返回一个可迭代的视图对象，展示字典中所有的键值对(key-value pairs)
  6. # 6、说明：
  7. # 7、示例：
  8. # 7-1、基本用法
  9. my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
  10. # 获取所有的键值对
  11. items_view = my_dict.items()
  12. # 遍历并打印所有的键值对
  13. for key, value in items_view:
  14.     print(f"Key: {key}, Value: {value}")
  15. # Key: apple, Value: 1
  16. # Key: banana, Value: 2
  17. # Key: cherry, Value: 3
  18. # 7-2、将items()的结果转换为列表
  19. my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
  20. # 将items()的结果转换为列表
  21. items_list = list(my_dict.items())
  22. # 打印列表内容
  23. print(items_list)
  24. # 输出可能是(注意顺序可能因Python版本或实现而异):[('apple', 1), ('banana', 2), ('cherry', 3)]
  25. # 7-3、修改字典并检查items()视图
  26. my_dict = {'apple': 1, 'banana': 2}
  27. # 获取items()视图
  28. items_view = my_dict.items()
  29. # 修改字典
  30. my_dict['cherry'] = 3
  31. # 遍历并打印items_view
  32. for key, value in items_view:
  33.     print(f"Key: {key}, Value: {value}")
  34. # Key: apple, Value: 1
  35. # Key: banana, Value: 2
  36. # Key: cherry, Value: 3
  37. # 重新调用items()
  38. for key, value in my_dict.items():
  39.     print(f"Key: {key}, Value: {value}")
  40. # Key: apple, Value: 1
  41. # Key: banana, Value: 2
  42. # Key: cherry, Value: 3
5-9-6、keys()方法
  1. # 1、方法：dict.keys
  2. # 2、语法：dict.keys()
  3. # 3、参数：无
  4. # 4、功能：用于返回一个可迭代的视图对象，该对象包含了字典中所有的键(keys)
  5. # 5、返回值：返回一个可迭代的视图对象，该对象包含了字典中所有的键(keys)
  6. # 6、说明：由于字典的键是不可变的，所以即使你修改了字典的值，键的视图仍然保持不变；但是，如果你添加或删除了键，那么视图将会更新以反映这些变化
  7. # 7、示例：
  8. # 7-1、基本用法
  9. my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
  10. # 获取所有的键
  11. keys_view = my_dict.keys()
  12. # 遍历并打印所有的键
  13. for key in keys_view:
  14.     print(key)
  15. # apple
  16. # banana
  17. # cherry
  18. # 7-2、将keys()的结果转换为列表
  19. my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
  20. # 将keys()的结果转换为列表
  21. keys_list = list(my_dict.keys())
  22. # 打印列表内容
  23. print(keys_list)
  24. # 输出可能是(注意顺序可能因Python版本或实现而异)：['apple', 'banana', 'cherry']
  25. # 7-3、修改字典并检查keys()视图
  26. my_dict = {'apple': 1, 'banana': 2}
  27. # 获取keys()视图
  28. keys_view = my_dict.keys()
  29. # 修改字典的一个值(这不会影响keys()视图)
  30. my_dict['apple'] = 10
  31. # 遍历并打印keys_view（输出与修改前相同）
  32. for key in keys_view:
  33.     print(key)
  34. # 输出:
  35. # apple
  36. # banana
  37. # 添加一个新的键(这会影响keys()视图)
  38. my_dict['cherry'] = 3
  39. # 遍历并打印keys_view(现在会包含新添加的键)
  40. for key in keys_view:
  41.     print(key)
  42. # 输出:
  43. # apple
  44. # banana
  45. # cherry  # 新添加的键
  46. # 删除一个键(这也会影响keys()视图)
  47. del my_dict['banana']
  48. # 遍历并打印keys_view(现在不再包含被删除的键)
  49. for key in keys_view:
  50.     print(key)
  51. # 输出:
  52. # apple
  53. # cherry  # 'banana'键已被删除
5-9-7、pop()方法
  1. # 1、方法：dict.pop
  2. # 2、语法：dict.pop(key[, default])
  3. # 3、参数：
  4. # 3-1、key(必须)：要从中删除并返回其值的键
  5. # 3-2、default(可选)：如果键不存在时返回的值；如果未指定并且键不存在，则会引发KeyError
  6. # 4、功能：用于从字典中删除并返回指定键的值
  7. # 5、返回值：返回指定键的值
  8. # 6、说明：
  9. # 7、示例：
  10. # 7-1、基本用法
  11. my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
  12. # 从字典中删除并返回'apple'的值
  13. apple_value = my_dict.pop('apple')
  14. print(apple_value)  # 输出: 1
  15. print(my_dict)  # 输出: {'banana': 2, 'cherry': 3}
  16. # 尝试删除一个不存在的键(会引发KeyError)
  17. # my_dict.pop('orange')  # KeyError: 'orange'
  18. # 7-2、使用默认值
  19. my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
  20. # 尝试删除并返回'orange'的值，如果它不存在则返回默认值'not found'
  21. orange_value = my_dict.pop('orange', 'not found')
  22. print(orange_value)  # 输出: not found
  23. print(my_dict)  # 输出: {'apple': 1, 'banana': 2, 'cherry': 3}
  24. # 7-3、使用pop()进行条件删除
  25. my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
  26. key_to_remove = 'banana'
  27. if key_to_remove in my_dict:
  28.     value_removed = my_dict.pop(key_to_remove)
  29.     print(f"Removed key '{key_to_remove}' with value {value_removed}")
  30. else:
  31.     print(f"Key '{key_to_remove}' not found in the dictionary.") # 输出: Removed key 'banana' with value 2
  32. print(my_dict)  # 输出: {'apple': 1, 'cherry': 3}
5-9-8、popitem()方法
  1. # 1、方法：dict.popitem
  2. # 2、语法：dict.popitem()
  3. # 3、参数：无
  4. # 4、功能：用于随机删除并返回一个字典中的键值对(key-value pair)
  5. # 5、返回值：返回一个字典中的键值对(key-value pair)
  6. # 6、说明：在Python 3.7及以后的版本中，popitem()方法按照键(key)的插入顺序返回并删除最后插入的键值对(也称为“后进先出”或LIFO)，这被称为有序字典(ordered dictionaries)
  7. # 7、示例：
  8. # 7-1、基本用法
  9. my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
  10. # 删除并返回一个键值对
  11. key, value = my_dict.popitem()
  12. print(f"Key: {key}, Value: {value}")  # 输出可能是 "Key: cherry, Value: 3" 或其他，但在Python 3.7+中通常是最后插入的键值对
  13. print(my_dict)  # 输出将是剩下的键值对，即：{'apple': 1, 'banana': 2}
  14. # 如果字典为空，调用popitem()会引发KeyError
  15. # 如果要安全地调用popitem()，可以检查字典是否为空
  16. if my_dict:
  17.     key, value = my_dict.popitem()
  18. else:
  19.     print("Dictionary is empty.")
  20. # 7-2、使用循环来清空字典
  21. my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
  22. while my_dict:
  23.     key, value = my_dict.popitem()
  24.     print(f"Removed key: {key}, value: {value}")
  25. # 输出将是每个键值对被移除时的信息
  26. # 最后，my_dict将为空
  27. print(my_dict)  # 输出: {}
  28. # 7-3、处理空字典
  29. my_dict = {}
  30. if my_dict:
  31.     key, value = my_dict.popitem()
  32. else:
  33.     print("Cannot pop item from an empty dictionary.") # 输出：Cannot pop item from an empty dictionary.
5-9-9、setdefault()方法
  1. # 1、方法：dict.setdefault
  2. # 2、语法：dict.setdefault(key[, default=None])
  3. # 3、参数：
  4. # 3-1、key：需要查找或设置的键
  5. # 3-2、default(可选)：如果字典中没有该键，则返回该默认值，默认为None
  6. # 4、功能：用于获取指定键的值，如果该键不存在于字典中，则设置该键的值
  7. # 5、返回值：如果键存在于字典中，setdefault()返回该键的值，否则返回默认值
  8. # 6、说明：与get()方法不同的是，setdefault()在键不存在时还会将该键添加到字典中，并将其值设置为默认值
  9. # 7、示例：
  10. # 7-1、获取键的值
  11. my_dict = {'a': 1, 'b': 2}
  12. print(my_dict.setdefault('a', 3))  # 输出: 1，因为'a'已经存在，其值为1
  13. print(my_dict.setdefault('c', 3))  # 输出: 3，因为'c'不存在，返回默认值3，并将'c': 3添加到字典中
  14. print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}
  15. # 7-2、使用setdefault()初始化字典
  16. # 假设我们有一个列表的键，我们想要初始化一个字典，其中这些键的值为0
  17. keys = ['apple', 'banana', 'cherry']
  18. my_dict = {}
  19. for key in keys:
  20.     my_dict.setdefault(key, 0)
  21. print(my_dict)  # 输出: {'apple': 0, 'banana': 0, 'cherry': 0}
  22. # 7-3、避免重复设置值
  23. my_dict = {}
  24. for i in range(5):
  25.     my_dict.setdefault('count', 0)
  26.     my_dict['count'] += 1
  27. print(my_dict)  # 输出: {'count': 5}，尽管循环了5次，但'count'只被设置了一次
5-9-10、update()方法
  1. # 1、方法：dict.update
  2. # 2、语法：
  3. # 2-1、dict.update(other_dict)
  4. # 2-2、dict.update(key=value, ...)
  5. # 3、参数：
  6. # 3-1、dict: 要被更新的字典
  7. # 3-2、other_dict: 另一个字典，其键值对将被添加到dict中，或者如果键已存在，则更新其值
  8. # 3-3、key=value: 可以直接传入关键字参数来更新字典中的值
  9. # 4、功能：用于将一个字典中的键值对更新到另一个字典中
  10. # 5、返回值：一个新的字典
  11. # 6、说明：
  12. # 6-1、如果新的字典中有与原始字典相同的键，那么原始字典中对应的值会被新的值所替代
  13. # 6-2、如果新的字典中的键在原始字典中不存在，那么这些键值对会被添加到原始字典中
  14. # 7、示例：
  15. # 7-1、使用另一个字典更新
  16. dict1 = {'a': 1, 'b': 2}
  17. dict2 = {'b': 3, 'c': 4}
  18. dict1.update(dict2)
  19. print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4}
  20. # 7-2、使用关键字参数更新
  21. dict1 = {'a': 1, 'b': 2}
  22. dict1.update(b=3, d=4)
  23. print(dict1)  # 输出: {'a': 1, 'b': 3, 'd': 4}
  24. # 7-3、合并多个字典
  25. dict1 = {'a': 1, 'b': 2}
  26. dict2 = {'b': 3, 'c': 4}
  27. dict3 = {'d': 5, 'e': 6}
  28. # 合并dict2和dict3到dict1
  29. dict1.update(dict2, **dict3)  # 注意：这里dict2的方式是不正确的，只是为了展示意图
  30. # 正确的合并方式是使用**解包每个字典
  31. dict1.update(dict2)
  32. dict1.update(**dict3)
  33. print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4, 'd': 5, 'e': 6}
  34. # 或者，你也可以使用{}和**运算符来一次性合并多个字典
  35. dict1 = {'a': 1, 'b': 2}
  36. dict2 = {'b': 3, 'c': 4}
  37. dict3 = {'d': 5, 'e': 6}
  38. # 使用{}和**运算符合并字典
  39. dict1 = {**dict1, **dict2, **dict3}  # 在Python 3.5及以后的版本中，你可以使用{**dict1, **dict2}这种形式来直接合并字典
  40. print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4, 'd': 5, 'e': 6}
5-9-11、values()方法
  1. # 1、方法：dict.values
  2. # 2、语法：dict.values()
  3. # 3、参数：无
  4. # 4、功能：用于返回字典中所有值的一个视图对象(view object)
  5. # 5、返回值：一个动态集合，它反映了字典在调用时的状态，但它不是一个列表
  6. # 6、说明：
  7. # 6-1、如果你需要一个列表，你可以通过list()函数将视图对象转换为列表
  8. # 6-2、虽然视图对象在大多数情况下可以像列表一样使用(例如，可以通过索引访问元素或检查长度)，但它们不是列表
  9. # 6-3、视图对象提供了对底层数据的动态视图，这意味着如果原始字典被修改，视图对象也会反映这些修改，然而，视图对象并不支持所有的列表方法(如append()或insert())，因为它们不是用于修改数据的
  10. # 7、示例：
  11. # 创建一个字典
  12. my_dict = {
  13.     "key1": "value1",
  14.     "key2": "value2",
  15.     "key3": "value3"
  16. }
  17. # 使用values()方法获取所有的值
  18. values_view = my_dict.values()
  19. # 打印值的视图对象(它通常不会直接显示所有的值，但它是一个可迭代对象)
  20. print(values_view)  # 输出类似于：dict_values(['value1', 'value2', 'value3'])
  21. # 将值的视图对象转换为列表并打印
  22. values_list = list(my_dict.values())
  23. print(values_list)  # 输出：['value1', 'value2', 'value3']
  24. # 你可以直接迭代视图对象
  25. for value in my_dict.values():
  26.     print(value)  # 输出：value1, value2, value3（按字典中的顺序或任意顺序）
  27. # 需要注意的是，如果字典在迭代过程中被修改，可能会引发RuntimeError
  28. # 但简单地从视图对象中获取值通常是安全的

二、推荐阅读

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

2、Python算法之旅

3、Python函数之旅

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

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览61317 人正在系统学习中
遨游码海，我心飞扬
微信名片
注：本文转载自blog.csdn.net的神奇夜光杯的文章"https://myelsa1024.blog.csdn.net/article/details/139050598"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！