您的位置:时时app平台注册网站 > 编程知识 > python高等(三)—— 字典和聚集(泛映射类型)

python高等(三)—— 字典和聚集(泛映射类型)

2019-10-30 04:22

本文首要内容

可散列类型

泛映射类型

字典

    (1)字典推导式

  (2)管理空头支票的键

    (3)字典的变种

集合

照耀的再研商

 

python高级——目录

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

 

正文紧要内容

可散列类型

泛映射类型

字典

    (1)字典推导式

  (2)管理不设有的键

集合

照耀的再商议

 

python高级——目录

文中代码均位居github上:

 

3、键查询飞速

集合

'''
    集合对于很多人并不陌生,中学阶段就已经接触过。集合具有:
    (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>一书,如下三个表:

表一:集合的数学方法

 

表2:集结的比较运算

 

表3:集结的别的运算

 

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

default_factory 并非贰个措施,而是多个可调用对象,它的值 defaultdict 开首化的时候由客商设定。 OrderedDict.popitem() 会移除字典最初插入的成分(先进先出);可选参数 last 假如值为真,则会移除最终插入的因素(后进先出)。用 setdefault 管理找不到的键

python高档体系小说目录

python高级——目录

 

 

 

python高等体系作品目录

python高级——目录

 

 

 

字典和聚众(泛映射类型),python映射 本文首要内容 可散列类型 泛映射类型 字典 (1)字典推导式 (2)管理不设有...

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

可散列类型

'''
    可散列数据类型(也称可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

 

泛映射类型

'''
    泛映射类型就是广义上的对应关系,在数学中,我们将集合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

 

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

泛映射类型

'''
    泛映射类型就是广义上的对应关系,在数学中,我们将集合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

 

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

辉映的再谈谈 

'''
    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可能会一举成功。

   重要的下结论摘录如下:

  (1)键必需是可散列的

  (2)字典在内部存款和储蓄器上的开销庞大

  (3)键查询急忙

  (4)键的前后相继决定于增加顺序

  (5)往字典里增加新键也许会变动本来就有键的顺序

 

字典

'''
    字典是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__...

 

在 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}

(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}

 

contains 方法存在是为了保持大器晚成致性,因为 k in d 那些操作会调用它,但咱们从 dict 继承到的 contains 方法不会在找不到键的时候用 missing 方法。

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

__missing__ 方法只会被 __getitem__ 调用。提供 missing 方法对 get 或者 __contains__(in 运算符会用到那一个方法)这几个措施的是有未有震慑。

从 Python3.3 起首 types 模块中引进了一个封装类名称为 MappingProxyType。假如给那么些类一个映射,它会重临三个只读的投射视图(尽管原映射做了退换,那个视图的结果页会相应的改变)。比如

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

不论是曾几何时向字典中增添新的键,Python 解释器都可能做出为字典扩大体量的主宰。扩大容积导致的结果就是要新建八个更加大的散列表,并把原来的键加多到新的散列表中,这几个历程中大概会发生新的散列冲突,导致新散列表中次序产生变化。
故此,不要对字典同期进行迭代和改革。

借使八个对象在比较的时候是格外的,那么它们的散列值也必得相等。比方1==1.0 那么,hash(1) == hash(1.0)

5、往字典里增加新键或者会退换原来就有键的各样

依赖那些概念,字典提供了非常多样构造方法, 那些页面有个例子来表明创制字典的比不上措施。

据他们说那个概念,原子不可变类型(str,bytes和数值类型)都以可散列类型,frozenset 也是可散列的(因为依照其定义,frozenset 里只可以容纳可散列类型),即使元组内都以可散列类型的话,元组也是可散列的(元组即便是不可变类型,但如果它此中的因素是可变类型,这种元组也不能够被认为是不可变的)。

自 Python2.7 以来,列表推导和生成器表明式的定义就移植到了字典上,进而有了字典推导。字典推导(dictcomp)能够从此外以键值对作为成分的可迭代对象中营造出字典。

为了获取 my_dict[search_key] 的值,Python 会首先调用 hash(search_key) 来计算 search_key 的散列值,把那些值的最低几个人充当偏移量在散列表中检索元。若表元为空,抛出 KeyError 至极。若不为空,则表元会有部分 found_key:found_value。
那时候急需校验 search_key == found_key,假若相等,重临 found_value。
假诺不包容(散列冲突),再在散列表中再取几个人,然后管理一下,用管理后的结果作为索引再找表元。 然后再一次上面包车型客车步子。

取值流程图如下:

即使要自定义三个映射类型,合适的政策是传承 collections.UserDict 类。那个类便是把正规化 dict 用 python 又达成了一回,UserDict 是让客户承继写子类的,改正后的代码如下:

散列表其实是三个疏散数组(总有空白成分的数组叫疏落数组),在 dict 的散列表中,各个键值都占有一个表元,种种表元都有几个部分,三个是对键的援用,另两个是对值的援用。因为具备表元的大大小小相仿,所以能够由此偏移量来读取有个别表元。
python 会设法保障差十分少有1/3的表元是空的,所以在就要达到那几个阈值的时候,原有的散列表会被复制到贰个更加大的空间。

图片 1

Mapping 中提供了 get 方法,和咱们在 StrKeyDict0 中定义的一模二样,所以大家在那地没有必要定义 get 方法。

可散列对象须求如下:

比如:

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

那就是说,大家取值的时候,该怎么管理找不到的键呢?

因为字典使用了散列表,而散列表又必得是荒废的,这导致它在半空中上成效低下。

上面这段代码完成了 StrKeyDict0 类,StrKeyDict0 类在询问的时候把非字符串的键转变为字符串。

有时,尽管有个别键在璀璨里空中楼阁,大家也期待在通过那几个键读取值的时候能获取一个默许值。有几个路子能帮大家落成那么些指标,多个是由此defaultdict 这么些项目并非平铺直叙的 dict,另三个是给和睦定义多个 dict 的子类,然后在子类中得以落成 __missing__ 方法。

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

奇异措施 missing

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()

这两段代码的效力等同,只不过,后面一个最少要进行五次键查询,若是不设有,正是一回,而用 setdefault 只需二遍就足以成功总体操作。

>>> 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模块内)。

泛映射类型

你只怕感兴趣的小说:

  • Python数据结构与算法之遍布的分配排序法示例【桶排序与基数排序】
  • Python数据结构与算法之图的广度优先与深度优先寻找算法示例
  • Python数据结构与算法之使用队列化解喵星人钓鱼难点
  • Python数据结构之栈、队列的兑现代码分享
  • Python数据结构之顺序表的贯彻代码示例
  • Python数据结构与算法之列表(链表,linked list)轻易实现
  • Python数据结构与算法之链表定义与用法实例详解【单链表、循环链表】
  • Python中顺序表的完成轻松代码分享

当字典 d[k] 无法找到科学的键的时候,Python 会抛出极度,平日大家都施用d.get(k, default) 来代替 d[k],给找不到的键三个暗中同意值,还是能运用频率更加高的 setdefault

借使要把三个对象归入散列表,那么首先要总括这些元素的散列值。
Python内置的 hash() 方法可以用于总结有所的放到类型对象。

此间我们新建了二个字典 index,如若键 new_key 在 index 中不设有,表达式 index[new_key] 会按以下步骤来操作:

图片 2

在 collections 模块中,除了 defaultdict 之外还会有别的的炫人眼目类型。

大范围的投射方法

defaultdict 中的 default_factory 只会在 getitem 里调用,在其余艺术中不会时有产生效能。譬喻 index[k] 那么些表明式会调用 default_factory 创制的某部暗中认可值,而 index.get(k) 则会回去 None。(那是因为特殊格局 missing 会在 defaultdict 蒙受找不到的键的时候调用 default_factory,实际上,那特性情全部映射方法都足以扶持)。

1、键必需是可散列的

2、字典费用庞大

标准Curry全数映射类型都以接收 dict 来兑现的,它们有个联合的限量,即独有可散列的数据类型技术用做这几个映射里的键。

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

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

图片 3

难点:规范库中颇负的映照类型都以可变的,假使大家想给客户提供贰个不可变的照耀类型该怎么管理啊?

my_dict.keys() 在 Python3 中再次来到值是一个"视图","视图"就好像贰个聚焦,並且和字典相像速度超快。但在 Python第22中学,my_dict.keys() 重回的是七个列表。 所以 k in my_dict.keys() 操作在 python3中速度快速,但在 python2 中,管理成效并不高。

当往 dict 里增添新键而又生出散列冲突时,新建大概会被布置贮存在另叁个职位。

dict 的实现是名列三甲的半空中换时间:字典类型由着英豪的内部存款和储蓄器花费,但提供了无视数据量大小的快速访谈。

辉映的弹性查询

4、键的主次决议于增多顺序

collections.abc 模块中有 Mapping 和 MutableMapping 这多少个抽象基类,它们的效果与利益是为 dict 和其余相像的类型定义方式接口。

先是大家看下如何使用 defaultdict :

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

别的,在插入新值是,Python 可能会遵照散列表的熙熙攘攘程度来决定是或不是重新分配内部存款和储蓄器为它扩大体量,纵然扩充了散列表的大大小小,这散列值所占的位数和作为索引的位数都会随着扩大字典的优势和限量

除去那么些点子以外,还足以用字典推导的情势来修造新 dict。

字典中的散列表

援救 hash 函数,何况经过__hash__() 方法所得的散列值不改变扶植通过 __eq__() 方法检查评定相等性若 a == b 为真, 则 hash(a) == hash(b) 也为真

散列表算法

import collections

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

字典推导

享有映射在拍卖找不到的键的时候,都会推抢到 missing 方法。但基类 dict 并从未提供 那些方法。不过,假若有二个类承袭了 dict ,然后这些承袭类提供了 missing 方法,那么在 getitem 蒙受找不到键的时候,Python 会自动调用它,并非抛出一个 KeyError 分外。

借使二个对象是可散列的,那么在这里个指标的生命周期中,它的散列值是不变的,况且以此目的急需得以完毕 __hash__() 方法。其它可散列对象还要有 __eq__() 方法,那样手艺跟别的键做相比较。倘使五个可散列对象是相等的,那么它们的散列只确定是生机勃勃律的

调用 list() 来创设三个新的列表把那么些新列表作为值,'new_key' 作为它的键,归入 index 中回到这么些列表的援用。

日常来说,客户自定义的项目的对象都以可散列的,散列值正是它们的 id() 函数的重临值,所以那个目的在可比的时候都以不对等的。(假诺三个目的完毕了 eq 方法,并且在艺术中用到了那么些目的的中间景况以来,那么唯有当有着这个内部景色都以不可变的动静下,这几个指标才是可散列的。)

本文由时时app平台注册网站发布于编程知识,转载请注明出处:python高等(三)—— 字典和聚集(泛映射类型)

关键词: