namedtuple

類似于能幫我們創(chuàng)建一個(gè)動(dòng)態(tài)的類是尔，使用該類我們可以動(dòng)態(tài)指定屬性和值殉了，并且值只能定義一次，以后無法再修改拟枚，舉例：

from collections import namedtuple

People = namedtuple("People", ["name", "age", "hobby"])
# 創(chuàng)建一個(gè)People類薪铜，含有name、age和hobby屬性恩溅，并且屬性值只能初始化的時(shí)候設(shè)置一次
people = People(name="aaa", age=10, hobby="play")
# people = People("aaa", 10, "play")
# 兩種傳參都可以
print(people)
print(people.name, people.age, people.hobby)
people.name = "xxx"
# 不能修改值
print(people.name, people.age, people.hobby)

# People(name='aaa', age=10, hobby='play')
# aaa 10 play
# AttributeError: can't set attribute

優(yōu)勢(shì)

• 節(jié)省我們自己開發(fā)代碼
• 使用namedtuple創(chuàng)建的類會(huì)省掉很多不必要的變量隔箍，幫我們節(jié)省空間
• 省內(nèi)存、效率高

實(shí)現(xiàn)原理

該類實(shí)際上先編寫了一個(gè)類的字符串模板脚乡，源碼如下：

_class_template = """\
from builtins import property as _property, tuple as _tuple
from operator import itemgetter as _itemgetter
from collections import OrderedDict

class {typename}(tuple):
    '{typename}({arg_list})'

    __slots__ = ()

    _fields = {field_names!r}

    def __new__(_cls, {arg_list}):
        'Create new instance of {typename}({arg_list})'
        return _tuple.__new__(_cls, ({arg_list}))

    @classmethod
    def _make(cls, iterable, new=tuple.__new__, len=len):
        'Make a new {typename} object from a sequence or iterable'
        result = new(cls, iterable)
        if len(result) != {num_fields:d}:
            raise TypeError('Expected {num_fields:d} arguments, got %d' % len(result))
        return result

    def _replace(_self, **kwds):
        'Return a new {typename} object replacing specified fields with new values'
        result = _self._make(map(kwds.pop, {field_names!r}, _self))
        if kwds:
            raise ValueError('Got unexpected field names: %r' % list(kwds))
        return result

    def __repr__(self):
        'Return a nicely formatted representation string'
        return self.__class__.__name__ + '({repr_fmt})' % self

    def _asdict(self):
        'Return a new OrderedDict which maps field names to their values.'
        return OrderedDict(zip(self._fields, self))

    def __getnewargs__(self):
        'Return self as a plain tuple.  Used by copy and pickle.'
        return tuple(self)

{field_defs}
"""

以及創(chuàng)建屬性的字符串模板：

_field_template = '''\
    {name} = _property(_itemgetter({index:d}), doc='Alias for field number {index:d}')
'''

然后通過格式化字符串后蜒滩，通過exec函數(shù)動(dòng)態(tài)創(chuàng)建類，通過該模板發(fā)現(xiàn)其還提供了幾個(gè)方法奶稠，下面會(huì)介紹

提供方法

_make

類方法俯艰，接收一個(gè)迭代器創(chuàng)建對(duì)象，舉例：

from collections import namedtuple

People = namedtuple("People", ["name", "age", "hobby"])
people = People._make(["aaa", 10, "play"])
# 傳入一個(gè)可迭代對(duì)象創(chuàng)建對(duì)象
print(people)

# People(name='aaa', age=10, hobby='play')

_replace

修改指定屬性值窒典，并返回一個(gè)新的對(duì)象，舉例：

from collections import namedtuple

People = namedtuple("People", ["name", "age", "hobby"])
people = People._make(["aaa", 10, "play"])
new_people = people._replace(name="bbb")
# 修改name稽莉，并返回一個(gè)新的對(duì)象
print(new_people)

# People(name='bbb', age=10, hobby='play')

_asdict

將類轉(zhuǎn)成有序字典返回瀑志，舉例：

from collections import namedtuple

People = namedtuple("People", ["name", "age", "hobby"])
people = People._make(["aaa", 10, "play"])
print(people._asdict())

# OrderedDict([('name', 'aaa'), ('age', 10), ('hobby', 'play')])

defaultdict

能夠在key不存在的時(shí)候自動(dòng)生成一個(gè)指定的對(duì)象（對(duì)象類型在我們實(shí)例化的時(shí)候傳入）：

from collections import defaultdict

dd = defaultdict(list)
# key不存在時(shí)，默認(rèn)設(shè)置成一個(gè)list對(duì)象
print(dd["x"])
dd["x"].append(1)
print(dd["x"])

# []
# [1]

defaultdict初始化指定的類型必須是可調(diào)用的對(duì)象即可污秆，例如：類劈猪、函數(shù)等，舉例：

from collections import defaultdict

class A: pass

def people():
    return {
        "name": "aaa",
        "age": 20
    }

dd = defaultdict(people)
# 傳入一個(gè)函數(shù)
print(dd["x"])
dd = defaultdict(A)
# 傳入一個(gè)類
print(dd["x"])

# {'name': 'aaa', 'age': 20}
# <__main__.A object at 0x00000225A1A7F3C8>

實(shí)現(xiàn)原理

該類實(shí)現(xiàn)了__missing__魔法函數(shù)良拼，當(dāng)key不存在時(shí)就設(shè)置默認(rèn)值

deque

雙端隊(duì)列战得，相比于list，提供了很多隊(duì)頭操作的方法庸推，并且deque是線程安全的

Counter

對(duì)可迭代對(duì)象出現(xiàn)的次數(shù)進(jìn)行統(tǒng)計(jì)：

from collections import Counter

a = ["a", "b", "a", "x", "a", "c", "b"]
c = Counter(a)
print(c)
print(c["a"])
# 查看a出現(xiàn)的次數(shù)
print(c.most_common(2))
# 取出數(shù)量最多的2個(gè)

# Counter({'a': 3, 'b': 2, 'x': 1, 'c': 1})
# 3
# [('a', 3), ('b', 2)]

該類繼承自dict常侦，因此可以用dict的相關(guān)方法

其他方法

most_common(n)

統(tǒng)計(jì)次數(shù)最多的前n個(gè)

elements

返回一個(gè)迭代器浇冰，里面是所有的內(nèi)容

subtract

刪掉幾個(gè)元素，舉例：

from collections import Counter

a = ["a", "b", "a", "x", "a", "c", "b"]
c = Counter(a)
print(c)
c.subtract(["a", "b"])
# 刪掉一個(gè)a和一個(gè)b
print(c)

# Counter({'a': 3, 'b': 2, 'x': 1, 'c': 1})
# Counter({'a': 2, 'b': 1, 'x': 1, 'c': 1})

OrderDict

有序字典聋亡，但在python3.6以后普通的字典都是有序的了肘习，不過該類還提供了一些dict沒有的方法

提供方法

popitem

直接把最后一項(xiàng)彈出，舉例：

from collections import OrderedDict

od = OrderedDict(a=1, b=2, c=3)
print(od)
print(od.popitem())
print(od)

# OrderedDict([('a', 1), ('b', 2), ('c', 3)])
# ('c', 3)
# OrderedDict([('a', 1), ('b', 2)])

該方法和pop不同坡倔，pop需要傳入key漂佩，但該方法不需要，因?yàn)槠鋬?nèi)部維護(hù)了一個(gè)鏈表來記錄順序罪塔，然后將popitem時(shí)投蝉，直接把鏈表中最后一個(gè)彈出

remove_to_end

移動(dòng)某個(gè)key到最后一個(gè)，舉例：

from collections import OrderedDict

od = OrderedDict(a=1, b=2, c=3)
print(od)
od.move_to_end("a")
print(od)

# OrderedDict([('a', 1), ('b', 2), ('c', 3)])
# OrderedDict([('b', 2), ('c', 3), ('a', 1)])

原理

本質(zhì)是內(nèi)部維護(hù)了一個(gè)鏈表來記錄順序

chainmap

可以將多個(gè)可迭代對(duì)象合并到一起：

from collections import ChainMap

d1 = {"a":1, "b":2}
d2 = {"b":1, "c":2}
cm = ChainMap(d1, d2)
print(cm)
for d in cm:
    print(d, cm[d])

# ChainMap({'a': 1, 'b': 2}, {'b': 1, 'c': 2})
# c 2
# b 2
# a 1

可以看到如果有重名的征堪，那么第一個(gè)會(huì)正常返回瘩缆，而第二個(gè)就會(huì)被跳過，并且傳入的對(duì)象只要是可迭代的即可请契，多個(gè)之間可以不是同一類型咳榜，舉例：

from collections import ChainMap

d1 = [1,2,3]
d2 = {"a":1}
cm = ChainMap(d1, d2)
print(cm)
for d in cm:
    print(d)

# ChainMap([1, 2, 3], {'a': 1})
# 1
# 2
# 3
# a

原理

內(nèi)部實(shí)際上就是將所有迭代器使用一個(gè)list包起來進(jìn)行管理，源碼如下：

def __init__(self, *maps):
    self.maps = list(maps) or [{}]          # always at least one map

因此我們也可以通過直接通過這個(gè)maps屬性來進(jìn)行操作爽锥，舉例：

from collections import ChainMap

d1 = [1,2,3]
d2 = [1,4,5]
cm = ChainMap(d1, d2)
print(cm)
cm.maps[1][0] = 0
print(cm)

# ChainMap([1, 2, 3], [1, 4, 5])
# ChainMap([1, 2, 3], [0, 4, 5])