字典和汇聚,python数据结构字典

正文首要内容

可散列类型

泛映射类型

字典和汇聚,python数据结构字典。字典

    (一)字典推导式

  (二)管理不设有的键

    (三)字典的变种

集合

炫丽的再谈谈

 

python高级——目录

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

 

python高档(三)—— 字典和聚众(泛映射类型),python映射

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

关于Python数据结构中字典的感受,python数据结构字典

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

泛映射类型

collections.abc 模块中有 Mapping 和 MutableMapping
那八个抽象基类,它们的法力是为 dict 和其余类似的类型定义方式接口。

美高梅开户网址 1

行业内部Curry所有映射类型都以利用 dict
来兑现的,它们有个共同的限量,即只有可散列的数据类型才具用做那么些映射里的键。

题目: 什么是可散列的数据类型?

在 python
词汇表(

若是1个目的是可散列的,那么在这几个目的的生命周期中,它的散列值是不改变的,而且以此目标急需贯彻
__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。

字典推导

自 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 并不是二个措施,而是一个可调用对象,它的值 defaultdict
初步化的时候由用户设定。 OrderedDict.popitem()
会移除字典发轫插入的成分(先进先出);可选参数 last
假如值为真,则会移除最终插入的因素(后进先出)。用 setdefault
处理找不到的键

当字典 d[k] 无法找到科学的键的时候,Python
会抛出十一分,日常我们都使用d.get(k, default) 来代替
d[k],给找不到的键三个暗中认可值,还足以采用成效越来越高的 setdefault

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

那两段代码的机能同样,只但是,后者至少要拓展两回键查询,假使不存在,便是3回,而用
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() 在 Python3 中重临值是三个”视图”,”视图”就如三个会晤,而且和字典同样速度异常的快。但在
Python第22中学,my_dict.keys() 再次回到的是三个列表。 所以 k in my_dict.keys()
操作在 python三中速度高速,但在 python2 中,管理功效并不高。

假定要自定义二个辉映类型,合适的战略是承继 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 模块中引进了贰个封装类名字为
MappingProxyType。假设给这么些类3个辉映,它会回去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'

字典中的散列表

散列表其实是四个疏散数组(总有空白成分的数组叫稀疏数组),在 dict
的散列表中,各种键值都占领1个表元,各种表元都有七个部分,二个是对键的引用,另三个是对值的引用。因为兼具表元的深浅相同,所以可以透过偏移量来读取有个别表元。
python 会设法保证大概有1/叁的表元是空的,所以在将要达到那几个阈值的时候,原有的散列表会被复制到一个更加大的半空中。

只要要把贰个对象放入散列表,那么首先要总括这一个成分的散列值。
Python内置的 hash() 方法能够用来总括有所的放权类型对象。

假定八个目标在可比的时候是十二分的,那么它们的散列值也非得相等。例如壹==一.0 那么,hash(壹) == hash(一.0)

散列表算法

为了获得 my_dict[search_key] 的值,Python 会首先调用
hash(search_key) 来计算 search_key
的散列值,把那个值的最低2人当做偏移量在散列表中研究元。若表元为空,抛出
KeyError 万分。若不为空,则表元会有一些 found_key:found_value。
那儿需求校验 search_key == found_key,如若相等,重临 found_value。
举个例子不合作(散列争持),再在散列表中再取肆位,然后管理一下,用管理后的结果作为索引再找表元。
然后再也上边的步调。

取值流程图如下:

美高梅开户网址 3

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

除此以外,在插入新值是,Python
恐怕会安分守纪散列表的拥堵程度来决定是或不是重新分配内部存款和储蓄器为它扩大容积,固然扩大了散列表的大小,那散列值所占的位数和当作索引的位数都会跟着增加字典的优势和界定

1、键必须是可散列的

可散列对象须要如下:

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

二、字典开支巨大

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

三、键查询快速

dict
的得以完成是数壹数贰的长空换时间:字典类型由着英雄的内部存款和储蓄器开支,但提供了无视数据量大小的飞快访问。

四、键的次序决定于增添顺序

当往 dict
里加多新键而又发生散列争辩时,新建或许会被布署存放在另二个地方。

五、往字典里加多新键大概会转移已有键的逐一

随意哪一天向字典中增加新的键,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

 

正文主要内容

可散列类型

泛映射类型

字典

    (一)字典推导式

  (二)管理不存在的键

集合

辉映的再谈谈

 

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}

(1)字典推导式

 

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

    以下直接引用《流畅的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__...

 

正规Curry全体映射类型都以应用 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》7柒页到80页对散列表算法以及字典、群集的效能、日常亟待专注的主题素材实行了对比详细的探赜索隐,提议严俊并有意思味的同人阅读,该片段内容对了然字典类型无比有益,场景中捉摸不透的莫名其妙的bug大概会消除。

   首要的结论摘录如下:

  (1)键必须是可散列的

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

  (叁)键查询神速

  (4)键的先后取决于增加顺序

  (5)往字典里增加新键可能会变动已有键的依次

 

python高等种类作品目录

python高级——目录

 

 

 

字典和聚合(泛映射类型),python映射 本文重要内容 可散列类型 泛映射类型
字典 (1)字典推导式 (贰)管理不设有…

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

python高端连串小说目录

python高级——目录

 

 

 

在 python
词汇表(

只要三个目标是可散列的,那么在那个目标的生命周期中,它的散列值是不改变的,而且以此目的急需落成
__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.7以来,列表推导和生成器表明式的概念就移植到了字典上,从而有了字典推导。字典推导(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],给找不到的键一个私下认可值,仍可以使用频率更加高的 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() 来建立1个新的列表把那个新列表作为值,’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 会自动调用它,而不是抛出2个 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() 在 Python3 中再次来到值是三个”视图”,”视图”就如二个聚众,而且和字典同样速度极快。但在
Python2中,my_dict.keys() 重临的是多少个列表。 所以 k in my_dict.keys()
操作在 python三中速度快速,但在 python2 中,管理效用并不高。

假使要自定义3个绚烂类型,合适的国策是承袭 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 模块中引进了3个封装类名字为
MappingProxyType。借使给那一个类二个绚烂,它会回到1个只读的炫目视图(假如原映射做了改变,那些视图的结果页会相应的改变)。举例

>>> 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'

字典中的散列表

散列表其实是二个疏散数组(总有空白成分的数组叫稀疏数组),在 dict
的散列表中,每种键值都据有三个表元,每一种表元都有五个部分,3个是对键的引用,另二个是对值的引用。因为兼具表元的大大小小同等,所以能够通过偏移量来读取某些表元。
python 会设法有限帮忙差不离有1/三的表元是空的,所以在就要达到那个阈值的时候,原有的散列表会被复制到二个更加大的上空。

万1要把多个对象放入散列表,那么首先要总结这些元素的散列值。
Python内置的 hash() 方法能够用来计算有所的放到类型对象。

设若七个目的在可比的时候是非凡的,那么它们的散列值也必须相等。举个例子一==一.0 那么,hash(一) == hash(1.0)

散列表算法

为了博取 my_dict[search_key] 的值,Python 会首先调用
hash(search_key) 来计算 search_key
的散列值,把这几个值的最低3位当做偏移量在散列表中寻找元。若表元为空,抛出
KeyError 分外。若不为空,则表元会有一部分 found_key:found_value。
那会儿急需校验 search_key == found_key,要是相等,重返 found_value。
借使不相称(散列冲突),再在散列表中再取二个人,然后管理一下,用管理后的结果作为索引再找表元。
然后再行上边的手续。

取值流程图如下:

美高梅开户网址 6

加多新值和上述的流程基本壹致,只但是对于前者,在开采空表元的时候会放入一个新因素,而对此后者,在找到呼应表元后,原表里的值对象会被替换到新值。

其余,在插入新值是,Python
大概会坚守散列表的水泄不通程度来决定是还是不是重新分配内部存款和储蓄器为它扩大容积,如若扩展了散列表的高低,那散列值所占的位数和当作索引的位数都会随着扩充字典的优势和范围

一、键必须是可散列的

可散列对象供给如下:

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

贰、字典耗费巨大

因为字典使用了散列表,而散列表又必须是稀疏的,那导致它在空间上效用低下。

3、键查询飞快

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

肆、键的次第决定于加多顺序

当往 dict
里增多新键而又发出散列争论时,新建只怕会被布署存放在另1个职位。

五、往字典里增多新键恐怕会改造已有键的相继

无论哪天向字典中增添新的键,Python
解释器都只怕做出为字典扩大容积的支配。扩大容积导致的结果正是要新建3个更加大的散列表,并把原有的键增加到新的散列表中,那个进程中只怕会生出新的散列争辨,导致新散列表中次序发生变化。
于是,不要对字典同时开展迭代和退换。

您恐怕感兴趣的篇章:

  • Python数据结构与算法之广大的分红排序法示例【桶排序与基数排序】
  • Python数据结构与算法之图的广度优先与深度优先搜索算法示例
  • Python数据结构与算法之使用队列消除猫猫钓鱼难点
  • Python数据结构之栈、队列的得以落成代码分享
  • Python数据结构之顺序表的兑现代码示例
  • Python数据结构与算法之列表(链表,linked
    list)轻巧完毕
  • Python数据结构与算法之链表定义与用法实例详解【单链表、循环链表】
  • Python中顺序表的贯彻轻便代码分享

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图