namedtuple
類似於能幫我們創建一個動態的類，使用該類我們可以動態指定屬性和值，並且值只能定義一次，以後無法再修改，舉例：
from collections import namedtuple
People = namedtuple("People", ["name", "age", "hobby"])
# 創建一個People類，含有name、age和hobby屬性，並且屬性值只能初始化的時候設置一次
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
優勢
- 節省我們自己開發代碼
- 使用
namedtuple創建的類會省掉很多不必要的變量，幫我們節省空間 - 省內存、效率高
實現原理
該類實際上先編寫了一個類的字符串模板，源碼如下：
_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}
"""
以及創建屬性的字符串模板：
_field_template = '''\
{name} = _property(_itemgetter({index:d}), doc='Alias for field number {index:d}')
'''
然後通過格式化字符串後，通過exec函數動態創建類，通過該模板發現其還提供了幾個方法，下面會介紹
提供方法
_make
類方法，接收一個迭代器創建對象，舉例：
from collections import namedtuple
People = namedtuple("People", ["name", "age", "hobby"])
people = People._make(["aaa", 10, "play"])
# 傳入一個可迭代對象創建對象
print(people)
# People(name='aaa', age=10, hobby='play')
_replace
修改指定屬性值，並返回一個新的對象，舉例：
from collections import namedtuple
People = namedtuple("People", ["name", "age", "hobby"])
people = People._make(["aaa", 10, "play"])
new_people = people._replace(name="bbb")
# 修改name，並返回一個新的對象
print(new_people)
# People(name='bbb', age=10, hobby='play')
_asdict
將類轉成有序字典返回，舉例：
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不存在的時候自動生成一個指定的對象（對象類型在我們實例化的時候傳入）：
from collections import defaultdict
dd = defaultdict(list)
# key不存在時，默認設置成一個list對象
print(dd["x"])
dd["x"].append(1)
print(dd["x"])
# []
# [1]
defaultdict初始化指定的類型必須是可調用的對象即可，例如：類、函數等，舉例：
from collections import defaultdict
class A: pass
def people():
return {
"name": "aaa",
"age": 20
}
dd = defaultdict(people)
# 傳入一個函數
print(dd["x"])
dd = defaultdict(A)
# 傳入一個類
print(dd["x"])
# {'name': 'aaa', 'age': 20}
# <__main__.A object at 0x00000225A1A7F3C8>
實現原理
該類實現了__missing__魔法函數，當key不存在時就設置默認值
deque
雙端隊列，相比於list，提供了很多隊頭操作的方法，並且deque是線程安全的
Counter
對可迭代對象出現的次數進行統計：
from collections import Counter
a = ["a", "b", "a", "x", "a", "c", "b"]
c = Counter(a)
print(c)
print(c["a"])
# 查看a出現的次數
print(c.most_common(2))
# 取出數量最多的2個
# Counter({'a': 3, 'b': 2, 'x': 1, 'c': 1})
# 3
# [('a', 3), ('b', 2)]
該類繼承自dict，因此可以用dict的相關方法
其他方法
most_common(n)
統計次數最多的前n個
elements
返回一個迭代器，裏面是所有的內容
subtract
刪掉幾個元素，舉例：
from collections import Counter
a = ["a", "b", "a", "x", "a", "c", "b"]
c = Counter(a)
print(c)
c.subtract(["a", "b"])
# 刪掉一個a和一個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
直接把最後一項彈出，舉例：
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，但該方法不需要，因爲其內部維護了一個鏈表來記錄順序，然後將popitem時，直接把鏈表中最後一個彈出
remove_to_end
移動某個key到最後一個，舉例：
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)])
原理
本質是內部維護了一個鏈表來記錄順序
chainmap
可以將多個可迭代對象合併到一起：
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
可以看到如果有重名的，那麼第一個會正常返回，而第二個就會被跳過，並且傳入的對象只要是可迭代的即可，多個之間可以不是同一類型，舉例：
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
原理
內部實際上就是將所有迭代器使用一個list包起來進行管理，源碼如下：
def __init__(self, *maps):
self.maps = list(maps) or [{}] # always at least one map
因此我們也可以通過直接通過這個maps屬性來進行操作，舉例：
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])