python語言中的常用容器(集合)示例詳解

更新時間：2025年09月23日 10:46:10 作者：_bong

Python集合是一種無序且不重復(fù)的數(shù)據(jù)容器,它可以存儲任意類型的對象,包括數(shù)字、字符串、元組等,下面這篇文章主要介紹了python語言中常用容器(集合)的相關(guān)資料,文中通過代碼介紹的非常詳細,需要的朋友可以參考下

1.核心內(nèi)置容器

1. 列表

類型名: list
可變性: 可變
有序性: 有序（元素按插入順序排列，可通過索引訪問）
元素要求: 可存放任意類型、可重復(fù)的元素。
語法: 使用方括號 [] 創(chuàng)建，元素用逗號分隔。
主要特性:
- 最通用、最常用的序列類型。
- 支持豐富的操作：索引 (lst[0])、切片 (lst[1:3])、拼接 (+)、重復(fù) (*)、成員檢查 (in)。
- 提供多種方法來修改內(nèi)容：.append(), .insert(), .pop(), .remove(), .sort() 等。

my_list = [1, 2, 'hello', 3.14, 1] # 可重復(fù)，不同類型
my_list[0] = 100 # 可變，可以修改元素
print(my_list) # 輸出: [100, 2, 'hello', 3.14, 1]

2. 元組

類型名: tuple
可變性: 不可變
有序性: 有序（元素按插入順序排列，可通過索引訪問）
元素要求: 可存放任意類型、可重復(fù)的元素。
語法: 使用圓括號 () 創(chuàng)建，元素用逗號分隔。單元素元組需加逗號（如 (1,)）。
主要特性:
- 一旦創(chuàng)建，其內(nèi)容無法修改（但如果元素本身是可變對象，如列表，則該列表的內(nèi)容可以修改）。
- 因其不可變性，常用于需要數(shù)據(jù)安全、保證不會被更改的場景，如作為字典的鍵、函數(shù)返回多個值等。
- 性能通常略優(yōu)于列表。

my_tuple = (1, 2, 'world', [3, 4])
# my_tuple[0] = 100 # 錯誤！元組不可變
my_tuple[3].append(5) # 正確。因為元組中的列表是可變的
print(my_tuple) # 輸出: (1, 2, 'world', [3, 4, 5])

3. 集合

類型名: set
可變性: 可變
有序性: 無序（Python 3.7+ 后，實現(xiàn)細節(jié)上保留了插入順序，但絕不能依賴于此進行編程。從語言定義上講，它是無序的）。
元素要求: 元素必須是可哈希的（如數(shù)字、字符串、元組等不可變類型）。元素不可重復(fù)。
語法: 使用花括號 {} 創(chuàng)建（但空集合必須用 set() 創(chuàng)建），元素用逗號分隔。
主要特性:
- 核心功能是去重和成員關(guān)系測試（檢查元素是否存在），這兩項操作效率極高（時間復(fù)雜度為 O(1)）。
- 支持數(shù)學(xué)上的集合運算：并集 (|), 交集 (&), 差集 (-), 對稱差集 (^)。

my_set = {1, 2, 3, 2, 'hello'} # 自動去重
print(my_set) # 輸出可能是 {1, 2, 3, 'hello'} (順序不確定)
my_set.add(4) # 可變，可以添加元素
print(2 in my_set) # 成員檢查，輸出: True

4. 凍結(jié)集合

類型名: frozenset
可變性: 不可變
有序性: 無序
元素要求: 同 set，元素必須是可哈希的且不可重復(fù)。
語法: 使用 frozenset() 函數(shù)創(chuàng)建，可傳入一個可迭代對象（如列表、元組）。
主要特性:
- 具有 set 的所有特性（去重、成員測試、集合運算），但內(nèi)容不可變。
- 因其不可變性，它本身是可哈希的，因此可以作為字典的鍵或另一個集合的元素。

my_frozenset = frozenset([1, 2, 2, 3])
print(my_frozenset) # 輸出: frozenset({1, 2, 3})
# my_frozenset.add(4) # 錯誤！不可變集合

5. 字典

類型名: dict
可變性: 可變
有序性: 有序（自 Python 3.7 起，字典正式保持鍵的插入順序）。
元素要求: 鍵必須是可哈希的，值可以是任意對象。鍵不可重復(fù)。
語法: 使用花括號 {} 創(chuàng)建，鍵值對形式 key: value，用逗號分隔。空字典為 {}。
主要特性:
- 存儲鍵值對映射關(guān)系，通過鍵來高效地查找、插入和刪除對應(yīng)的值（時間復(fù)雜度為 O(1)）。
- 是 Python 中極其重要的數(shù)據(jù)結(jié)構(gòu)。

my_dict = {'name': 'Alice', 'age': 25, 1: 'number'}
my_dict['country'] = 'USA' # 添加新的鍵值對
print(my_dict['name']) # 通過鍵訪問值，輸出: Alice
print(list(my_dict.keys())) # 輸出鍵列表: ['name', 'age', 1, 'country'] (保持插入順序)

2.collections模塊中的高級集合

collections 模塊提供了多種專門化的容器數(shù)據(jù)類型，它們是對 Python 通用內(nèi)置容器（如字典、列表、集合）的強大補充。這些數(shù)據(jù)結(jié)構(gòu)針對特定用例進行了優(yōu)化，能夠提供更好的性能或更便利的接口。

6. 命名元組

namedtuple 是元組的子類，它為元組的每個位置分配一個名稱，同時保留元組的特性（不可變、有序、可通過索引訪問）。普通元組需要通過數(shù)字索引訪問元素（如 point[0], point[1]），這使得代碼可讀性差且容易出錯。namedtuple 允許使用有意義的名稱訪問相同的數(shù)據(jù)。

from collections import namedtuple

# 創(chuàng)建一個名為'Point'的namedtuple類，具有字段'x'和'y'
Point = namedtuple('Point', ['x', 'y'])

# 創(chuàng)建實例
p = Point(11, y=22)

# 訪問字段
print(p.x)    # 輸出: 11
print(p.y)    # 輸出: 22
print(p[0])   # 仍然可以通過索引訪問: 11

# 不可變性（繼承自元組）
# p.x = 33  # 這會報錯：AttributeError: can't set attribute

7. 雙端隊列

deque是一個線程安全、可以快速從兩端添加或刪除元素的序列容器。Python 的列表在尾部操作（追加和彈出）非常高效（O(1)時間復(fù)雜度），但在頭部操作（插入和刪除）效率較低（O(n)時間復(fù)雜度）。deque 在兩端操作都是 O(1) 時間復(fù)雜度。

from collections import deque

# 創(chuàng)建雙端隊列
d = deque(['b', 'c', 'd'])

# 從左側(cè)添加元素
d.appendleft('a')   # deque(['a', 'b', 'c', 'd'])

# 從右側(cè)添加元素
d.append('e')       # deque(['a', 'b', 'c', 'd', 'e'])

# 從左側(cè)彈出元素
left_item = d.popleft()  # 'a', deque變?yōu)閇'b', 'c', 'd', 'e']

# 從右側(cè)彈出元素
right_item = d.pop()     # 'e', deque變?yōu)閇'b', 'c', 'd']

# 限制最大長度（當(dāng)隊列滿時，添加新元素會從另一端自動刪除元素）
limited_deque = deque(maxlen=3)
limited_deque.extend([1, 2, 3])  # deque([1, 2, 3], maxlen=3)
limited_deque.append(4)          # deque([2, 3, 4], maxlen=3) - 自動刪除最左邊的1

8. 計數(shù)器

Counter 是 dict 的子類，用于統(tǒng)計可哈希對象的出現(xiàn)次數(shù)。它是一個無序集合，其中元素存儲為字典鍵，它們的計數(shù)存儲為字典值。手動統(tǒng)計元素頻率需要編寫循環(huán)和條件判斷，而 Counter 提供了簡潔高效的接口來完成這一常見任務(wù)。

from collections import Counter

# 從可迭代對象創(chuàng)建
words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
word_count = Counter(words)
print(word_count)  # Counter({'apple': 3, 'banana': 2, 'orange': 1})

# 從映射創(chuàng)建
c = Counter({'red': 4, 'blue': 2})  # Counter({'red': 4, 'blue': 2})

# 從關(guān)鍵字參數(shù)創(chuàng)建
c = Counter(cats=4, dogs=8)  # Counter({'dogs': 8, 'cats': 4})

# 常用操作
print(word_count.most_common(2))  # 出現(xiàn)頻率最高的2個元素: [('apple', 3), ('banana', 2)]

c = Counter(a=3, b=1)
d = Counter(a=1, b=2)
print(c + d)   # 相加: Counter({'a': 4, 'b': 3})
print(c - d)   # 相減: Counter({'a': 2})
print(c & d)   # 交集: Counter({'a': 1, 'b': 1})
print(c | d)   # 并集: Counter({'a': 3, 'b': 2})

9. 默認字典

defaultdict 是 dict 的子類，它重寫了一個方法并添加了一個可寫的實例變量。當(dāng)嘗試訪問不存在的鍵時，它會自動創(chuàng)建該鍵并使用提供的工廠函數(shù)初始化其值。使用普通字典時，訪問不存在的鍵會引發(fā) KeyError，需要先檢查鍵是否存在或使用 get() 方法。defaultdict 自動處理這種情況，使代碼更簡潔。

from collections import defaultdict

# 使用list作為工廠函數(shù)，當(dāng)鍵不存在時創(chuàng)建空列表
dd = defaultdict(list)

dd['fruits'].append('apple')  # 自動創(chuàng)建'fruits'鍵并初始化為空列表
dd['fruits'].append('banana')
print(dd)  # defaultdict(<class 'list'>, {'fruits': ['apple', 'banana']})

# 使用int作為工廠函數(shù)，默認值為0
counts = defaultdict(int)
counts['apple'] += 1  # 自動創(chuàng)建'apple'鍵并初始化為0，然后加1
print(counts)  # defaultdict(<class 'int'>, {'apple': 1})

# 使用lambda函數(shù)提供自定義默認值
prices = defaultdict(lambda: 10.0)  # 默認價格為10.0
print(prices['unknown_item'])  # 輸出: 10.0

3.numpy數(shù)組

NumPy 是 Python 科學(xué)計算生態(tài)系統(tǒng)的基石和核心庫。幾乎所有處理數(shù)據(jù)、進行科學(xué)計算或機器學(xué)習(xí)的 Python 工具（如 Pandas, Scikit-learn, SciPy, TensorFlow, PyTorch）都構(gòu)建在 NumPy 的基礎(chǔ)之上。這也是為什么numpy單獨開一章來講！

對比一下list與numpy：

# 使用 Python list (效率低)
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
result = []
for x, y in zip(a, b):
    result.append(x**2 + y**2)

# 使用 NumPy (高效、簡潔)
import numpy as np
a_np = np.array([1, 2, 3, 4])
b_np = np.array([5, 6, 7, 8])
result_np = a_np**2 + b_np**2 # 直接對整個數(shù)組操作

numpy無需編寫循環(huán)，就可以直接對整個數(shù)組進行算術(shù)運算、邏輯運算等。這得益于其廣播（Broadcasting） 機制，使得不同形狀的數(shù)組可以進行數(shù)學(xué)運算。

廣播規(guī)則：從尾部維度開始，向前面維度推進，如果兩個數(shù)組的維度大小相等或其中一個為1，則它們是兼容的，可以進行廣播。

# 將一個向量加到矩陣的每一行上
a = np.array([[1, 2, 3],
              [4, 5, 6]]) # Shape: (2, 3)
b = np.array([10, 20, 30])   # Shape: (3,)
# b 的 shape 會被“廣播”成 (1, 3)，然后再“廣播”成 (2, 3)
result = a + b
print(result)
# [[11 22 33]
#  [14 25 36]]

除此之外numpy還有更多更強大的優(yōu)勢，例如具有豐富的數(shù)學(xué)函數(shù)庫提供了大量標準的數(shù)學(xué)函數(shù)（sin, cos, exp, log...）、線性代數(shù)運算（矩陣乘法、求逆、行列式...）、隨機數(shù)生成、傅里葉變換等，全部針對數(shù)組進行優(yōu)化；強大的索引功能，除了類似列表的基礎(chǔ)索引，還支持布爾索引、花式索引等，可以非常靈活地訪問和修改數(shù)組數(shù)據(jù)。等等優(yōu)勢

下面簡要介紹一下numpy的基礎(chǔ)用法

3.1 導(dǎo)入 NumPy

import numpy as np

3.2 創(chuàng)建數(shù)組

# 從列表創(chuàng)建
arr1 = np.array([1, 2, 3, 4, 5])          # 一維數(shù)組
arr2 = np.array([[1, 2, 3], [4, 5, 6]])   # 二維數(shù)組

# 使用內(nèi)置函數(shù)創(chuàng)建
zeros_arr = np.zeros((3, 4))      # 創(chuàng)建 3x4 的全0數(shù)組
ones_arr = np.ones((2, 3))        # 創(chuàng)建 2x3 的全1數(shù)組
empty_arr = np.empty((2, 2))      # 創(chuàng)建未初始化的數(shù)組（內(nèi)容隨機）
range_arr = np.arange(0, 10, 2)   # 類似 range(), 創(chuàng)建 [0, 2, 4, 6, 8]
linspace_arr = np.linspace(0, 1, 5) # 在0到1之間創(chuàng)建5個等間隔的數(shù) [0., 0.25, 0.5, 0.75, 1.]

# 創(chuàng)建隨機數(shù)組
random_arr = np.random.rand(3, 2) # 創(chuàng)建 3x2 的數(shù)組，元素來自[0,1)的均勻分布
randn_arr = np.random.randn(1000) # 創(chuàng)建1000個符合標準正態(tài)分布的隨機數(shù)

3.3數(shù)組的屬性

arr = np.array([[1, 2, 3], [4, 5, 6]])

print(arr.ndim)    # 數(shù)組的維數(shù) (秩): 2
print(arr.shape)   # 數(shù)組的維度 (行數(shù), 列數(shù)): (2, 3)
print(arr.size)    # 數(shù)組的元素總數(shù): 6
print(arr.dtype)   # 數(shù)組中元素的數(shù)據(jù)類型: int64 (取決于系統(tǒng))

3.4切片功能

arr = np.array([[1, 2, 3, 4],
                [5, 6, 7, 8],
                [9, 10, 11, 12]])

# 基礎(chǔ)索引
print(arr[0, 1])   # 獲取第0行第1列的元素: 2

# 切片 (支持負索引和步長)
print(arr[:2, 1:3]) # 前兩行，第1到2列:
                    # [[2, 3],
                    #  [6, 7]]

# 布爾索引 (非常強大！)
mask = arr > 5
print(mask)        # 布爾數(shù)組: [[False False False False],
                   #           [False  True  True  True],
                   #           [ True  True  True  True]]
print(arr[mask])   # 獲取所有大于5的元素: [ 6  7  8  9 10 11 12]

# 花式索引 (使用整數(shù)數(shù)組進行索引)
rows = np.array([0, 2])
cols = np.array([1, 3])
print(arr[rows, cols]) # 獲取(0,1)和(2,3)位置上的元素: [ 2 12]

3.5數(shù)組計算

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 元素級運算
print(a + b)   # [5 7 9]
print(a * b)   # [4 10 18] (逐元素相乘，不是矩陣乘法！)
print(a ** 2)  # [1 4 9]
print(np.sin(a)) # 對每個元素求正弦

# 矩陣乘法 (使用 @ 運算符或 .dot() 方法)
x = np.array([[1, 2], [3, 4]])
y = np.array([[5, 6], [7, 8]])
print(x @ y)      # 矩陣乘法: [[19 22],
                  #           [43 50]]
print(x.dot(y))   # 同上

# 聚合函數(shù) (對整組數(shù)據(jù)進行計算)
arr = np.array([1, 2, 3, 4, 5])
print(arr.sum())      # 總和: 15
print(arr.mean())     # 平均值: 3.0
print(arr.std())      # 標準差
print(arr.min())      # 最小值: 1
print(arr.max())      # 最大值: 5
print(arr.argmax())   # 最大值的索引: 4