字典——增

fromkeys():创建一个新字典 update():更新字典 copy():复制字典


  1. new_dict = dict.fromkeys(['a', 'b', 'c'], 0)
  2. print(f"初始化字典：{new_dict}")
  3. for key in new_dict.keys():
  4.     new_dict[key] += 1
  5. print(new_dict)
  7. """
  8. 初始化字典：{'a': 0, 'b': 0, 'c': 0}
  9. {'a': 1, 'b': 1, 'c': 1}
  10. """

字典——删

popitem():返回并删除字典中的最后一对键和值(元组)，为空会报错 pop():给定key，返回被删除值 clear():清除字典


  1. new_dict = {'a': 1, 'b': 1, 'c': 1}
  2. print(new_dict.popitem())
  3. print(type(new_dict.popitem()))
  5. """
  6. ('c', 1)
  7. <class 'tuple'>
  8. """

字典——改

dict[“a”]=”values”

字典——查

key in dict：检查key是否在字典 items():以列表返回可遍历的(键、值)元组数组 keys():返回一个迭代器，可以list()转换为列表 values():返回一个迭代器，可以list()转换为列表 get():返回指定的值,不存在则返回默认 setdefault(key, default=None):返回指定的值,不存在则返回默认 len(dict)：返回字典dict中的项数 list(dict)： 返回字典dict中使用的所有键的列表

  1. dict_info2 = {3: 'd', 4: 'e'}
  2. print("检查key是否在字典：", 1 in dict_info)
  3. print("items以列表返回可遍历的(键、值)元组数组：", dict_info.items())
  4. print("keys返回一个迭代器，可以list()转换为列表：", dict_info.keys())
  5. print("values返回一个迭代器，可以list()转换为列表：", dict_info.values())
  6. print("get返回指定的值,不存在则返回默认：", dict_info.get(3, 'c'))
  7. print("setdefault返回指定的值,不存在则返回默认：", dict_info.setdefault(3, 'c'))
  8. dict_info.update(dict_info2)
  9. print("更新字典:", dict_info)
  10. dict_copy = dict_info.copy()
  11. print("复制字典:", dict_copy)
  12. print("创建一个新字典:", dict.fromkeys(tuple_info, 100))
  13. print("随机返回并删除字典最后一键值对", dict_info.popitem(), dict_info)
  14. print("给定key，返回被删除值：", dict_info.pop(1), dict_info)
  15. dict_info.clear()
  16. print("清除字典:", dict_info)
  17. ------------------------------
  18. #检查key是否在字典： True
  19. #items以列表返回可遍历的(键、值)元组数组： dict_items([(1, 'a'), (2, 'b')])
  20. #keys返回一个迭代器，可以list()转换为列表： dict_keys([1, 2])
  21. #values返回一个迭代器，可以list()转换为列表： dict_values(['a', 'b'])
  22. #get返回指定的值,不存在则返回默认： c
  23. #setdefault返回指定的值,不存在则返回默认： c
  24. #更新字典: {1: 'a', 2: 'b', 3: 'd', 4: 'e'}
  25. #复制字典: {1: 'a', 2: 'b', 3: 'd', 4: 'e'}
  26. #创建一个新字典: {1: 100, 2: 100, 3: 100, 4: 100}
  27. #随机返回并删除字典最后一键值对 (4, 'e') {1: 'a', 2: 'b', 3: 'd'}
  28. #给定key，返回被删除值： a {2: 'b', 3: 'd'}
  29. #清除字典: {}

合并字典的各种姿势

  1. a = {"name": "zaygee", "age": 18}
  2. b = {"name2": "hoan", "age2": 20}
  4. # update
  5. a.update(b)
  6. print(a)
  7. # {'name2': 'hoan', 'age': 18, 'age2': 20, 'name': 'zaygee'}
  9. # 解包
  10. print({**a, **b})
  11. # {'name': 'zaygee', 'age': 18, 'name2': 'hoan', 'age2': 20}
  14. # itertools
  15. import itertools
  17. print(
  18.     dict(
  19.         itertools.chain(
  20.             a.items(), 
  21.             b.items()
  22.             )
  23.         )
  24.     )
  25. # {'name': 'zaygee', 'age': 18, 'name2': 'hoan', 'age2': 20}
  27. # collection.ChainMap
  28. # tips: 使用 ChainMap 有一点需要注意，当字典间有重复的键时，只会取第一个值，排在后面的键值并不会更新掉前面的
  29. from collections import ChainMap
  31. print(dict(ChainMap(a, b)))
  32. # {'name': 'zaygee', 'age': 18, 'name2': 'hoan', 'age2': 20}
  35. # dict.items() 
  36. print(dict(a.items() | b.items()))
  37. # {'name': 'zaygee', 'name2': 'hoan', 'age2': 20, 'age': 18}
  41. # 字典解析式
  42. print({k: v for i in [a, b] for k, v in i.items()})
  43. # {'name': 'zaygee', 'age': 18, 'name2': 'hoan', 'age2': 20}

实现字典的多级排序

  1. 使用sort：.sort(key=lambda x: (x[“age”], -x[“score]))
  2. 使用sorted：sorted(, key=lambda x: (x[“age”], -x[“score])))
  1. students = [
  2.     {"name": "zaygee", "age": 15, "score": 90},
  3.     {"name": "hoan", "age": 15, "score": 80},
  4.     {"name": "john", "age": 16, "score": 80}
  5. ]
  7. # 使用sort先按年纪正序排序再按分数倒序排序
  8. students.sort(key=lambda student : (student["age"], -student["score"]))
  9. print("先按年纪正序排序再按分数倒序排序: \n", students)
  10. # 先按年纪正序排序再按分数倒序排序: 
  11. #  [{'name': 'zaygee', 'age': 15, 'score': 90}, {'name': 'hoan', 'age': 15, 'score': 80}, {'name': 'john', 'age': 16, 'score': 80}]
  13. # 使用sorted
  14. result = sorted(students, key=lambda student : (student["age"], -student["score"]))
  15. print(result)
  16. # [{'name': 'zaygee', 'age': 15, 'score': 90}, {'name': 'hoan', 'age': 15, 'score': 80}, {'name': 'john', 'age': 16, 'score': 80}]

字典实现计算斐波那契数列

  1. class UserDict(dict):
  3.     def __init__(self):
  4.         self[0] = self[1] = 1
  6.     def __missing__(self, key):
  7.         fib_key = self[key] = self[key - 1] + self[key - 2]
  8.         return fib_key
  10. fib_dict = UserDict()
  11. print(fib_dict[10])
  12. # print(fib_dict[500])    # RecursionError: maximum recursion depth exceeded 超过递归深度
  14. fib_dict2 = UserDict()
  15. for i in range(2000):
  16.     print(i)
  17.     # 利用字典是可变参数的特性(有记忆的)，此方法调用，不会出现递归问题
  18.     _ = fib_dict2[i]
  19. print(fib_dict2[2000])

munch实现字典的点式操作

  1. """
  2. 实现dict的点式操作，并继承字典的所有操作
  3. """
  5. from munch import Munch, DefaultMunch, DefaultFactoryMunch
  7. # profile = Munch()
  8. # 使用DefaultMunch() 当访问不存在的key时不会直接报错，可设置默认值，不设置则为None
  9. # profile = DefaultMunch()
  10. profile = DefaultMunch("default", {"age": 10})
  11. print(isinstance(profile, dict)) # True
  13. profile.name = "zaygee"
  14. print(profile.name)
  16. print(profile.values())
  17. print(profile.items())
  18. print(profile.keys())
  20. # 访问不存在的key，返回默认值default
  21. print(profile.sex)
  23. # 自动创建key工厂方法，当key不存在时，新增该key并设置其为默认值
  24. profile = DefaultFactoryMunch(str, age=10)
  25. print(profile.name) # 输出为空
  26. print(profile.items()) # dict_items([('age', 10), ('name', '')])

有序的字典

  1. """有序的字典OrderedDict"""
  3. from collections import OrderedDict
  5. d = OrderedDict(name='zaygee', age=10)
  6. print(d)
  8. d['a'] = 1
  9. print(d['a'])
  10. # d= OrderedDict([('name', 'zaygee'), ('age', 10), ('a', 1)])
  11. print("d=", d)
  13. e = OrderedDict(age=10, name='zaygee')
  15. e['a'] = 1
  16. print(e['a'])
  17. # e=  OrderedDict([('age', 10), ('name', 'zaygee'), ('a', 1)])
  18. print("e= ", e)
  20. # 字典顺序不一致，判断两个字典是否相等时视为False
  21. print('e == d', e == d) # e == d False

自定义字典

继承collections.abc 抽象基类：它们可用于判断一个具体类是否具有某一特定的接口：例如是否可哈希，是否为映射类 MutableMapping: 支持创建映射后管理映射内容的方法 抽象方法：getitem, setitem, delitem, iter, len

  1. """自定义字典
  2.     继承collections.abc 抽象基类：它们可用于判断一个具体类是否具有某一特定的接口：例如是否可哈希，是否为映射类
  3.     MutableMapping: 支持创建映射后管理映射内容的方法
  4.         抽象方法：__getitem__, __setitem__, __delitem__, __iter__, __len__
  5. """
  6. from collections.abc import MutableMapping
  7. from collections import defaultdict
  10. class CustomizeDict(MutableMapping):
  12.     def __init__(self):
  13.         # 当某个key不存在时，默认为0
  14.         self.data = defaultdict(int)
  16.     def __getitem__(self, key):
  17.         print(f"调用__getitem__ 根据 {key} 获取值")
  18.         return self.data[key]
  20.     def __setitem__(self, key, value):
  21.         print(f"调用 __setitem__ 设置 {key} 的值为 {value}")
  22.         self.data[key] = value
  24.     def __delitem__(self, key):
  25.         print(f"调用 __delitem__ 删除 {key}")
  27.     def __iter__(self):
  28.       return iter(self.data)
  30.     def __len__(self):
  31.         return len(self.data)
  34. a = CustomizeDict()
  35. # 调用__getitem__ 根据 a 获取值
  36. # 0
  37. print(a['a'])
  39. # 调用 __setitem__ 设置 a 的值为 1
  40. # 调用__getitem__ 根据 a 获取值
  41. a['a'] = 1
  43. # 调用 __delitem__ 删除 a
  44. a.popitem()