流畅的python学习笔记（三）：数据结构（2：字典和集合）

字典和集合

• dict 类型不但在各种程序里广泛使用，它也是 Python 语言的基石。模块的命名空间、实例的属性和函数的关键字参数中都可以看到字典的身影。跟它有关的内置函数都在 __builtins__.__dict__模块中。
• 正是因为字典至关重要，Python 对它的实现做了高度优化，而散列表则是字典类型性能出众的根本原因。
• 集合（set）的实现其实也依赖于散列表，因此本节也会讲到它。反过来说，想要进一步理解集合和字典，就得先理解散列表的原理。
• 本节大纲：
  • 常见的字典方法
  • 如何处理查找不到的键
  • 标准库中 dict 类型的变种
  • set 和 frozenset 类型
  • 散列表的工作原理
  • 散列表带来的潜在影响（什么样的数据类型可作为键、不可预知的顺序，等等）

  泛映射类型

  • collections.abc 模块中有 Mapping 和 MutableMapping 这两个抽象基类，它们的作用是为 dict 和其他类似的类型定义形式接口，如下图：
    
• 然而，非抽象映射类型一般不会直接继承这些抽象基类，它们会直接对dict 或是 collections.User.Dict 进行扩展。这些抽象基类的主要作用是作为形式化的文档，它们定义了构建一个映射类型所需要的最基本的接口。然后它们还可以跟 isinstance 一起被用来判定某个数据是不是广义上的映射类型：

from collections import abc
"""
	这里用 isinstance 而不是 type 来检查某个参数是否为 dict 类型，因为这个参数有可能不是 dict，而是一个比较另类的映射类型
"""


if __name__ == '__main__':
    my_dict = {
   }
    b = isinstance(my_dict, abc.Mapping)
    print(b)  # True

什么是可散列的数据类型

• 如果一个对象是可散列（hash）的，那么在这个对象的生命周期中， 它的散列值是不变的，而且这个对象要实现__hash__()方法。另外可散列对象还要有__qe__()方法，这样才能和其他键作比较。如果两个可散列对象是相等的，那么他们的散列值一定是一样的。
• 简单来说，如果一个对象是可散列的数据类型，那它应该是不可变的。
• 原子不可变数据类型（str、bytes 和数值类型）都是可散列类型，frozenset 也是可散列的，因为根据其定义，frozenset里只能容纳可散列类型。元组的话，只有当一个元组包含的所有元素都是可散列类型的情况下，它才是可散列的。

if __name__ == '__main__':
    tt = (1, 2, (30, 40))
    print(hash(tt))  # -3907003130834322577

    try:
        tl = (1, 2, [30, 40])
        print(hash(tl))
    except TypeError as e:
        print(e)  # unhashable type: 'list'

    tf = (1, 2, frozenset([30, 40]))
    print(hash(frozenset([30, 40])))  # -5140580174489706912
    print(hash(tf))  # 5149391500123939311
    """
    	元组tt中的每个元素都是可散列的，所以是可散列的
    	tl包含可变数据类型列表，是不可hash的
   		tf中的每个子元素都是可散列的，虽说列表不可散列，但是其被frozenset包含后整体而言是可散列的
    """

• Python 里所有的不可变类型都是可散列的这句话并不准确，比如虽然元组本身是不可变序列，它里面的元素可能是其他可变类型的引用。一般来讲用户自定义的类型的对象都是可散列的，散列值就是它们的 id() 函数的返回值，所以所有这些对象在比较的时候都是不相等的。

字典构造方式

• 标准库里的所有映射类型都是利用 dict 来实现的，因此它们有个共同的限制，即只有可散列的数据类型才能用作这些映射里的键（只有键有这个要求，值并不需要是可散列的数据类型）。根据这些定义，字典提供了很多种构造方法：

'''
    zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
'''
if __name__ == '__main__':
    a = dict(one=1, two=2, three=3)
    b = {
   "one": 1, "two": 2, "three": 3}
    c = dict(zip(["one", "two", "three"], [1, 2, 3]))
    d = dict({
   "three": 3, "two": 2, "one": 1})
    print(a == b == c == d)  # True

字典推导

• 字典推导（dictcomp）可以从任何以键值对作为元素的可迭代对象中构建出字典。如下示例：

"""
	一个承载成对数据的列表，它可以直接用在字典的构造方法中
"""
if __name__ == '__main__':
    DIAL_CODES = [
        (86, 'china'),
        (91, "India"),
        (1, "United States"),
        (62, "Indonesia"),
        (55, "Brazil"),
    ]
    country_code = {
   country: code for code, country in DIAL_CODES}
    print(country_code)  # {'china': 86, 'India': 91, 'United States': 1, 'Indonesia': 62, 'Brazil': 55}
    country_code = {
   code: country.upper() for country, code in country_code.items() if code < 66} 
    print(country_code)  # {1: 'UNITED STATES', 62: 'INDONESIA', 55: 'BRAZIL'}

常见的映射方法

• dict、collections.defaultdict和collections.OrderedDict这三种映射类型的方法列表

	dict	defaultdict	Ordereddict
d.clear()	✔	✔	✔	移除所有元素
d.__contains__(k)	✔	✔	✔	检查d是否包含键值k
d.copy()	✔	✔	✔	浅复制
d.__copy__()		✔		用于支持copy.copy
d.default_factory()		✔		在 missing 函数中被调用的函数，用以给未找到的元素设置值*
d.__delitem__(k)	✔	✔	✔	del d(k) ，移除键为k的元素
d.fromkeys(it, [initial])	✔	✔	✔	将迭代器 it 里的元素设置为映射里的键，如果有 initial 参数，就把它作为这些键对应的值（默认是 None）
d.fromkeys(it, [initial])	✔	✔	✔	返回键 k 对应的值，如果字典里没有键 k，则返回 None 或者default
d.__getitem__(k)	✔	✔	✔	让字典 d 能用 d[k] 的形式返回键k 对应的值default
d.items()	✔	✔	✔	返回 d 里所有的键值对
d.iter()	✔	✔	✔	获取键的迭代器
d.keys()	✔	✔	✔	获取所有的键
d.__len__()	✔	✔	✔	可以用 len(d) 的形式得到字典里键值对的数量
d.__missing__(k)		✔		当 __getitem__ 找不到对应键的时候，这个方法会被调用
d.move_to_end(k, [last])			✔	把键为 k 的元素移动到最靠前或者最靠后的位置（last 的默认值是 True）
d.pop(k, [default])	✔	✔	✔	返回键 k 所对应的值，然后移除这个键值对。如果没有这个键，返回 None 或者 defaul
d.popitem()	✔	✔	✔	随机返回一个键值对并从字典里移除它#
d.__reversed__()			✔	返回倒序的键的迭代器
d.setdefault(k, [default])	✔	✔	✔	若字典里有键k，则把它对应的值设置为 default，然后返回这个值；若无，则让 d[k] =default，然后返回 default
d.__setitem__(k, v)	✔	✔	✔	实现 d[k] = v 操作，把 k 对应的值设为v
d.update(m, [**kargs])	✔	✔	✔	m 可以是映射或者键值对迭代器，用来更新 d 里对应的条目
d.values()	✔	✔	✔	返回字典里的所有值

用setdefault处理找不到的键

• 在映射对象的方法里，setdefault 可能是比较微妙的一个。我们虽然并不会每次都用它，但是一旦它发挥作用，就可以节省不少次键查询，从而让程序更高效。
• 当字典 d[k] 不能找到正确的键的时候，Python 会抛出异常，这个行为符合 Python 所信奉的“快速失败”哲学，也许每个 Python 程序员都知道可以用 d.get(k, default) 来代替 d[k]，给找不到的键一个默认的返回值。但是要更新某个键对应的值的时候，不管使用 __getitem__ 还是 get 都会不自然，而且效率低。如下示例：

import sys, re

if __name__ == '__main__':
    WORD_RE = re.compile(r'\w+')
    index = {
   }
    with open(sys.argv[0], encoding=