流畅的python读书笔记-第三章Python 字典与集合

字典和集合

标准库里的全部映射类型都是利用 dict 来实现的
只有可散列的数据类型才能用做这些映射里的键(值不用)

可散列

1. 一个对象是可散列的
2. 它的散列值是不变的
3. 对象须要实现 __hash__() 方法
4. 可散列对象还要有 __qe__() 方法

字典推导

DIAL_CODES = [(86, 'China'), (91, 'India'), (1, 'United States'), (62, 'Indonesia') ]

country_code = {country: code        for code, country in DIAL_CODES     }

结果
{'China': 86, 'India': 91, 'United States': 1, 'Indonesia': 62}

常见的映射方法 page137

用setdefault处理找不到的键

##找对应的key,没有的话返回默认值
my_dict = {"name":"longe","age":8}
my_dict.setdefault("namerrr","default")

print(my_dict)

用 setdefault 只须要一次就能够完成整个操做。

defaultdict找不到键返回某种默认值

• 在实例化一个 defaultdict 的时候
• 这个可调用对象会在 getitem 碰到找不到的键的时候被调用，
• 让 getitem 返回某种默认值。

实现方式

• defaultdict 里的 default_factory 只会在__getitem__ 里被调用

好比，dd 是个 defaultdict，k 是个找不到的键，

• dd[k] 这个表达式会调用 default_factory 创造某个默认值，
• dd.get(k) 则会返回 None。

原理
全部这一切背后的功臣实际上是特殊方法 __missing__。
它会在defaultdict 遇到找不到的键的时候调用 default_factory

__missing__这个方法

自定义一个映射类型，更合适的策略实际上是继承collections.UserDict 类

只是为了演示 missing 是如何被dict.__getitem__ 调用的。

class StrKeyDict0(dict):
    def __missing__(self, key):

        if isinstance(key, str):
            raise KeyError(key)
            return self[str(key)]

    def get(self, key, default=None):
        try:
            return self[key]
        except KeyError:
            return default

    def __contains__(self, key):
        return key in self.keys() or str(key) in self.keys()

isinstance(key, str) 测试在上面的__missing__ 中是必需的
可是若是 str(k) 不是一个存在的键，代码就会陷入无限递归。

这是由于 missing 的最后一行中的 self[str(key)] 会调用 __getitem__，
而这个 str(key) 又不存在，因而 __missing__又会被调用。

精简版本

import collections


class StrKeyDict(collections.UserDict):
    def __missing__(self, key):
        if isinstance(key, str):
            raise KeyError(key)
        return self[str(key)]

    def __contains__(self, key):
        return str(key) in self.data

    def __setitem__(self, key, item):
        self.data[str(key)] = item

setitem 会把全部的键都转换成字符串。因为把具体的实现委
托给了 self.data 属性，这个方法写起来也不难

字典的变种

collections.OrderedDict

这个类型在添加键的时候会保持顺序，所以键的迭代次序老是一致
的。

collections.ChainMap

该类型能够容纳数个不一样的映射对象，而后在进行键查找操做的时
候，这些对象会被看成一个总体被逐个查找，直到键被找到为止。

collections.Counter

这个映射类型会给键准备一个整数计数器。每次更新一个键的时候
都会增长这个计数器。

colllections.UserDict

这个类其实就是把标准 dict 用纯 Python 又实现了一遍。
跟 OrderedDict、ChainMap 和 Counter 这些开箱即用的类型不
同，UserDict 是让用户继承写子类的。下面就来试试。

集合论

集合推导

from unicodedata import name

aa = {chr(i) for i in range(32, 256) if 'SIGN' in name(chr(i), '')}
print(aa)

集合的数学运算 page161

字典空间

• 由于 Python 会设法保证大概还有三分之一的表元是空的，因此在快要达

到这个阈值的时候，原有的散列表会被复制到一个更大的空间里面。

散列表原理

1. 为了获取 my_dict[search_key] 背后的值
2. Python 首先会调用hash(search_key) 来计算 search_key 的散列值，
3. 把这个值最低的几位数字看成偏移量
4. 在散列表里查找表元（具体取几位，得看当前散列表的大小
5. 若找到的表元是空的，则抛出 KeyError 异常。
6. 若不是空的，则表元里会有一对 found_key:found_value。
7. 这时候 Python 会检验 search_key == found_key 是否为真，如 果它们相等的话，就会返回found_value。
8. 若是 search_key 和 found_key 不匹配的话，这种状况称为散列 冲突。

原理图

添加新元素和更新现有键值

添加新元素和更新现有键值的操做几乎跟上面同样。
只不过对于前者，在发现空表元的时候会放入一个新元素；
对于后者，在找到相对应的表元后，原表里的值对象会被替换成新值。

优劣

字典浪费存储空间(不过没有几百万对象,内存好几个G不用考虑)
dict 的实现是典型的空间换时间：字典类型有着巨大的内存开销

键的次序取决于添加顺序

当往 dict 里添加新键而又发生散列冲突的时候，新键可能会被安
排存放到另外一个位置。

注意:

• 不管什么时候往字典里添加新的键，Python 解释器均可能作出为字典扩

容的决定。

• 扩容致使的结果就是要新建一个更大的散列表，并把字典里已有的元素添加到新表里。
• 这个过程当中可能会发生新的散列冲突，致使新散列表中键的次序变化。
• 要注意的是，上面提到的这些变化是否会发生以及如何发生，都依赖于字典背后的具体实现，
• 所以你不能很自信地说本身知道背后发生了什么。
• 若是你在迭代一个字典的全部键的过程当中同时对字典进行修改，那么这个循环颇有可

能会跳过一些键——甚至是跳过那些字典中已经有的键。

更新字典的主要使用姿式

• 由此可知，不要对字典同时进行迭代和修改。
• 若是想扫描并修改一个字典，最好分红两步来进行：
• 首先对字典迭代，以得出须要添加的内容，把这些内容放在一个新字典里；
• 迭代结束以后再对原有字典进行更新。

小总结:

• 标准库里的全部映射类型都是利用 dict 来实现
• 只有可散列的数据类型才能用做这些映射里的键(值不用)
• 字典推导
• 用setdefault处理找不到的键
• defaultdict找不到键返回某种默认值
• 底层是 getitem 与__miss__调用实现的
• 字典插入更新原理!!!

其余

• 大多数映射类型都提供了两个很强大的方法：setdefault 和

update。

• setdefault 方法能够用来更新字典里存放的可变值（好比列

表），从而避免了重复的键搜索。

• update 方法则让批量更新成为可能，它能够用来插入新值或者更新已有键值对，它的参数能够是包含(key, value) 这种键值对的可迭代对象，或者关键字参数。