一文帶你深入探究Python?Collections模塊

更新時間：2023年11月10日 10:38:43 作者：郝同學的測開筆記

Python中Collections模塊實現(xiàn)了一些專門化的容器,提供了對?Python?的通用內建容器?dict、list、set?和?tuple?的補充,下面我們就來了解一下它的具體用法吧

前言

這幾天刷leetcode題時，看到題解中有這樣一行代碼collections.defaultdict(list)，不明白是啥意思，平時開發(fā)的腳本中未遇到，借著這個機會，學習一下collections模塊的用法。

collections

這個模塊實現(xiàn)了一些專門化的容器，提供了對 Python 的通用內建容器 dict、list、set 和 tuple 的補充。

defaultdict

defaultdict是dict（字典）的一個子類，它為字典操作中的缺失鍵提供了默認值。這在處理計數(shù)、分組等操作時非常有用。

案例：給定一個列表，將每個單詞按首字母分組

import collections
?
mp = collections.defaultdict(list)
?
words = ['apple', 'banana', 'orange', 'pear', 'peach']
for word in words:
    mp[word[0]].append(word)
?
print(mp) # defaultdict(<class 'list'>, {'a': ['apple'], 'b': ['banana'], 'o': ['orange'], 'p': ['pear', 'peach']})

mp = collections.defaultdict(list)這行代碼創(chuàng)建了一個defaultdict對象，其中list是指定的默認值類型。

這意味著當我們通過mp訪問一個不存在的鍵時，defaultdict會自動創(chuàng)建這個鍵，并將其對應的值初始化為一個空列表。比如上面這段代碼，我們在print(mp)前面增加mp['aa']，此時會輸出defaultdict(<class 'list'>, {'a': ['apple'], 'b': ['banana'], 'o': ['orange'], 'p': ['pear', 'peach'], 'aa': []})

Counter

Counter是一個簡單而強大的計數(shù)器工具，用于統(tǒng)計可迭代對象中各元素出現(xiàn)的次數(shù)。

案例：統(tǒng)計一個字符串中字符出現(xiàn)的次數(shù)

import collections
?
s = "abracadabra"
counter = collections.Counter(s)
print(counter) # 輸出結果：Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

namedtuple

namedtuple創(chuàng)建了一個帶字段名的元組類型，它可以對元組進行命名，使得代碼更易讀。

案例：創(chuàng)建一個表示坐標的數(shù)據(jù)結構

import collections
?
Point = collections.namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)
print(p.x, p.y) # 輸出結果：11 22

deque

deque是一個雙向隊列，可以在兩端快速插入和刪除元素，適用于需要高效地進行隊列和棧操作的場景。

案例：使用deque實現(xiàn)一個簡單的循環(huán)隊列

import collections
?
q = collections.deque(maxlen=3)
q.append(1)
q.append(2)
q.append(3)
print(q)  # 輸出結果：deque([1, 2, 3], maxlen=3)
q.append(4)
print(q)  # 輸出結果：deque([2, 3, 4], maxlen=3)

OrderedDict

有序字典，保持元素被插入的順序。

案例：實現(xiàn)LRU緩存：LRU（Least Recently Used）緩存是一種常見的緩存策略，當緩存滿時，會淘汰最近最少使用的元素。OrderedDict可以很方便地實現(xiàn)LRU緩存，每次訪問一個元素時，將其移到字典的末尾，這樣最近訪問的元素就會被保留，最早訪問的元素就會被淘汰。

from collections import OrderedDict
?
class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = OrderedDict()
?
    def get(self, key):
        if key in self.cache:
            value = self.cache[key]
            # 將訪問的元素移到字典的末尾
            self.cache.move_to_end(key)
            return value
        else:
            return -1
?
    def put(self, key, value):
        if key in self.cache:
            # 如果key已經存在，將其移到字典的末尾
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            # 如果緩存已滿，淘汰最早訪問的元素
            self.cache.popitem(last=False)

ChainMap

在多個字典中查找某個鍵的值，可以使用ChainMap將這些字典組合成一個邏輯上的字典，從而方便地進行查找操作。

案例：使用ChainMap查找鍵的值：

from collections import ChainMap
?
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
dict3 = {'e': 5, 'f': 6}
?
chain_map = ChainMap(dict1, dict2, dict3)
?
value = chain_map['a']
print(value)  # 輸出: 1
?
value = chain_map['c']
print(value)  # 輸出: 3

UserDict

當需要創(chuàng)建一個自定義的字典類時，可以繼承UserDict類，從而方便地實現(xiàn)自定義的字典功能。

案例：使用UserDict創(chuàng)建自定義字典類

from collections import UserDict
?
class MyDict(UserDict):
    def __setitem__(self, key, value):
        super().__setitem__(key, value * 2)
?
my_dict = MyDict()
my_dict['a'] = 1
my_dict['b'] = 2
?
print(my_dict)  # 輸出: {'a': 2, 'b': 4}

UserList

當需要創(chuàng)建一個自定義的列表類時，可以繼承UserList類，從而方便地實現(xiàn)自定義的列表功能。

案例：使用UserList創(chuàng)建自定義列表類

from collections import UserList
?
class MyList(UserList):
    def remove_duplicates(self):
        self.data = list(set(self.data))
?
my_list = MyList([1, 2, 2, 3, 4, 4, 5])
my_list.remove_duplicates()
?
print(my_list)  # 輸出: [1, 2, 3, 4, 5]

UserString

當需要創(chuàng)建一個自定義的字符串類時，可以繼承UserString類，從而方便地實現(xiàn)自定義的字符串功能。

案例：使用UserString創(chuàng)建自定義字符串類

from collections import UserString
?
class MyString(UserString):
    def remove_whitespace(self):
        self.data = self.data.replace(' ', '')
?
my_string = MyString('Hello World')
my_string.remove_whitespace()
?
print(my_string)  # 輸出: HelloWorld