Python 中數(shù)據(jù)結(jié)構(gòu)的重要性不言而喻，它們是構(gòu)建高效、可維護(hù)代碼的基礎(chǔ)。數(shù)據(jù)結(jié)構(gòu)決定了如何存儲、組織和操作數(shù)據(jù)。理解和使用合適的數(shù)據(jù)結(jié)構(gòu)能夠極大地提升程序的性能、簡潔性以及代碼的可讀性。

Python 的基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)有 4 種，分別是 列表 (list)、元組 (tuple)、集合 (set) 和 字典 (dictionary)，它們都是 Python 內(nèi)置的，并不需要額外導(dǎo)入模塊?；A(chǔ)數(shù)據(jù)結(jié)構(gòu)廣泛用于存儲和操作數(shù)據(jù)，支持常見的增刪改查等操作。

Python 的高級數(shù)據(jù)結(jié)構(gòu)有 6 種，通常需要從 collections、heapq 和 queue 模塊導(dǎo)入，包括 雙端隊列 (deque)、默認(rèn)字典 (defaultdict)、有序字典 (OrderedDict)、計數(shù)器 (Counter)、堆 (heap) 和 優(yōu)先隊列 (Priority Queue)。這些高級數(shù)據(jù)結(jié)構(gòu)提供了更高效和專業(yè)化的功能，適用于復(fù)雜的場景如優(yōu)先級處理、計數(shù)統(tǒng)計、雙向數(shù)據(jù)操作等。

本文將會詳細(xì)介紹Python的基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)。

1、python基礎(chǔ)結(jié)構(gòu)

1.1 列表（list）

列表（list）是一種有序的、可變的序列，用于存儲多個元素。它是最常見的基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)之一，可以存儲任意類型的對象（數(shù)字、字符串、甚至其他列表）。

特點(diǎn):
有序: 元素按照插入順序排列。
可變: 可以動態(tài)添加、刪除和修改元素。
支持重復(fù)元素: 列表中的元素可以重復(fù)。
元素可以是不同類型: 列表可以包含任何類型的對象（數(shù)字、字符串、列表等）。

列表使用方括號 [] 來定義，元素用逗號分隔。列表可以很方便進(jìn)行元素訪問、切片、修改、添加、刪除，列表的長度使用 len() 函數(shù)可以獲取列表的長度，合并列表可以通過 + 操作符或 extend() 方法合并兩個列表，如果需要遍歷列表的索引和元素，可以使用 enumerate() 函數(shù)。列表的具體使用如下：

# 創(chuàng)建一個包含多種元素類型的列表
my_list = [1, 2, 3, 'hello', [4, 5]]  # 列表可以包含數(shù)字、字符串、甚至其他列表# 訪問列表中的元素
print(my_list[0])  # 輸出: 1，訪問第一個元素
print(my_list[-1])  # 輸出: [4, 5]，訪問最后一個元素（支持負(fù)索引）# 列表切片
print(my_list[1:3])  # 輸出: [2, 3]，從索引1開始到索引3之前的元素
print(my_list[:2])   # 輸出: [1, 2]，獲取從開始到索引2之前的元素
print(my_list[::2])  # 輸出: [1, 3, [4, 5]]，每隔一個元素取一次# 修改列表中的元素
my_list[1] = 'changed'  # 修改索引1處的元素為'changed'
print(my_list)  # 輸出: [1, 'changed', 3, 'hello', [4, 5]]# 添加元素到列表
my_list.append(6)  # 在列表末尾添加元素6
print(my_list)  # 輸出: [1, 'changed', 3, 'hello', [4, 5], 6]# 在指定位置插入元素
my_list.insert(2, 'new')  # 在索引2處插入'new'
print(my_list)  # 輸出: [1, 'changed', 'new', 3, 'hello', [4, 5], 6]# 刪除列表中的元素
removed = my_list.pop()  # 刪除并返回列表末尾的元素
print(removed)  # 輸出: 6，顯示被刪除的元素
print(my_list)  # 輸出: [1, 'changed', 'new', 3, 'hello', [4, 5]]my_list.remove('new')  # 刪除列表中的第一個'new'元素
print(my_list)  # 輸出: [1, 'changed', 3, 'hello', [4, 5]]# 獲取列表的長度
print(len(my_list))  # 輸出: 5，列表中包含5個元素# 合并兩個列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2  # 使用'+'操作符合并列表
print(combined)  # 輸出: [1, 2, 3, 4, 5, 6]list1.extend(list2)  # 使用extend方法合并list2到list1中
print(list1)  # 輸出: [1, 2, 3, 4, 5, 6]# 對列表排序
nums = [3, 1, 4, 2]
nums.sort()  # 原地排序
print(nums)  # 輸出: [1, 2, 3, 4]# 反轉(zhuǎn)列表
nums.reverse()  # 原地反轉(zhuǎn)列表
print(nums)  # 輸出: [4, 3, 2, 1]# 列表的遍歷
for item in my_list:print(item)  # 逐個打印列表中的元素# 使用enumerate同時獲取索引和值
for index, value in enumerate(my_list):print(f"Index: {index}, Value: {value}")  # 打印索引和值

列表的常用方法：

方法	描述
append(x)	將元素 x 添加到列表末尾
extend(iterable)	將可迭代對象的元素添加到列表末尾
insert(i, x)	在索引 i 處插入元素 x
remove(x)	刪除列表中第一個值為 x 的元素
pop([i])	移除并返回索引 i 處的元素（默認(rèn)移除最后一個元素）
clear()	移除列表中的所有元素
index(x[, start[, end]])	返回列表中第一個值為 x 的元素索引
count(x)	返回元素 x 在列表中出現(xiàn)的次數(shù)
sort(key=None, reverse=False)	對列表進(jìn)行原地排序
reverse()	原地反轉(zhuǎn)列表中的元素
copy()	返回列表的淺拷貝

列表的內(nèi)存管理與性能:
由于列表是動態(tài)數(shù)組，它的大小可以動態(tài)調(diào)整，這使得 Python 列表能夠以靈活的方式存儲不同大小的數(shù)據(jù)。然而，頻繁的插入和刪除操作（尤其是在列表的中間部分）可能導(dǎo)致性能下降，因為這些操作可能需要移動列表中的其他元素。

時間復(fù)雜度:
訪問元素: O(1)
在末尾添加元素 (append()): O(1)
插入或刪除（中間或開頭）: O(n)
遍歷列表: O(n)
排序: O(n log n)

應(yīng)用場景:
列表適用于需要按順序存儲數(shù)據(jù)且數(shù)據(jù)量較小的場景。
動態(tài)管理元素集合，例如任務(wù)列表、購物車、學(xué)生名單等。
適用于需要頻繁訪問、更新或追加數(shù)據(jù)的場景。

1.2 元組（tuple）

元組（tuple）是 Python 中的一種有序的、不可變的數(shù)據(jù)結(jié)構(gòu)。元組中的元素一旦創(chuàng)建后就不能被修改，因此它適用于存儲那些不需要更改的數(shù)據(jù)。元組類似于列表，但它的不可變性使它在某些場景下更高效，并且可以作為字典的鍵。

特點(diǎn):
有序: 元素按照插入順序排列。
不可變: 一旦元組被創(chuàng)建，就不能修改其內(nèi)容（不能添加、刪除、修改元素）。
支持重復(fù)元素: 元組中的元素可以重復(fù)。
元素可以是不同類型: 元組可以包含任意類型的元素（數(shù)字、字符串、列表，甚至另一個元組）。
輕量高效: 由于不可變性，元組在內(nèi)存和性能方面比列表更高效。

元組使用圓括號 () 定義，元素用逗號分隔。如果創(chuàng)建只有一個元素的元組，需要在元素后加一個逗號，否則會被識別為一個普通的類型。元組的具體操作如下：

# 創(chuàng)建一個元組
my_tuple = (1, 2, 3, 'hello', [4, 5])# 訪問元組中的元素
print(my_tuple[0])  # 輸出: 1
print(my_tuple[-1])  # 輸出: [4, 5]# 元組的長度
print(len(my_tuple))  # 輸出: 4，元組中有4個元素# 元組切片
print(my_tuple[1:3])  # 輸出: (2, 3)# 遍歷元組
for item in my_tuple:print(item)# 元組不可變性 
# my_tuple[1] = 'new_value'  # 這會引發(fā)錯誤，因為元組是不可變的   # 元組解包
a, b, c = (1, 2, 3)
print(a, b, c)  # 輸出: 1 2 3# 嵌套元組
nested_tuple = (1, (2, 3), (4, (5, 6)))
print(nested_tuple[2][1])  # 輸出: (5, 6)# 元組的方法
print(my_tuple.count(2))  # 輸出: 1，元素 2 出現(xiàn)了一次
print(my_tuple.index('hello'))  # 輸出: 3，'hello' 在索引 3 處

元組的常用方法：

方法	描述
count(x)	返回元素 x 在元組中出現(xiàn)的次數(shù)
index(x)	返回元素 x 在元組中第一次出現(xiàn)的索引位置

時間復(fù)雜度:
訪問元素: O(1)
遍歷元組: O(n)

元組的應(yīng)用場景:
不可變數(shù)據(jù)的存儲: 元組適用于存儲不需要更改的數(shù)據(jù)，例如數(shù)據(jù)庫表中的一行記錄、GPS 坐標(biāo)等。
字典的鍵: 因為元組是不可變的，所以它可以作為字典的鍵，而列表不行。
解包操作: 在函數(shù)返回多個值時，經(jīng)常使用元組解包來獲取這些值。
?

1.3 集合（set）

集合（set）是 Python 中的一種無序且不重復(fù)的可變數(shù)據(jù)結(jié)構(gòu)，用于存儲唯一的元素。集合主要用于執(zhí)行集合相關(guān)的操作，如交集、并集和差集等。集合中的元素必須是不可變的對象（例如，數(shù)字、字符串、元組），但集合本身是可變的。

特點(diǎn):
無序: 集合中的元素沒有固定順序，不能通過索引訪問元素。
元素唯一: 集合中的所有元素都是唯一的，自動去重。
可變: 可以動態(tài)添加、刪除元素。
高效查找: 集合基于哈希表實(shí)現(xiàn)，查找、插入、刪除操作的時間復(fù)雜度為 O(1)。
元素必須是不可變對象: 例如，數(shù)字、字符串、元組可以作為集合元素，而列表和字典不能。

集合可以使用大括號 {} 或內(nèi)置的 set() 函數(shù)創(chuàng)建。集合的操作如下：

# 創(chuàng)建集合
my_set = {1, 2, 3, 4, 4}  # 自動去重，重復(fù)的元素4只保留一個
print(my_set)  # 輸出: {1, 2, 3, 4}# 添加元素
my_set.add(5)  # 向集合中添加元素5
print(my_set)  # 輸出: {1, 2, 3, 4, 5}# 刪除元素
my_set.discard(5)  # 刪除元素5，不會引發(fā)錯誤
print(my_set)  # 輸出: {1, 2, 3, 4}# 隨機(jī)刪除并返回集合中的一個元素
popped_element = my_set.pop()  # 隨機(jī)刪除并返回一個元素
print(f"被刪除的元素: {popped_element}")
print(my_set)  # 輸出集合的剩余元素# 判斷元素是否存在
print(2 in my_set)  # 輸出: True，2 在集合中
print(5 in my_set)  # 輸出: False，5 不在集合中# 獲取集合的長度
print(f"集合長度: {len(my_set)}")  # 輸出: 集合長度# 清空集合
my_set.clear()  # 清空集合
print(my_set)  # 輸出: set()# 集合運(yùn)算
set1 = {1, 2, 3}
set2 = {3, 4, 5}print(set1 & set2)  # 輸出: {3}，交集
print(set1 | set2)  # 輸出: {1, 2, 3, 4, 5}，并集
print(set1 - set2)  # 輸出: {1, 2}，差集
print(set1 ^ set2)  # 輸出: {1, 2, 4, 5}，對稱差集（不同時存在于兩個集合中的元素）# 遍歷集合
for item in set1:print(f"集合中的元素: {item}")  # 逐個打印集合中的元素

集合的常用方法:

方法	描述
add(x)	向集合添加元素 x
remove(x)	刪除元素 x，若不存在則報錯
discard(x)	刪除元素 x，若不存在不報錯
pop()	隨機(jī)刪除一個元素并返回
clear()	清空集合
union(set)	返回兩個集合的并集
intersection(set)	返回兩個集合的交集
difference(set)	返回當(dāng)前集合與另一個集合的差集
symmetric_difference(set)	返回兩個集合的對稱差集
issubset(set)	判斷當(dāng)前集合是否為另一個集合的子集
issuperset(set)	判斷當(dāng)前集合是否為另一個集合的超集
isdisjoint(set)	判斷兩個集合是否沒有交集

時間復(fù)雜度:

插入元素: O(1)
刪除元素: O(1)
查找元素: O(1)
遍歷集合: O(n)

應(yīng)用場景:

去重: 適合用來快速去重。例如，將列表轉(zhuǎn)換為集合后可以自動去除重復(fù)元素。
集合運(yùn)算: 處理交集、并集、差集等集合相關(guān)操作的場景，如計算共同好友、差異項等。
快速查找: 利用集合的 O(1) 查找特性，適合用于大量元素的快速存在性檢查。

1.4?字典（dict）

字典（dict）是 Python 中的一種無序的、可變的數(shù)據(jù)結(jié)構(gòu)，用于存儲鍵值對（key-value）。每個鍵是唯一的，并且與對應(yīng)的值相映射。字典是 Python 中最常用的數(shù)據(jù)結(jié)構(gòu)之一，適合存儲和快速查找數(shù)據(jù)。

特點(diǎn):
無序（Python 3.7+ 版本中字典按插入順序保存，但仍稱為無序結(jié)構(gòu)）。
鍵唯一: 每個鍵在字典中是唯一的，重復(fù)的鍵會覆蓋之前的值。
可變: 可以動態(tài)添加、刪除、修改鍵值對。
鍵必須是不可變類型: 鍵可以是字符串、數(shù)字或元組，但不能是列表或字典。
快速查找: 字典查找操作的時間復(fù)雜度是 O(1)，非常高效。

字典使用大括號 {} 定義，鍵值對之間使用逗號分隔，鍵和值使用冒號 : 分隔。字典的操作如下：

# 創(chuàng)建字典
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}# 訪問字典中的值
print(my_dict['name'])  # 輸出: Alice# 使用 get() 方法訪問不存在的鍵時返回默認(rèn)值
print(my_dict.get('country', 'Not Found'))  # 輸出: Not Found# 修改字典中的值
my_dict['age'] = 26
print(my_dict)  # 輸出: {'name': 'Alice', 'age': 26, 'city': 'New York'}# 添加新的鍵值對
my_dict['country'] = 'USA'
print(my_dict)  # 輸出: {'name': 'Alice', 'age': 26, 'city': 'New York', 'country': 'USA'}# 刪除鍵值對
my_dict.pop('city')  # 刪除鍵 'city'
print(my_dict)  # 輸出: {'name': 'Alice', 'age': 26, 'country': 'USA'}# 使用 del 刪除鍵值對
del my_dict['age']
print(my_dict)  # 輸出: {'name': 'Alice', 'country': 'USA'}# 獲取字典的鍵、值和鍵值對
print(my_dict.keys())    # 輸出: dict_keys(['name', 'country'])
print(my_dict.values())  # 輸出: dict_values(['Alice', 'USA'])
print(my_dict.items())   # 輸出: dict_items([('name', 'Alice'), ('country', 'USA')])# 遍歷字典的鍵值對
for key, value in my_dict.items():print(f"Key: {key}, Value: {value}")# 合并兩個字典
other_dict = {'age': 30, 'job': 'Engineer'}
my_dict.update(other_dict)
print(my_dict)  # 輸出: {'name': 'Alice', 'country': 'USA', 'age': 30, 'job': 'Engineer'}# 清空字典
my_dict.clear()
print(my_dict)  # 輸出: {}

字典的常用方法:

方法	描述
get(key[, default])	返回指定鍵的值，如果鍵不存在，返回默認(rèn)值
pop(key[, default])	刪除并返回指定鍵的值
keys()	返回字典中所有鍵
values()	返回字典中所有值
items()	返回字典中所有鍵值對
update(dict)	使用另一個字典或鍵值對更新當(dāng)前字典
clear()	清空字典
copy()	返回字典的淺復(fù)制

時間復(fù)雜度:
訪問元素: O(1)
插入/刪除元素: O(1)
遍歷字典: O(n)

應(yīng)用場景:
快速查找數(shù)據(jù): 通過唯一鍵快速查找對應(yīng)的值，如用戶名到用戶數(shù)據(jù)的映射。
存儲配置信息: 字典常用于存儲配置信息，如應(yīng)用程序的設(shè)置參數(shù)。
數(shù)據(jù)映射: 字典非常適合存儲映射關(guān)系，如商品 ID 到商品詳情的映射。