Python學習（十二）—— 常用内模組化塊collections

collections是Python内建的一個集合子產品，提供了許多有用的集合類。

1.namedtuple

namedtuple是一個函數，它用來建立一個自定義的tuple對象，并且規定了tuple元素的個數，并可以用屬性而不是索引來引用tuple的某個元素。

用namedtuple來建立坐标Point對象：

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2
           

用namedtuple來建立圓Circle對象：

# namedtuple('名稱', [屬性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])
           

2.deque

使用list存儲資料時，按索引通路元素很快，但是插入和删除元素就很慢了，因為list是線性存儲，資料量大的時候，插入和删除效率很低。

deque是為了高效實作插入和删除操作的雙向清單，适用于隊列和棧：

>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])
           

deque提供的操作有：

操作	含義
append()	從隊列尾插入元素
pop()	從隊列尾删除元素
appendleft()	從隊列頭插入元素
popleft()	從隊列頭删除元素

3.defaultdict

使用dict時，如果引用的Key不存在，就會抛出KeyError。如果希望key不存在時，傳回一個預設值，就可以用defaultdict：

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')                # 注意預設值是調用函數傳回的，而函數在建立defaultdict對象時傳入
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，傳回預設值
'N/A'
           

4.OrderedDict

使用dict時，Key是無序的。在對dict做疊代時，我們無法确定Key的順序。

如果要保持Key的順序，可以用OrderedDict：

>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d # dict的Key是無序的
{'a': 1, 'c': 3, 'b': 2}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
           

注意，OrderedDict的Key會按照插入的順序排序，不是Key本身排序：

>>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> list(od.keys()) # 按照插入的Key的順序傳回
['z', 'y', 'x']
           

注意，OrderedDict的Key會按照插入的順序排序，不是Key本身排序：

>>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> list(od.keys()) # 按照插入的Key的順序傳回
['z', 'y', 'x']
           

OrderedDict可以實作一個FIFO（先進先出）的dict，當容量超出限制時，先删除最早添加的Key：

from collections import OrderedDict

class LastUpdatedOrderedDict(OrderedDict):

    def __init__(self, capacity):
        super(LastUpdatedOrderedDict, self).__init__()
        self._capacity = capacity                            # 初始化fifo容量

    def __setitem__(self, key, value):
        containsKey = 1 if key in self else 0                # 判斷key是否已存在
        if len(self) - containsKey >= self._capacity:        # 若超過容量，删除棧頂元素
            last = self.popitem(last=False)
            print('remove:', last)
        if containsKey:                                      
            del self[key]
            print('set:', (key, value))
        else:
            print('add:', (key, value))
        OrderedDict.__setitem__(self, key, value)
           

5.ChainMap

（1）使用ChainMap可以将多個字典串聯起來，當做一個字典來處理：

from collections import ChainMap

# 構造兩個字典
user_dict1 = {"a": "xiaohong", "b": "xiaohua"}
user_dict2 = {"c": "xiaopang", "d": "xiaoming"}

# 通過ChainMap将兩個字典串聯起來，合成一個新字典
new_dict = ChainMap(user_dict1, user_dict2)

# 列印新字典
print(new_dict)
# ChainMap({'a': 'xiaohong', 'b': 'xiaohua'}, {'c': 'xiaopang', 'd': 'xiaoming'})
           

（2）直接通路串聯起來的資料：

print(new_dict["c"])
# xiaopang
           

（3）當不同的字典具有相同的主鍵的時候，在周遊串聯之後的資料時，會隻能周遊到之前的：

user_dict1 = {"a": "xiaohong", "b": "xiaohua"}
user_dict2 = {"b": "xiaopang", "d": "xiaoming"}
new_dict = ChainMap(user_dict1, user_dict2)

for key, value in new_dict.items():
    print(key, value)

# d xiaoming
# b xiaohua    # 隻擷取到user_dict1中的b，而user_dict2中的b被忽略
# a xiaohong
           

（4）動态添加新的dict：

# new_dict.new_child(new_dict)
#
# print(new_dict)
# for key, value in new_dict.items():
#     print(key, value)
           

（5）maps 方法會将串聯起來的字典以清單的形式展示：

print(new_dict.maps)
# [{'a': 'xiaohong', 'b': 'xiaohua'}, {'c': 'xiaopang', 'd': 'xiaoming'}]
           

（6）ChainMap 并不是對源資料的拷貝，而是 指向源資料：

new_dict.maps[0]["a"] = "pangzi"

print(new_dict)
# ChainMap({'a': 'pangzi', 'b': 'xiaohua'}, {'c': 'xiaopang', 'd': 'xiaoming'})
           

6.Counter

Counter

是一個簡單的計數器，例如，統計字元出現的個數：

>>> from collections import Counter
>>> c = Counter()                 # 構造計數器，該計數器實際上是一個dict
>>> for ch in 'programming':      # 每一個c[key]的初始值為0
...     c[ch] = c[ch] + 1
...
>>> c
Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})