前言时刻

上午讲的好多呀，信息量有点大，主要讲字典

来来总结：

今天主要讲了字典的创建、增：setdefault、删：pop、del、改、查：get

以及dic.keys()、 dic.values()、 dic.items()

字典

字典的特点是由键值对组成，其中键是可哈希的，一般是int、str，而值可以是任意数据类型，不可哈希。优点是查询速度快，但是存储空间较大，典型的用空间复杂度换时间。

从3.6X版本以来，字典默认有序，顺序按照字典建立前后顺序。

1、创建字典

  1. # 1、最常用
  2. dic = {'name': 'come', 'hobby': [1, 2, 3], 'age': 18}   # {'name': 'come', 'hobby': [1, 2, 3], 'age': 18}
  4. # 2、拆包创建字典
  5. dic2 = dict((('name', 'come'), ('age', 18)))   # {'name': 'come', 'age': 18}
  7. # 3、传入键值创建
  8. dic3 = dict(name="come", age=18)   # {'name': 'come', 'age': 18}

2、增

1、常用 有则修改，无则添加。

  1. dic = {'name': 'come'}
  3. # 1、常用 有则修改，无则添加
  4. dic['age'] = 18    # {'name': 'come', 'age': 18}
  5. dic['name'] = 'on'   # {'name': 'on', 'age': 18}

2、setdefault 有则不变，无则添加。

  1. dic = {'name': 'come'}
  3. # 2、setdefault 有则不变，无则添加
  4. dic.setdefault('hobby', '看电影')   # {'name': 'on', 'age': 18, 'hobby': '看电影'}
  5. dic.setdefault('hobby', "美食")   # {'name': 'on', 'age': 18, 'hobby': '看电影'}

3、删

1. pop 函数

dict.pop(key[,default])

  • key: 要删除的键值
  • default: 如果没有 key，返回 default 值
  1. dic = {'name': 'come', 'hobby': [1, 2], 'age': 18}
  3. # 1、最常用 pop ，按键删除。注意列表中pop是按索引删除
  4. dic.pop('hobby')   # {'name': 'come', 'age': 18}
  6. # 2、若删除不存在的键，可添加第二个参数并返回。类似get用法
  7. res = dic.pop('address', "Sorry")
  8. print(res)   # Sorry

2. del 函数

  1. dic = {'name': 'come', 'age': 18}
  3. # 2、del
  4. del dic['age']   # {'name': 'come'}
  5. print(dic)
  7. del dic['address']   # 直接报错

3. clear 清空

直接清空字典，但保留字典格式

  1. dic = {'name': 'come', 'age': 18}
  3. dic.clear()

4、改

  1. dic = {'name': 'come', 'hobby': [1, 2, 3], 'age': 18}
  3. # 1、
  4. dic['name'] = 'on'
  5. print(dic)   # {'name': 'on', 'hobby': [1, 2, 3], 'age': 18}
  7. dic['hobby'].append(666)
  8. print(dic)   # {'name': 'on', 'hobby': [1, 2, 3, 666], 'age': 18}

5、查

常用 dic.get(key) 获得键值。

  1. dic = {'name': 'come', 'hobby': [1, 2, 3], 'age': 18}
  3. # 1、最常用 get 
  4. dic.get('hobby')   # [1, 2, 3]
  6. print(dic.get('address', "Sorry"))   # Sorry
  8. # 2、索引型
  9. print(dic['name'])   # come
  11. print(dic['address'])   # 直接报错

6、键值对迭代器

dic.keys()：获取到字典所有键的迭代器对象

dic.values()：获取到字典所有值的迭代器对象

dic.items()：获取到字典所有键和值元组的迭代器对象、

  1. dic = {'name': 'come', 'hobby': [1, 2, 3], 'age': 18}
  3. # 1、
  4. print(dic.keys())
  5. print(dic.values())
  6. print(dic.items())
  8. # dict_keys(['name', 'hobby', 'age'])
  9. # dict_values(['come', [1, 2, 3], 18])
  10. # dict_items([('name', 'come'), ('hobby', [1, 2, 3]), ('age', 18)])
  12. # 2、例子2 迭代打印内容
  13. for key, value in dic.items():
  14.     print(f"键：{key} 值：{value}")
  15. """
  16. 键：name 值：come
  17. 键：hobby 值：[1, 2, 3]
  18. 键：age 值：18
  19. """

Last、小试牛刀：面试题

例1：

  1. dic = {'hobby': [1, 2, 3], 'age': 18}
  3. dic2 = dic.get('hobby')
  4. dic2.append(666)
  6. print(dic, dic2)
  7. # ？？？？问打印dic dic2的结果是？
  8. # 1、{'hobby': [1, 2, 3, 666], 'age': 18} [1, 2, 3, 666]
  9. # 2、{'hobby': [1, 2, 3], 'age': 18} [1, 2, 3, 666]

答案是1，你写对了吗？可能你会疑惑了，为什么是 dic2 的追加一个值，而 dic 中也会变？

这就涉及到深浅拷贝了，就像上面的 dic2 只是对键 “hobby” 的值引用，属于浅拷贝，并没有开辟自己的存储空间，说白了就是一个变量符号而已。当你修改 dic2 的值其实就是修改 dic 中的值，如果你只是想单独修改 dic2 的值，那就深度拷贝一下吧。

如：

  1. import copy
  3. # 1、深度拷贝
  4. dic = {'hobby': [1, 2, 3], 'age': 18}
  6. dic3 = copy.deepcopy(dic.get('hobby'))
  7. dic3.append(666)
  9. print(dic)  # {'hobby': [1, 2, 3], 'age': 18}
  10. print(dic3)   # [1, 2, 3, 666]
  12. # 可以看到 dic 并没有被修改

——————2021.06.24更新——————

1）python 如何一次性取出字典中多个键的对应的值？

答：使用内置函数operator中的itemgetter方法。

  1. from operator import itemgetter
  3. dic = {'name': 'python', 'age': 17, 'job': 'code'}
  4. age, name, job = itemgetter('age', 'name', 'job')(dic)
  5. print(age, name, job, sep=' ')   # 17 python code

通过它的源码可以得出，itemgetter还支持列表的一次性取多个值：

  1. likes = ['python', 'Java', 'c++']
  2. print(itemgetter(0, 1, 2)(likes))   # ('python', 'Java', 'c++')

itemgetter类源码，写的是真的好，真专业：

  1. class itemgetter:
  2.     """
  3.     Return a callable object that fetches the given item(s) from its operand.
  4.     After f = itemgetter(2), the call f(r) returns r[2].
  5.     After g = itemgetter(2, 5, 3), the call g(r) returns (r[2], r[5], r[3])
  6.     """
  7.     __slots__ = ('_items', '_call')
  9.     def __init__(self, item, *items):
  10.         if not items:
  11.             self._items = (item,)
  12.             def func(obj):
  13.                 return obj[item]
  14.             self._call = func
  15.         else:
  16.             self._items = items = (item,) + items
  17.             def func(obj):
  18.                 return tuple(obj[i] for i in items)
  19.             self._call = func
  21.     def __call__(self, obj):
  22.         return self._call(obj)
  24.     def __repr__(self):
  25.         return '%s.%s(%s)' % (self.__class__.__module__,
  26.                               self.__class__.__name__,
  27.                               ', '.join(map(repr, self._items)))
  29.     def __reduce__(self):
  30.         return self.__class__, self._items

———————————————————

总结

字典的内容还行，重要的是多练多总结，就这样，明天继续写。