关于Python数据结构中字典的感受,泛映射类型

本文首要内容

可散列类型

泛映射类型

字典

    (一)字典推导式

  (二)管理不存在的键

    (3)字典的变种

集合

炫彩的再商讨

 

python高级——目录

文中代码均位于github上:https://github.com/ampeeg/cnblogs/tree/master/python高级

 

python高端(3)—— 字典和集合(泛映射类型),python映射

本篇重要介绍:常见的字典方法、怎么着管理查不到的键、标准库中 dict
类型的变种、散列表的职业规律等。一下是全部内容:

有关Python数据结构中字典的体验,python数据结构字典

本篇首要介绍:常见的字典方法、怎么样管理查不到的键、标准库中 dict
类型的变种、散列表的劳作规律等。一下是全体内容:

泛映射类型

collections.abc 模块中有 Mapping 和 MutableMapping
那五个抽象基类,它们的成效是为 dict 和别的类似的类型定义格局接口。

亚洲必赢官网 1

行业内部Curry全部映射类型都以选取 dict
来兑现的,它们有个体协会同的限定,即唯有可散列的数据类型才具用做那几个映射里的键。

难点: 什么是可散列的数据类型?

在 python
词汇表(

一经八个目的是可散列的,那么在那一个目的的生命周期中,它的散列值是不改变的,而且以此目的急需完成
__hash__() 方法。此外可散列对象还要有 __eq__()
方法,那样技能跟任何键做比较。假若五个可散列对象是卓殊的,那么它们的散列只分明是1模同样的

基于这几个定义,原子不可变类型(str,bytes和数值类型)都以可散列类型,frozenset
也是可散列的(因为按照其定义,frozenset
里只可以容纳可散列类型),尽管元组内都以可散列类型的话,元组也是可散列的(元组尽管是不行变类型,但假诺它个中的成分是可变类型,那种元组也不可能被以为是不可变的)。

一般来讲,用户自定义的类其他靶子都是可散列的,散列值正是它们的 id()
函数的再次来到值,所以这几个目的在可比的时候都以不等于的。(假使叁个对象实现了
eq
方法,并且在章程中用到了这几个目的的中间意况以来,那么只有当全体那些内部景观都以不可变的意况下,那几个目的才是可散列的。)

遵照这一个概念,字典提供了繁多样构造方法,
那个页面有个例证来证明创造字典的不比方式。

>>> 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([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True

除外那个情势以外,还足以用字典推导的不二等秘书技来建造新 dict。

关于Python数据结构中字典的感受,泛映射类型。字典推导

自 Python贰.七以来,列表推导和生成器表达式的定义就移植到了字典上,从而有了字典推导。字典推导(dictcomp)能够从其余以键值对作为成分的可迭代对象中构建出字典。

比如:

>>> data = [(1, 'a'), (2, 'b'), (3, 'c')]
>>> data_dict = {num: letter for num, letter in data}
>>> data_dict
{1: 'a', 2: 'b', 3: 'c'}

大面积的映射方法

下表为大家显示了 dict、defaultdict 和 OrderedDict 的遍布方法(后二种是
dict 的变种,位于 collections模块内)。

亚洲必赢官网 2

default_factory 并不是一个方法,而是3个可调用对象,它的值 defaultdict
初步化的时候由用户设定。 OrderedDict.popitem()
会移除字典开头插入的因素(先进先出);可选参数 last
假使值为真,则会移除最后插入的要素(后进先出)。用 setdefault
管理找不到的键

当字典 d[k] 不能找到科学的键的时候,Python
会抛出尤其,常常大家都施用d.get(k, default) 来代替
d[k],给找不到的键1个暗中同意值,还足以应用频率更加高的 setdefault

my_dict.setdefault(key, []).append(new_value)
# 等同于
if key not in my_dict:
 my_dict[key] = []
my_dict[key].append(new_value)

那两段代码的意义等同,只可是,后者至少要进行一次键查询,若是不设有,正是贰回,而用
setdefault 只需一回就可以形成总体操作。

这正是说,我们取值的时候,该怎么管理找不到的键呢?

炫人眼目的弹性查询

有时,就算有些键在炫彩里不设有,我们也可望在通过那些键读取值的时候能博取二个私下认可值。有多个门路能帮大家完毕那些目标,一个是通过
defaultdict 这么些类型而不是一般的 dict,另多个是给和睦定义二个 dict
的子类,然后在子类中达成 __missing__ 方法。

defaultdict:管理找不到的键的三个增选

首先大家看下怎样使用 defaultdict :

import collections

index = collections.defaultdict(list)
index[new_key].append(new_value)

此地大家新建了二个字典 index,尽管键 new_key 在 index 中不存在,表达式
index[new_key] 会按以下步骤来操作:

调用 list() 来建立三个新的列表把那些新列表作为值,’new_key’
作为它的键,放入 index 中回到这么些列表的引用。

而以此用来生成默许值的可调用对象存放在名字为 default_factory
的实例属性中。

defaultdict 中的 default_factory 只会在 getitem
里调用,在别的格局中不会时有发生效用。举个例子 index[k] 那个表明式会调用
default_factory 成立的某部私下认可值,而 index.get(k) 则会回来
None。(那是因为万分措施 missing 会在 defaultdict
蒙受找不到的键的时候调用
default_factory,实际上,那天天性全部映射方法都足以帮忙)。

特种方式 missing

具备映射在拍卖找不到的键的时候,都会牵涉到 missing 方法。但基类 dict
并从未提供 那么些法子。不过,如果有三个类承袭了 dict
,然后那几个承继类提供了 missing 方法,那么在 getitem
遇到找不到键的时候,Python 会自动调用它,而不是抛出一个 KeyError 至极。

__missing__ 方法只会被 __getitem__ 调用。提供 missing 方法对 get
或者 __contains__(in 运算符会用到那些主意)那几个方法的是有未有影响。

下边那段代码落成了 StrKeyDict0 类,StrKeyDict0
类在查询的时候把非字符串的键转化为字符串。

class StrKeyDict0(dict): # 继承 dict
 def __missing__(self, key):
 if isinstance(key, str):
  # 如果找不到的键本身就是字符串,抛出 KeyError 
  raise KeyError(key)
 # 如果找不到的键不是字符串,转化为字符串再找一次
 return self[str(key)]
 def get(self, key, default=None):
 # get 方法把查找工作用 self[key] 的形式委托给 __getitem__,这样在宣布查找失败钱,还能通过 __missing__ 再给键一个机会
 try:
  return self[key]
 except KeyError:
  # 如果抛出 KeyError 说明 __missing__ 也失败了,于是返回 default 
  return default
 def __contains__(self, key):
 # 先按传入的键查找,如果没有再把键转为字符串再找一次
 return key in self.keys() or str(key) in self.keys()

contains 方法存在是为着维持壹致性,因为 k in d
那个操作会调用它,但大家从 dict 承继到的 contains
方法不会在找不到键的时候用 missing 方法。

my_dict.keys() 在 Python三 中再次回到值是二个”视图”,”视图”就像一个集聚,而且和字典同样速度异常快。但在
Python2中,my_dict.keys() 重回的是二个列表。 所以 k in my_dict.keys()
操作在 python三中速度赶快,但在 python二 中,管理功效并不高。

假若要自定义叁个辉映类型,合适的政策是承接 collections.UserDict
类。那一个类就是把标准 dict 用 python 又完结了叁次,UserDict
是让用户承接写子类的,革新后的代码如下:

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):
 # 这里可以放心假设所有已经存储的键都是字符串。因此只要在 self.data 上查询就好了
 return str(key) in self.data

 def __setitem__(self, key, item):
 # 这个方法会把所有的键都转化成字符串。
 self.data[str(key)] = item

因为 UserDict 承袭的是 MutableMapping,所以 StrKeyDict
里剩余的那么些炫丽类型都以从 UserDict、MutableMapping 和 Mapping
那些超类承接而来的。

Mapping 中提供了 get 方法,和大家在 StrKeyDict0
中定义的同样,所以大家在此地不需求定义 get 方法。

字典的变种

在 collections 模块中,除了 defaultdict 之外还有此外的照射类型。

collections.OrderedDict collections.ChainMap collections.Counter
不可变的映照类型

难题:规范库中具有的照射类型都以可变的,假诺我们想给用户提供二个不可变的投射类型该怎么管理啊?

从 Python三.叁 初步 types 模块中引进了2个封装类名称为
MappingProxyType。假设给这几个类三个映射,它会回来2个只读的照耀视图(如果原映射做了改观,那些视图的结果页会相应的改换)。比方

>>> from types import MappingProxy Type
>>> d = {1: 'A'}
>>> d_proxy = MappingProxyType(d)
>>> d_proxy
mappingproxy({1: 'A'})
>>> d_proxy[1]
'A'
>>> d_proxy[2] = 'x'
Traceback(most recent call last):
 File "<stdin", line 1, in <module>
TypeError: 'MappingProxy' object does not support item assignment
>>> d[2] = 'B'
>>> d_proxy[2] # d_proxy 是动态的,d 的改动会反馈到它上边
'B'

字典中的散列表

散列表其实是3个疏散数组(总有空白成分的数组叫稀疏数组),在 dict
的散列表中,每个键值都挤占二个表元,每一种表元都有七个部分,2个是对键的引用,另三个是对值的引用。因为有着表元的轻重同等,所以能够由此偏移量来读取某些表元。
python 会设法保证大约有1/3的表元是空的,所以在就要到达那个阈值的时候,原有的散列表会被复制到一个更加大的空中。

设若要把三个对象放入散列表,那么首先要总计那个成分的散列值。
Python内置的 hash() 方法能够用来计算有所的内置类型对象。

万1多少个目的在可比的时候是相等的,那么它们的散列值也无法不相等。例如一==1.0 那么,hash(一) == hash(壹.0)

散列表算法

为了获得 my_dict[search_key] 的值,Python 会首先调用
hash(search_key) 来计算 search_key
的散列值,把那几个值的最低3位当做偏移量在散列表中检索元。若表元为空,抛出
KeyError 相当。若不为空,则表元会有部分 found_key:found_value。
那时候急需校验 search_key == found_key,若是相等,再次来到 found_value。
壹经不相配(散列争执),再在散列表中再取2位,然后管理一下,用处理后的结果作为索引再找表元。
然后再行上边的手续。

取值流程图如下:

亚洲必赢官网 3

加上新值和上述的流水生产线基本1致,只但是对于前者,在意识空表元的时候会放入一个新因素,而对此后者,在找到呼应表元后,原表里的值对象会被替换来新值。

其它,在插入新值是,Python
大概会遵从散列表的拥堵程度来支配是还是不是重新分配内部存款和储蓄器为它扩大体量,要是扩充了散列表的轻重缓急,那散列值所占的位数和当作索引的位数都会随之大增字典的优势和范围

1、键必须是可散列的

可散列对象必要如下:

支撑 hash 函数,并且通过__hash__() 方法所得的散列值不改变协理通过
__eq__() 方法检查评定相等性若 a == b 为真, 则 hash(a) == hash(b) 也为真

二、字典开支巨大

因为字典使用了散列表,而散列表又不能够不是稀疏的,那变成它在半空中上功用低下。

三、键查询快速

dict
的贯彻是首屈一指的空中换时间:字典类型由着英豪的内部存储器开支,但提供了无视数据量大小的火速访问。

4、键的先后决定于增加顺序

当往 dict
里加多新键而又生出散列争执时,新建大概会被安排存放在另3个地点。

5、往字典里加多新键或然会变动已有键的逐1

亚洲必赢官网 ,不论哪天向字典中增多新的键,Python
解释器都只怕做出为字典扩大容积的决定。扩大容积导致的结果正是要新建3个更加大的散列表,并把原本的键加多到新的散列表中,这些历程中也许会产生新的散列争论,导致新散列表中次序发生变化。
之所以,不要对字典同时开始展览迭代和改造。

本篇主要介绍:常见的字典方法、如何管理查不到的键、标准库中 dict
类型的变种、散…

可散列类型

'''
    可散列数据类型(也称可hash)————我理解"可散列"就是"可hash"
    可hash的对象需要实现__hash__方法,返回hash值;另外为了与其他对象比较还需要有__eq__方法

    原子不可变数据类型(str、bytes和数值类型)都是可散列的,可散列对象必须满足下列要求:
    (1)实现了__hash__方法,并且所得到的hash值是不变的
    (2)实现了__eq__方法,用来比较
    (3)若a == b 为真,那么hash(a) == hash(b)也是真
'''


# 创建类Foo,并实现__hash__和__eq__

class Foo:
    def __init__(self, name):
        self.name = name

    def __hash__(self):
        print("正在hash...")
        return hash(self.name)

    def __eq__(self, other):
        print("正在比较...")
        return self.name == other.name

    def __repr__(self):
        return self.name


if __name__ == "__main__":

    f1 = Foo("小李")
    f2 = Foo("小红")
    f3 = Foo("小李")

    s = set([f1, f2, f3])        # 集合实现不重复的原理正好利用了散列表
    print(s)                     # {小红, 小李}
    print( f1 == f3, hash(f1) == hash(f3))      # True True 满足可散列对象的第三个条件
'''
    对于元组来说,只有当一个元组包含的所有元素都是可hash的情况下,它才是可hash的
'''
t1 = (1, 2, 3, [1, 2])   # 元组里的列表的值是可变的,所以不可hash
try:
    print(hash(t1))
except Exception as e:
    print(e)             # unhashable type: 'list'

t2 = (1, 2, 3, (1, 2))   # 元组里的元素都是不可变的,并且第二层元组里面的元素也不可变,所以可hash
print(hash(t2))          # 3896079550788208169

t3 = (1, 2, 3, frozenset([1, 2]))
print(hash(t3))          # -5691000848003037416

 

正文首要内容

可散列类型

泛映射类型

字典

    (一)字典推导式

  (2)管理不存在的键

集合

照耀的再商议

 

python高级——目录

文中代码均位于github上:

 

泛映射类型

泛映射类型

'''
    泛映射类型就是广义上的对应关系,在数学中,我们将集合A对应集合B中的对应法则称为"映射"(Mapping)
    同样,在python里,我们称"键值对"为映射,这其实也是一种对应法则
    如果一个数据类型是映射,那么它肯定属于collections.abc.Mapping,可使用isinstance函数测试

    PS: 字典是 Python 语言中唯一的映射类型。映射类型对象里哈希值(键) 和指向的对象(值)是一对多的关系。
'''

from collections import abc

# 我们测试一些常用的类型是不是映射
if __name__ == "__main__":
    print(isinstance({}, abc.Mapping))      # True   字典是典型的键值对
    print(isinstance([1, 2], abc.Mapping))  # False  列表是序列
    print(isinstance((1, 2), abc.Mapping))  # False  元组是序列
    print(isinstance('adfasfd', abc.Mapping))  # False  字符串也是序列
'''
   大家可以查看_collections_abc.py源代码,里面基本的类型包含:
    ["Awaitable", "Coroutine", "AsyncIterable", "AsyncIterator",
    "Hashable", "Iterable", "Iterator", "Generator",
    "Sized", "Container", "Callable",
     "Set", "MutableSet",
     "Mapping", "MutableMapping",
     "MappingView", "KeysView", "ItemsView", "ValuesView",
     "Sequence", "MutableSequence",
    "ByteString",
    ]
'''

 

'''
    如果我们自己想定义一个映射类型的对象,那么必须实现__getitem__、__iter__、__len__方法

    PS:关于该部分的原理,本人暂未查看说明文档,毕竟现实中几乎不可能自定义映射;有兴趣的同志可深入钻研。
'''


class Foo(abc.Mapping):
    def __init__(self, name):
        self.name = name

    def __getitem__(self, item):
        return self.name

    def __iter__(self):
        return iter(str(self.name))

    def __len__(self):
        return len(self.name)


print(isinstance(Foo("123"), abc.Mapping))      # True

 

可散列类型

'''
    可散列数据类型(也称可hash)————我理解"可散列"就是"可hash"
    可hash的对象需要实现__hash__方法,返回hash值;另外为了与其他对象比较还需要有__eq__方法

    原子不可变数据类型(str、bytes和数值类型)都是可散列的,可散列对象必须满足下列要求:
    (1)实现了__hash__方法,并且所得到的hash值是不变的
    (2)实现了__eq__方法,用来比较
    (3)若a == b 为真,那么hash(a) == hash(b)也是真
'''


# 创建类Foo,并实现__hash__和__eq__

class Foo:
    def __init__(self, name):
        self.name = name

    def __hash__(self):
        print("正在hash...")
        return hash(self.name)

    def __eq__(self, other):
        print("正在比较...")
        return self.name == other.name

    def __repr__(self):
        return self.name


if __name__ == "__main__":

    f1 = Foo("小李")
    f2 = Foo("小红")
    f3 = Foo("小李")

    s = set([f1, f2, f3])        # 集合实现不重复的原理正好利用了散列表
    print(s)                     # {小红, 小李}
    print( f1 == f3, hash(f1) == hash(f3))      # True True 满足可散列对象的第三个条件
'''
    对于元组来说,只有当一个元组包含的所有元素都是可hash的情况下,它才是可hash的
'''
t1 = (1, 2, 3, [1, 2])   # 元组里的列表的值是可变的,所以不可hash
try:
    print(hash(t1))
except Exception as e:
    print(e)             # unhashable type: 'list'

t2 = (1, 2, 3, (1, 2))   # 元组里的元素都是不可变的,并且第二层元组里面的元素也不可变,所以可hash
print(hash(t2))          # 3896079550788208169

t3 = (1, 2, 3, frozenset([1, 2]))
print(hash(t3))          # -5691000848003037416

 

collections.abc 模块中有 Mapping 和 MutableMapping
那四个抽象基类,它们的效益是为 dict 和别的类似的类型定义方式接口。

字典

'''
    字典是python内置类型中唯一的映射,先看创建字典的几种方法

    1、对象创建
    2、大括号
    3、zip
'''

if __name__ == "__main__":
    # 1、利用实例化对象的方法创建
    a = dict(key1=1, key2=2, all=[1, 2, 3])
    b = dict([('key3', 3), ('key4', 4)])
    c = dict({"key5": 5, "key6": 6})

    print("a:", a)     # a: {'key1': 1, 'all': [1, 2, 3], 'key2': 2}
    print("b:", b)     # b: {'key3': 3, 'key4': 4}
    print("c:", c)     # c: {'key6': 6, 'key5': 5}

    # 2、直接使用大括号
    d = {"key7": 7, "key8": 8}
    print("d:", d)     # d: {'key8': 8, 'key7': 7}

    # 3、使用zip
    e = dict(zip(("key9", "key10", "key11"), [9, 10, 11]))
    print("e:", e)     # e: {'key11': 11, 'key10': 10, 'key9': 9}

(壹)字典推导式

 

'''
    字典推导式:字典推导式的创建方法同列表推导式类似

    以下直接引用《流畅的python》中的例子
'''


if __name__ == "__main__":
    DIAL_CODES = [
        (86, 'China'),
        (91, 'India'),
        (1, 'United States'),
        (62, 'Indonesia'),
        (55, 'Brazil'),
        (92, 'Pakistan'),
        (880, 'Bangladesh'),
        (234, 'Nigeria'),
        (7, 'Russia'),
        (81, 'Japan'),
    ]

    country_code = {country: code for code, country in DIAL_CODES}
    print(country_code)   # {'Russia': 7, 'Indonesia': 62, 'Brazil': 55, 'China': 86, 'India': 91, 'Bangladesh': 880, 'Pakistan': 92, 'United States': 1, 'Nigeria': 234, 'Japan': 81}

    code_upper = {code: country.upper() for country, code in country_code.items() if code < 66}
    print(code_upper)     # {1: 'UNITED STATES', 7: 'RUSSIA', 62: 'INDONESIA', 55: 'BRAZIL'}
(2)处理不存在的键
'''
    处理找不到的键

    在实际场景中,当使用d[key]的方法查找数据的时候,如果找不到该键,python会抛出KeyError异常;
    如果是取值操作,可以使用d.get(key, default)来解决,可以给找不到的键一个默认的值
    但是如果要给更新某个不存在键对应的值的时候,就稍显麻烦了,可以使用以下方法解决:
        1、用setdefault处理dict找不到的键
        2、使用defaultdict对象
        3、__missing__方法
'''

class Foo:
    def __init__(self, name=None):
        self.name = name

    def __repr__(self):
        return str(self.name)

    def setattr(self, key, value):
        self.__setattr__(key, value)
        return self


if __name__ == "__main__":
    d1 = {}
    print(d1.get("key", "default"))   # default   使用d.get(key, default)的方法取值


    # 1、用setdefault处理dict找不到的键
    d2 = {}
    d2.setdefault("key", [x for x in "adfaf"])  # setdefault虽然是set名字,但是是取值操作,只有当键不存在时才进行赋值,并返回该值
    l = d2.setdefault("key", [])
    print(l)                                    # ['a', 'd', 'f', 'a', 'f']

    d2.setdefault("key2", []).extend([1, 2, 3]) # 返回空列表,所以可在后面直接使用方法extend
    print(d2)                                   # {'key': 'default', 'key2': [1, 2, 3]}

    # 2、使用defaultdict对象
    #  在python中,还有一些dict的变种类型,defaultdict为其中一种,位于collections中
    from collections import defaultdict

    dic = defaultdict(list)                    # 将list的构造方法作为default_factory(只有__getitem__找不到值时调用)
    dic["key"].extend([1, 2, 3])               # dic中不含有"key"键,此时default_factory会被调用,创造一个空列表,并连接[1, 2, 3]
    print(dic["key"])                # [1, 2, 3]

    dic = defaultdict(Foo)           # 将Foo的构造方法作为default_factory创建一个defaultdict
    print(dic["key"].setattr("name", "default"))                # default

    # 3、__missing__方法
    # 所有的映射类型在找不到键的时候,都会牵扯到__missing__方法;如果在__getitem__找不到键的时候,python就会自动调用它
    # 另外,__missing__方法只会被getitem调用,对get或者__contains__没有影响

    class My_dict(dict):
        def __missing__(self, key):
            print("正在调用__missing__...")

    mdict = My_dict(one=1, two=2, three=3)
    print(mdict)     # {'two': 2, 'three': 3, 'one': 1}
    mdict["key"]     # 正在调用__missing__...
(3)字典的变种
'''
    在python中虽然只有dict为映射类型,但是dict有很多变种,上面defaultdict就是,除此之外还有:

    (1)OrderedDict: 有顺序的字典
     (2) ChainMap: 可以容纳数个不同的映射对象
     (3) Counter:  给键准备一个整数计数器,每次更新键的时候会增加该计数器
    (4)UserDict:  将标准的dict用python实现了一遍
'''


from collections import OrderedDict, ChainMap, Counter, UserDict

if __name__ == "__main__":
    # 1、OrderedDict
    d = OrderedDict()
    d['one'] = 1
    d['two'] = 2
    d['three'] = 3
    for _ in range(10):
        print("%d次:" % _)
        for k, v in d.items():
            print("**", k, v)        # OrderedDict迭代的时候的顺序总是跟插入顺序一致


    # 2、ChainMap

    pylookup = ChainMap(d, globals())   # d和globals()都是映射类型,ChainMap会将其组合
    for v, k in pylookup.items():
        print(v, k)

    # 3、Counter
    ct = Counter('asfjlajslfjals')
    print(ct)      # Counter({'j': 3, 'l': 3, 's': 3, 'a': 3, 'f': 2})
                   # 存储的是每个字母出现的次数
    ct.update('jjjjjjjjlllllllll')
    print(ct)      # # Counter({'l': 12, 'j': 11, 's': 3, 'a': 3, 'f': 2})

    import random
    ct2 = Counter([random.randrange(1, 5) for _ in range(100)])   # 列表推导式创建Counter
    print(ct2)     # Counter({1: 30, 2: 24, 4: 24, 3: 22})

    ct3 = Counter((random.randrange(1, 5) for _ in range(100)))   # 生成器创建Counter
    print(ct3)      # Counter({2: 40, 3: 23, 4: 20, 1: 17})

    class Foo:
        def __init__(self, num):
            self.l = [random.randrange(1, 5) for _ in range(num)]

        def __iter__(self):
            return iter(self.l)

    ct4 = Counter(Foo(100))            # 可迭代对象创建Counter
    print(ct4)      # Counter({2: 31, 3: 25, 4: 25, 1: 19})

    # 4、UserDict
    # 创建自定义的映射类型,一般以UserDict为基类

    class My_dict(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):
            print("调用__setitem__。。。")
            self.data[str(key)] = item

    mdict = My_dict()
    mdict["one"] = 1      # 调用__setitem__。。。(下同)
    mdict["two"] = 2
    mdict["three"] = 3
    print(mdict)   # {'three': 3, 'one': 1, 'two': 2}

 

泛映射类型

'''
    泛映射类型就是广义上的对应关系,在数学中,我们将集合A对应集合B中的对应法则称为"映射"(Mapping)
    同样,在python里,我们称"键值对"为映射,这其实也是一种对应法则
    如果一个数据类型是映射,那么它肯定属于collections.abc.Mapping,可使用isinstance函数测试

    PS: 字典是 Python 语言中唯一的映射类型。映射类型对象里哈希值(键) 和指向的对象(值)是一对多的关系。
'''

from collections import abc

# 我们测试一些常用的类型是不是映射
if __name__ == "__main__":
    print(isinstance({}, abc.Mapping))      # True   字典是典型的键值对
    print(isinstance([1, 2], abc.Mapping))  # False  列表是序列
    print(isinstance((1, 2), abc.Mapping))  # False  元组是序列
    print(isinstance('adfasfd', abc.Mapping))  # False  字符串也是序列
'''
   大家可以查看_collections_abc.py源代码,里面基本的类型包含:
    ["Awaitable", "Coroutine", "AsyncIterable", "AsyncIterator",
    "Hashable", "Iterable", "Iterator", "Generator",
    "Sized", "Container", "Callable",
     "Set", "MutableSet",
     "Mapping", "MutableMapping",
     "MappingView", "KeysView", "ItemsView", "ValuesView",
     "Sequence", "MutableSequence",
    "ByteString",
    ]
'''

 

'''
    如果我们自己想定义一个映射类型的对象,那么必须实现__getitem__、__iter__、__len__方法

    PS:关于该部分的原理,本人暂未查看说明文档,毕竟现实中几乎不可能自定义映射;有兴趣的同志可深入钻研。
'''


class Foo(abc.Mapping):
    def __init__(self, name):
        self.name = name

    def __getitem__(self, item):
        return self.name

    def __iter__(self):
        return iter(str(self.name))

    def __len__(self):
        return len(self.name)


print(isinstance(Foo("123"), abc.Mapping))      # True

 

亚洲必赢官网 4

集合

'''
    集合对于很多人并不陌生,中学阶段就已经接触过。集合具有:
    (1)确定性:每一个对象都能确定是不是某一集合的元素,没有确定性就不能成为集合
    (2)互异性:集合中任意两个元素都是不同的对象
    (3)无序性:{a,b,c}{c,b,a}是同一个集合

    在python中,set中的元素必须是可散列的,但set本身不可散列(但是frosenset是可散列的)


    另外:set实现了很多基础运算
    &(交集)、|(并集)、-(差集)
'''


if __name__ == "__main__":
    # 创建集合
    s1 = set([1, 2, 3])
    s2 = {1, 2, 3, 4}
    print(s1, s2)     # {1, 2, 3} {1, 2, 3, 4}

    # 集合推导式
    s3 = {x**2 for x in range(10)}
    print(s3)         # {0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

 

set的操作方法很多,本文截自<流畅的python>一书,如下三个表:

表一:集合的数学方法

 

表二:集结的可比运算

 

表三:集合的其余运算

 

字典

'''
    字典是python内置类型中唯一的映射,先看创建字典的几种方法

    1、对象创建
    2、大括号
    3、zip
'''

if __name__ == "__main__":
    # 1、利用实例化对象的方法创建
    a = dict(key1=1, key2=2, all=[1, 2, 3])
    b = dict([('key3', 3), ('key4', 4)])
    c = dict({"key5": 5, "key6": 6})

    print("a:", a)     # a: {'key1': 1, 'all': [1, 2, 3], 'key2': 2}
    print("b:", b)     # b: {'key3': 3, 'key4': 4}
    print("c:", c)     # c: {'key6': 6, 'key5': 5}

    # 2、直接使用大括号
    d = {"key7": 7, "key8": 8}
    print("d:", d)     # d: {'key8': 8, 'key7': 7}

    # 3、使用zip
    e = dict(zip(("key9", "key10", "key11"), [9, 10, 11]))
    print("e:", e)     # e: {'key11': 11, 'key10': 10, 'key9': 9}
'''
    字典推导式:字典推导式的创建方法同列表推导式类似

    以下直接引用《流畅的python》中的例子
'''


if __name__ == "__main__":
    DIAL_CODES = [
        (86, 'China'),
        (91, 'India'),
        (1, 'United States'),
        (62, 'Indonesia'),
        (55, 'Brazil'),
        (92, 'Pakistan'),
        (880, 'Bangladesh'),
        (234, 'Nigeria'),
        (7, 'Russia'),
        (81, 'Japan'),
    ]

    country_code = {country: code for code, country in DIAL_CODES}
    print(country_code)   # {'Russia': 7, 'Indonesia': 62, 'Brazil': 55, 'China': 86, 'India': 91, 'Bangladesh': 880, 'Pakistan': 92, 'United States': 1, 'Nigeria': 234, 'Japan': 81}

    code_upper = {code: country.upper() for country, code in country_code.items() if code < 66}
    print(code_upper)     # {1: 'UNITED STATES', 7: 'RUSSIA', 62: 'INDONESIA', 55: 'BRAZIL'}
'''
    处理找不到的键

    在实际场景中,当使用d[key]的方法查找数据的时候,如果找不到该键,python会抛出KeyError异常;
    如果是取值操作,可以使用d.get(key, default)来解决,可以给找不到的键一个默认的值
    但是如果要给更新某个不存在键对应的值的时候,就稍显麻烦了,可以使用以下方法解决:
        1、用setdefault处理dict找不到的键
        2、使用defaultdict对象
        3、__missing__方法
'''

class Foo:
    def __init__(self, name=None):
        self.name = name

    def __repr__(self):
        return str(self.name)

    def setattr(self, key, value):
        self.__setattr__(key, value)
        return self


if __name__ == "__main__":
    d1 = {}
    print(d1.get("key", "default"))   # default   使用d.get(key, default)的方法取值


    # 1、用setdefault处理dict找不到的键
    d2 = {}
    d2.setdefault("key", [x for x in "adfaf"])  # setdefault虽然是set名字,但是是取值操作,只有当键不存在时才进行赋值,并返回该值
    l = d2.setdefault("key", [])
    print(l)                                    # ['a', 'd', 'f', 'a', 'f']

    d2.setdefault("key2", []).extend([1, 2, 3]) # 返回空列表,所以可在后面直接使用方法extend
    print(d2)                                   # {'key': 'default', 'key2': [1, 2, 3]}

    # 2、使用defaultdict对象
    #  在python中,还有一些dict的变种类型,defaultdict为其中一种,位于collections中
    from collections import defaultdict

    dic = defaultdict(list)                    # 将list的构造方法作为default_factory(只有__getitem__找不到值时调用)
    dic["key"].extend([1, 2, 3])               # dic中不含有"key"键,此时default_factory会被调用,创造一个空列表,并连接[1, 2, 3]
    print(dic["key"])                # [1, 2, 3]

    dic = defaultdict(Foo)           # 将Foo的构造方法作为default_factory创建一个defaultdict
    print(dic["key"].setattr("name", "default"))                # default

    # 3、__missing__方法
    # 所有的映射类型在找不到键的时候,都会牵扯到__missing__方法;如果在__getitem__找不到键的时候,python就会自动调用它
    # 另外,__missing__方法只会被getitem调用,对get或者__contains__没有影响

    class My_dict(dict):
        def __missing__(self, key):
            print("正在调用__missing__...")

    mdict = My_dict(one=1, two=2, three=3)
    print(mdict)     # {'two': 2, 'three': 3, 'one': 1}
    mdict["key"]     # 正在调用__missing__...

 

职业库里全数映射类型都以使用 dict
来完成的,它们有个共同的限制,即只有可散列的数据类型才干用做这几个映射里的键。

酷炫的再钻探 

'''
    python标准库里面的映射类型都是可变的,有时候需要使用不可变的映射,从python3.3开始,types模块中引入了
    MappingProxyType类,如果给这个类一个映射,那么它会返回这个映射的试图,该试图是动态的,原映射如果有改动
    可立即通过这个试图观察到,但是这个试图无法对该映射进行修改。
'''
from types import MappingProxyType

if __name__ == "__main__":
    d = {'one':1, 'two':2, 'three':3}
    d_proxy = MappingProxyType(d)
    print(d_proxy)     # {'three': 3, 'two': 2, 'one': 1}
    print(d_proxy['one'])  # 1
    for k, v in d_proxy.items():
        print(k, v)

    #d_proxy['four'] = 4   # 报错:TypeError: 'mappingproxy' object does not support item assignment
    d['four'] = 4
    print(d_proxy)     # {'two': 2, 'three': 3, 'four': 4, 'one': 1}

 

  别的,《流畅的python》77页到80页对散列表算法以及字典、会集的频率、平时需求留意的难题张开了相比较详细的斟酌,建议严厉并风乐趣的同事阅读,该有的剧情对驾驭字典类型无比有益,场景中捉摸不透的莫明其妙的bug可能会消除。

   主要的定论摘录如下:

  (壹)键必须是可散列的

  (二)字典在内部存款和储蓄器上的支付巨大

  (三)键查询快捷

  (四)键的先后取决于增添顺序

  (伍)往字典里增多新键也许会变动已有键的顺序

 

python高档种类小说目录

python高级——目录

 

 

 

字典和聚合(泛映射类型),python映射 本文主要内容 可散列类型 泛映射类型
字典 (一)字典推导式 (二)管理不存在…

主题素材: 什么是可散列的数据类型?

python高端体系作品目录

python高级——目录

 

 

 

在 python
词汇表(

要是2个对象是可散列的,那么在那几个目标的生命周期中,它的散列值是不变的,而且那几个目标急需贯彻
__hash__() 方法。其余可散列对象还要有 __eq__()
方法,这样才干跟其他键做相比较。假若多少个可散列对象是相等的,那么它们的散列只肯定是壹致的

听大人说那几个定义,原子不可变类型(str,bytes和数值类型)都是可散列类型,frozenset
也是可散列的(因为依据其定义,frozenset
里只好容纳可散列类型),假若元组内都以可散列类型的话,元组也是可散列的(元组尽管是不足变类型,但要是它当中的因素是可变类型,那种元组也没办法被以为是不可变的)。

一般来讲,用户自定义的类型的对象都是可散列的,散列值正是它们的 id()
函数的再次来到值,所以那么些目的在可比的时候都以不等于的。(如若一个对象完结了
eq
方法,并且在点子中用到了这几个目的的个中意况以来,那么唯有当有着那几个内部景观都以不可变的气象下,那么些目的才是可散列的。)

基于那些概念,字典提供了很各个构造方法,
那个页面有个例证而言明创制字典的比不上如式。

>>> 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([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True

除此而外这一个措施以外,还足以用字典推导的不二秘技来建造新 dict。

字典推导

自 Python2.七以来,列表推导和生成器表明式的概念就移植到了字典上,从而有了字典推导。字典推导(dictcomp)可以从其余以键值对作为成分的可迭代对象中创设出字典。

比如:

>>> data = [(1, 'a'), (2, 'b'), (3, 'c')]
>>> data_dict = {num: letter for num, letter in data}
>>> data_dict
{1: 'a', 2: 'b', 3: 'c'}

广阔的投射方法

下表为大家来得了 dict、defaultdict 和 OrderedDict 的宽泛格局(后三种是
dict 的变种,位于 collections模块内)。

亚洲必赢官网 5

default_factory 并不是五个方式,而是一个可调用对象,它的值 defaultdict
早先化的时候由用户设定。 OrderedDict.popitem()
会移除字典初叶插入的要素(先进先出);可选参数 last
假设值为真,则会移除最终插入的因素(后进先出)。用 setdefault
处理找不到的键

当字典 d[k] 无法找到准确的键的时候,Python
会抛出至极,经常我们都施用d.get(k, default) 来代替
d[k],给找不到的键2个暗中同意值,还足以行使效用越来越高的 setdefault

my_dict.setdefault(key, []).append(new_value)
# 等同于
if key not in my_dict:
 my_dict[key] = []
my_dict[key].append(new_value)

那两段代码的效果等同,只可是,后者至少要实行四回键查询,假使不设有,就是2次,而用
setdefault 只需二次就足以做到全套操作。

那么,我们取值的时候,该怎么管理找不到的键呢?

辉映的弹性查询

神蹟,固然有些键在光彩夺目里不存在,大家也愿目的在于经过那几个键读取值的时候能获得三个暗许值。有五个门路能帮大家完成那么些目标,多个是经过
defaultdict 那几个项目而不是惯常的 dict,另二个是给协和定义2个 dict
的子类,然后在子类中得以落成 __missing__ 方法。

defaultdict:管理找不到的键的一个取舍

第3我们看下怎么着使用 defaultdict :

import collections

index = collections.defaultdict(list)
index[new_key].append(new_value)

此地我们新建了2个字典 index,假如键 new_key 在 index 中不存在,表明式
index[new_key] 会按以下步骤来操作:

调用 list() 来建立3个新的列表把那一个新列表作为值,’new_key’
作为它的键,放入 index 中回到那一个列表的引用。

而那几个用来生成暗中认可值的可调用对象存放在名称为 default_factory
的实例属性中。

defaultdict 中的 default_factory 只会在 getitem
里调用,在其他措施中不会发出功能。比方 index[k] 这几个表明式会调用
default_factory 创制的某部暗中同意值,而 index.get(k) 则会回去
None。(那是因为拾叁分措施 missing 会在 defaultdict
碰到找不到的键的时候调用
default_factory,实际上,那性子情全体映射方法都能够帮衬)。

离奇情势 missing

具有映射在拍卖找不到的键的时候,都会推搡到 missing 方法。但基类 dict
并没有提供 那个艺术。但是,假诺有三个类承袭了 dict
,然后这几个承继类提供了 missing 方法,那么在 getitem
蒙受找不到键的时候,Python 会自动调用它,而不是抛出叁个 KeyError 十分。

__missing__ 方法只会被 __getitem__ 调用。提供 missing 方法对 get
或者 __contains__(in 运算符会用到那个法子)这个艺术的是有未有影响。

上边那段代码完毕了 StrKeyDict0 类,StrKeyDict0
类在查询的时候把非字符串的键转化为字符串。

class StrKeyDict0(dict): # 继承 dict
 def __missing__(self, key):
 if isinstance(key, str):
  # 如果找不到的键本身就是字符串,抛出 KeyError 
  raise KeyError(key)
 # 如果找不到的键不是字符串,转化为字符串再找一次
 return self[str(key)]
 def get(self, key, default=None):
 # get 方法把查找工作用 self[key] 的形式委托给 __getitem__,这样在宣布查找失败钱,还能通过 __missing__ 再给键一个机会
 try:
  return self[key]
 except KeyError:
  # 如果抛出 KeyError 说明 __missing__ 也失败了,于是返回 default 
  return default
 def __contains__(self, key):
 # 先按传入的键查找,如果没有再把键转为字符串再找一次
 return key in self.keys() or str(key) in self.keys()

contains 方法存在是为了有限支撑1致性,因为 k in d
那一个操作会调用它,但大家从 dict 承接到的 contains
方法不会在找不到键的时候用 missing 方法。

my_dict.keys() 在 Python三 中重回值是一个”视图”,”视图”就像3个聚焦,而且和字典同样速度非常的慢。但在
Python2中,my_dict.keys() 重返的是三个列表。 所以 k in my_dict.keys()
操作在 python3中速度高速,但在 python贰 中,管理效能并不高。

只要要自定义叁个辉映类型,合适的国策是承接 collections.UserDict
类。那几个类就是把标准 dict 用 python 又完结了1回,UserDict
是让用户承袭写子类的,革新后的代码如下:

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):
 # 这里可以放心假设所有已经存储的键都是字符串。因此只要在 self.data 上查询就好了
 return str(key) in self.data

 def __setitem__(self, key, item):
 # 这个方法会把所有的键都转化成字符串。
 self.data[str(key)] = item

因为 UserDict 承袭的是 MutableMapping,所以 StrKeyDict
里剩余的那个绚烂类型都是从 UserDict、MutableMapping 和 Mapping
那么些超类承袭而来的。

Mapping 中提供了 get 方法,和大家在 StrKeyDict0
中定义的一样,所以大家在此处不须求定义 get 方法。

字典的变种

在 collections 模块中,除了 defaultdict 之外还有别的的照射类型。

collections.OrderedDict collections.ChainMap collections.Counter
不可变的炫目类型

标题:标准库中有着的炫人眼目类型都以可变的,借使我们想给用户提供二个不可变的映射类型该怎么管理呢?

从 Python三.3 开首 types 模块中引进了1个封装类名称为
MappingProxyType。假诺给那么些类叁个辉映,它会回到二个只读的照耀视图(假如原映射做了改观,那些视图的结果页会相应的改观)。例如

>>> from types import MappingProxy Type
>>> d = {1: 'A'}
>>> d_proxy = MappingProxyType(d)
>>> d_proxy
mappingproxy({1: 'A'})
>>> d_proxy[1]
'A'
>>> d_proxy[2] = 'x'
Traceback(most recent call last):
 File "<stdin", line 1, in <module>
TypeError: 'MappingProxy' object does not support item assignment
>>> d[2] = 'B'
>>> d_proxy[2] # d_proxy 是动态的,d 的改动会反馈到它上边
'B'

字典中的散列表

散列表其实是3个疏散数组(总有空白元素的数组叫稀疏数组),在 dict
的散列表中,每一种键值都挤占八个表元,每一种表元都有八个部分,二个是对键的引用,另贰个是对值的引用。因为全部表元的轻重同样,所以能够通过偏移量来读取某些表元。
python 会设法保证大约有1/三的表元是空的,所以在将在达到这几个阈值的时候,原有的散列表会被复制到三个越来越大的上空。

若是要把叁个目的放入散列表,那么首先要计算那么些因素的散列值。
Python内置的 hash() 方法能够用来总括有所的内置类型对象。

假若多个对象在比较的时候是相等的,那么它们的散列值也非得相等。比如一==一.0 那么,hash(1) == hash(1.0)

散列表算法

为了获得 my_dict[search_key] 的值,Python 会首先调用
hash(search_key) 来计算 search_key
的散列值,把那么些值的最低四人当做偏移量在散列表中找找元。若表元为空,抛出
KeyError 十分。若不为空,则表元会有一些 found_key:found_value。
此刻要求校验 search_key == found_key,若是相等,重回 found_value。
设若不匹配(散列抵触),再在散列表中再取几个人,然后处理一下,用管理后的结果作为索引再找表元。
然后再也上面的步调。

取值流程图如下:

亚洲必赢官网 6

加上新值和上述的流程基本1致,只但是对于前者,在发掘空表元的时候会放入3个新因素,而对于后人,在找到相应表元后,原表里的值对象会被替换来新值。

别的,在插入新值是,Python
只怕会依据散列表的沸反盈天程度来调节是或不是重新分配内部存款和储蓄器为它扩大体量,假使扩展了散列表的大大小小,那散列值所占的位数和当作索引的位数都会跟着增加字典的优势和限量

一、键必须是可散列的

可散列对象须求如下:

支撑 hash 函数,并且经过__hash__() 方法所得的散列值不改变支持通过
__eq__() 方法检查评定相等性若 a == b 为真, 则 hash(a) == hash(b) 也为真

2、字典费用巨大

因为字典使用了散列表,而散列表又必须是稀疏的,那产生它在半空中上功能低下。

叁、键查询神速

dict
的贯彻是独占鳌头的上空换时间:字典类型由着巨大的内部存款和储蓄器花费,但提供了无视数据量大小的快捷访问。

四、键的次第决定于增多顺序

当往 dict
里增添新键而又发生散列争执时,新建大概会被布署存放在另一个职分。

5、往字典里加多新键恐怕会转移已有键的相继

不论是几时向字典中加多新的键,Python
解释器都大概做出为字典扩大容积的支配。扩大体积导致的结果正是要新建二个越来越大的散列表,并把本来的键增加到新的散列表中,这一个进程中可能会时有发生新的散列争辩,导致新散列表中次序发生变化。
为此,不要对字典同时进行迭代和退换。

您恐怕感兴趣的稿子:

  • Python数据结构与算法之广大的分配排序法示例【桶排序与基数排序】
  • Python数据结构与算法之图的广度优先与深度优先寻觅算法示例
  • Python数据结构与算法之使用队列搞定猫猫钓鱼难题
  • Python数据结构之栈、队列的兑当代码分享
  • Python数据结构之顺序表的落成代码示例
  • Python数据结构与算法之列表(链表,linked
    list)简单完毕
  • Python数据结构与算法之链表定义与用法实例详解【单链表、循环链表】
  • Python中顺序表的贯彻轻易代码分享
网站地图xml地图