python之列表的高級應(yīng)用及說明

更新時間：2026年05月07日 11:32:53 作者：一只勤勞的耗子

本文介紹了Python列表的基本概念、定義方式及應(yīng)用,包括如何定義列表、統(tǒng)計元素、數(shù)據(jù)增刪改查、列表索引取值、深淺拷貝的區(qū)別與應(yīng)用方法等,此外,還詳細(xì)講解了列表的迭代、數(shù)據(jù)處理、緩存機(jī)制及常見的數(shù)據(jù)結(jié)構(gòu)算法,如線性搜索、二分搜索、排序算法等

列表（list）是Python編程語言中的基本數(shù)據(jù)類型之一，也是一個非常重要的通用序列。在其它編程語言中，它們通常被稱為“數(shù)組”?？梢源鎯Χ鄠€元素，包括數(shù)字、字符串、甚至其他列表，是最常用的數(shù)據(jù)類型之一。

這篇文章主要介紹列表的各種處理方式和應(yīng)用方法。

1. 如何定義列表

列表可以使用兩個方式定義：

l = []        # 定義一個空列表
l = list()    # 定義一個空列表

列表用方括號 [ ] 來表示，左括號開始，右括號結(jié)束。括號中的數(shù)據(jù)稱為元素，這些元素以逗號分割，可以是數(shù)字、字符串，或者列表。

# 定義一個列表，包含數(shù)字、字符串和列表
l = [123 ,'AAA', [10, 20]]

在定義列表式時，除了手動去固定寫入元素外，還可以使用迭代來定義：

l = [x for x in range(1, 6)]

將函數(shù)的返回值或結(jié)果賦值給列表也是同理。

那么列表的作用是什么呢？

比如某個項目需要一個自動化框架，將需要處理的內(nèi)容寫到 Excel 文件中，再通過這個框架去讀取文件內(nèi)容，那么列表可以作為臨時存儲空間，將其保存到內(nèi)部后開始操作：

# 將文件名放入列表中
file = ['file1.xlsx', 'file2.xlsx', 'file3.xlsx']

# 遍歷這個列表中的文件名
for f in file:
    print(f"開始執(zhí)行項目，處理文件：{f}")
    '''省略處理文件的代碼'''

列表的各種應(yīng)用方法見《目錄3》

2. 處理列表的方式

列表的主要處理方法包括：增刪改查、索引取值、深拷貝和淺拷貝的區(qū)別，下面按章節(jié)逐個介紹。

2.1. 統(tǒng)計元素

在列表中，用逗號分割的字符被稱為元素，比如：

l = [ 100, 200, 'AAA', 'BBB' ]

這里面包含4個元素，這四個元素分別是100、200、AAA、BBB。與字符串不同，字符串是按單個字符統(tǒng)計，列表是按分隔符統(tǒng)計。

例：獲取第2個元素

l = [ 100, 200, 'AAA', 'BBB' ]
print(l[1])

直接通過索引即可（索引的具體用法見《目錄 2.5》）

統(tǒng)計元素的方法如下：

len：統(tǒng)計元素個數(shù)
count：統(tǒng)計某個元素出現(xiàn)的次數(shù)
max：統(tǒng)計最大的數(shù)值
min：統(tǒng)計最小的數(shù)值
sort：數(shù)字升序排序
sorted：數(shù)字升序或降序排序
reverse：元素反轉(zhuǎn)

【方式一】統(tǒng)計元素的個數(shù) len

l = [ 100, 200, 'AAA', 'BBB' ]
len(l)

【方式二】統(tǒng)計某個元素出現(xiàn)的個數(shù) count

l = [ 100, 200, 'AAA', 'BBB' ]
l.count("A")

注意：count的查看元素的個數(shù)，而不是單個字符的個數(shù)

【方式三】查詢最大值max（僅支持?jǐn)?shù)字）

L = [3, 43, 2, 98]
max(L)

【方式四】查詢最小值 min（僅支持?jǐn)?shù)字）

L = [3, 43, 2, 98]
min(L)

【方式五】升序sort、sorted（僅支持?jǐn)?shù)字）

L1 = [4, 1, 9]
L1.sort()

L2 = [5, 3, 7]
L2 = sorted(L2, reverse=False)

【方式六】降序sorted（僅支持?jǐn)?shù)字）

L = [5, 3, 7]
L = sorted(L, reverse=True)

【方式七】元素反轉(zhuǎn) reverse

L = [ 100, 200, 'AAA', 'BBB' ]
L.reverse()

2.2. 添加元素

列表可以通過索引指定位置添加元素，也可以直接向列表最后面追加元素。

insert：按索引添加
append：在列表后面追加1個元素
extend：在列表后面追加多個元素

【方式一】指定索引添加元素 insert

'''方法1'''
L = [ 100, 200, 'AAA', 'BBB' ]
L.insert(0, 500)    # 在索引為0處添加元素

'''方法2'''
L = [ 100, 200, 'AAA', 'BBB' ]
L[0:0] = [500]      # 在索引為0處添加元素

在索引為1處添加多個元素

L = [ 100, 200, 'AAA', 'BBB' ]
L[1:1] = [500, 'EEE']      # 在索引為1處添加元素

【方式二】在列表后面追加元素 append

L = [1, 2, 3]
L.append('AAA')

append 不支持追加多個元素，但可以使用符號 +

L = [1, 2, 3]
L = L + ['AAA', 'BBB']

【方式三】追加多個元素extend

L = [1, 2, 3]
L.extend(('a', 'b', 10))    # 需要使用一個括號

直接迭代添加整數(shù)

L = ['A', 'B', 'C']
L.extend(range(10,15))    # 使用range迭代

2.3. 修改元素

python 一般利用索引來修改元素

【方式一】按索引修改單個元素

L = ['A', 'B', 'C', 'D', 'E']
L[0] = 10    # 修改第1個元素
L[-1] = 20   # 修改最后1個元素

【方式二】按索引修改多個元素

L = ['A', 'B', 'C', 'D', 'E']
L[:3] = [10, 20]    # 將前3個元素修改為2個元素

【方式三】迭代修改指定的元素名

L = [100, 'BBB', 'AAA', 'BBB', 'BBB']
# 用迭代的方式將BBB修改為EEE
new_L = [elem if elem != 'BBB' else 'EEE' for elem in L]

2.4. 刪除元素

python 支持通過索引刪除和元素名刪除

【方式一】按索引刪除元素 del、pop

L = ['A', 'B', 'C', 'D', 'E']

# del支持刪除多個元素
del L[0]
del L[:3]

# pop只支持刪除一個元素
L.pop(0)    # 刪除第一個元素

【方式二】按元素名刪除 remove

L = ['A', 'B', 'C', 'B', 'D']
L.remove('B')    # 僅支持刪除1個元素

【方式三】按元素名刪除多個元素（迭代）

L = ['A', 'B', 'C', 'B', 'D']
d = ['A', 'B']  # 需要刪除的元素列表
new_L = [elem for elem in L if elem not in d]    # 迭代刪除

【方式四】按索引刪除多個元素（迭代）

del_index=[0, 1, 2]    #指定要刪除的索引下標(biāo)，不能使用負(fù)數(shù)(-1)
L1 = ['a', 'b', 'c', 'd', 'e']
L2=[i for num,i in enumerate(L1) if num not in del_index]

2.5. 索引取值

索引（Index）是用于標(biāo)識和訪問數(shù)據(jù)結(jié)構(gòu)中元素的位置或標(biāo)簽，在Python中，索引用于訪問字符串、列表、元組和其他序列類型的元素。

索引的值從0開始

元素：a b c d e f
索引：0 1 2 3 4 5

第1個元素的索引為0，第2個元素的索引為1，以此類推。。。

讀取對應(yīng)索引的值使用變量[ ] 的方式

L = ['a', 'b', 'c', 'd', 'e']
L[0]    # 讀取第1個元素
L[3]    # 讀取第4個元素
L[-1]   # 讀取最后1個元素

除了讀取單個元素，還能通過切片的方式范圍讀取

變量[起始索引:結(jié)束索引]

L = ['a', 'b', 'c', 'd', 'e']
L[:2]    # 讀取前2個元素
L[-2:]   # 讀取后2個元素
L[1:3]   # 讀取索引為1~2的元素

第1個元素用0表示，最后1個元素用-1表示。
范圍讀取時冒號前面為空（默認(rèn)讀取前面全部），冒號后面為空（默認(rèn)讀取后面全部）。
范圍取值時不包括結(jié)束索引。[1:3] 表示讀取索引1,2；[3:6] 表示讀取索引3,4,5。

切片時支持指定步長

變量[起始索引:結(jié)束索引:步長]    # 步長默認(rèn)1

L = ['a', 'b', 'c', 'd', 'e']
L[1::1]  # 讀取索引為1和后面的元素，步長為1
L[1::2]  # 讀取索引為1和后面的元素，步長為2
L[::2]   # 讀取全部元素，步長為2

2.6. 拷貝方式

python 支持深拷貝和淺拷貝兩種方式。

深拷貝復(fù)制對象及其子對象本身，遞歸地復(fù)制整個對象結(jié)構(gòu)。改變原始對象中的子對象不會影響到深拷貝后的對象。
淺拷貝僅復(fù)制對象的引用，而不復(fù)制子對象本身。改變原始對象中的子對象也會影響到淺拷貝后的對象。

它們各自的優(yōu)點(diǎn)

深拷貝的優(yōu)點(diǎn)是創(chuàng)建了一個全新的獨(dú)立對象，可以對深拷貝后的對象進(jìn)行修改，而不會影響到原始對象。深拷貝通常用于需要獨(dú)立副本的場景，特別是在進(jìn)行遞歸操作或修改子對象時。
淺拷貝的優(yōu)點(diǎn)是速度較快，因為它僅復(fù)制引用而不進(jìn)行實(shí)際的復(fù)制操作。如果原始對象的子對象較大而且不會被修改，那么淺拷貝可以節(jié)省大量的內(nèi)存。

他們各自的缺點(diǎn)

深拷貝的缺點(diǎn)：它可能會消耗更多的內(nèi)存和處理時間，特別是當(dāng)要復(fù)制的對象結(jié)構(gòu)較大、嵌套層級較深時。進(jìn)行深拷貝可能需要遞歸地復(fù)制整個對象，這可能會導(dǎo)致性能下降。
淺拷貝的缺點(diǎn)：如果原始對象中的子對象是可變的，那么改變原始對象中的子對象也會影響到淺拷貝后的對象，可能會導(dǎo)致意外的副作用。

定義一個深拷貝需要導(dǎo)入標(biāo)準(zhǔn)庫 copy

# 導(dǎo)入標(biāo)準(zhǔn)庫
import copy

# 定義一個列表a
a = [1, 2, 3, [4, 5]]

# 將列表a的值深拷貝到b
b = copy.deepcopy(a)

淺拷貝可以使用 copy() 函數(shù)實(shí)現(xiàn)，或者直接賦值

# 方式一
a = [1, 2, 3, [4, 5]]
b = a.copy()

# 方式二
a = [1, 2, 3, [4, 5]]
b = [a, "BBB"]

注意：修改原始列表，淺拷貝過去的列表不會發(fā)生變化

a = [1, 2, 3, [4, 5]]
b = a.copy()

對于淺拷貝，它僅僅是復(fù)制了列表對象的引用，所以當(dāng)你改變原始列表（例如修改索引為0的值）時，只有原始列表受到影響，而副本不會受到影響。也就是說只有改變子對象，淺拷貝的值才會發(fā)生變化。

3. 列表的應(yīng)用方法

3.1. 迭代循環(huán)

迭代循環(huán)是列表慣用的方式，比如直接循環(huán)列表中的元素

L = [1, 2, 3, [4, 5]]
for i in L:
    print(f"當(dāng)前元素為：{i}")

除了直接遍歷元素，還能遍歷該元素的索引enumerate

# 定義列表
L = ['AAA', 'BBB', 'CCC']

# 遍歷列表中的索引和元素
for index,element in enumerate(L):
    print(f"索引：{index}, 元素：{element}")

索引的起始值為0，所以默認(rèn)從0開始。如果業(yè)務(wù)有其他需求，我們還可以指定從1開始

# 定義列表
L = ['AAA', 'BBB', 'CCC']

# 遍歷列表中的索引和元素
for index,element in enumerate(L, start=1):
    print(f"索引：{index}, 元素：{element}")

3.2. 數(shù)據(jù)處理

我們時常使用列表來存儲和操作數(shù)據(jù)集，不少操作中需要進(jìn)行排序、過濾、計算等操作，介紹幾種方法：

【方式一】列表排序（元素僅支持?jǐn)?shù)字）

L = [4, 2, 1, 3, 5]
L.sort()  # 升序
L = sorted(L, reverse=False)    # 升序
L = sorted(L, reverse=True)     # 降序
L.reverse()  # 反轉(zhuǎn)

【方式二】過濾列表（篩選偶數(shù)）

# 定義一個全數(shù)字的列表
L = [1, 2, 3, 4, 5]
# 過濾偶數(shù)
L_new = list(filter(lambda x: x % 2 == 0, L))

【方式三】計算列表的值

# 定義一個全是數(shù)字的列表
L = [1, 2, 6, 8, 5, 10]

# 求和
sum_result = sum(L)

# 求最大值
max_result = max(L)

# 求最小值
min_result = min(L)

# 求平均值
avg_result = sum(L) / len(L)

# 所有值乘以 10
multiplied_list = [x * 10 for x in L]

3.3.實(shí)現(xiàn)緩存

列表的可變性使其適用于實(shí)現(xiàn)緩存機(jī)制，可以存儲臨時的計算結(jié)果或其他需要快速訪問的數(shù)據(jù)。

# 封裝一個使用列表緩存的類
class ListCache:
    def __init__(self, max_size):
        self.max_size = max_size   # 緩存的最大容量
        self.cache = []            # 定義一個空的緩存列表

    def get(self, key):
        '''檢查是否有對應(yīng)的緩存項'''
        for item in self.cache:
            if item['key'] == key:
                return item['value']
        return None

    def set(self, key, value):
        '''判斷緩存是否已滿'''
        if len(self.cache) >= self.max_size:
            self.cache.pop(0)   # FIFO方式移除最舊的緩存項

        # 使用字典的方式添加新的緩存項
        self.cache.append({'key': key, 'value': value})

if __name__ == '__main__':
    # 創(chuàng)建一個最大容量為 2 的緩存
    LC = ListCache(2)

    # 向方法中添加兩個緩存數(shù)據(jù)
    LC.set('k1', 'AAA')
    LC.set('k2', 'BBB')

    # 查看結(jié)果
    print(LC.get('k1'))     # AAA
    print(LC.get('k2'))     # BBB

    # 向方法中添加第3個緩存數(shù)據(jù)
    LC.set('k3', 'CCC')
    print(LC.get('k1'))     # 此時的k1已經(jīng)被清理

3.4.數(shù)據(jù)結(jié)構(gòu)算法

列表是一種常見的數(shù)據(jù)結(jié)構(gòu)，它可以存儲多個元素，并且元素的順序是有序的。這里列舉幾種常見的算法

① 線性搜索

線性搜索的方式是從列表的起始位置開始逐個比較元素，直到找到目標(biāo)元素或遍歷完整個列表

代碼如下

# 定義一個列表
arr = [4, 2, 7, 1, 9, 5]
# 需要查找的值
target = 7

def linear_search(arr, target):
    # 遍歷該數(shù)組的長度
    for i in range(len(arr)):
        # 通過索引來判斷這個值是否為真
        if arr[i] == target:
            return i  # 返回目標(biāo)元素的索引
    return -1  # 如果目標(biāo)元素不存在于列表中，返回 -1

# 傳入列表和需要查找的值
index = linear_search(arr, target)
print(f"元素{target}的索引為：{index}")

② 二分搜索

二分搜索要求列表是有序的。通過將列表分成兩半并與中間元素進(jìn)行比較，以確定目標(biāo)元素位于哪一半，然后再在該半中進(jìn)行搜索。該算法的時間復(fù)雜度為 O(log n)，比線性搜索更高效。

代碼如下

# 定義一個列表
arr = [1, 12, 4, 6, 7, 3]
# 需要查詢的值
target = 7

def binary_search(arr, target):
    arr.sort()  # 先將數(shù)組排序（升序）
    low = 0     # 定義最小索引
    high = len(arr) - 1     # 定義最大索引

    while low <= high:
        mid = (low + high) // 2 # 取中間索引的值（整數(shù)）
        if arr[mid] == target:  # 判斷是否該索引的值等于target
            return mid          # 為真，返回目標(biāo)元素的索引
        elif arr[mid] < target:
            low = mid + 1       # 如果結(jié)果小于target，將索引+1
        else:
            high = mid - 1      # 如果結(jié)果大于target，將索引-1

    return -1  # 如果目標(biāo)元素不存在于列表中，返回 -1

# 向函數(shù)中傳入列表和需要查找的值
index = binary_search(arr, target)
print("目標(biāo)元素的索引：", index)

③ 排序算法

冒泡排序

arr = [4, 2, 7, 1, 9, 5]

def bubble_sort(arr):
    n = len(arr)

    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

sorted_arr = bubble_sort(arr)
print("排序后的列表：", sorted_arr)

插入排序

arr = [4, 2, 7, 1, 9, 5]

def insertion_sort(arr):
    n = len(arr)

    for i in range(1, n):
        key = arr[i]
        j = i - 1

        while j >= 0 and arr[j] > key:
            arr[j+1] = arr[j]
            j -= 1
        
        arr[j+1] = key
    
    return arr

sorted_arr = insertion_sort(arr)
print("排序后的列表：", sorted_arr)

選擇排序

arr = [4, 2, 7, 1, 9, 5]

def selection_sort(arr):
    n = len(arr)

    for i in range(n-1):
        min_index = i
        for j in range(i+1, n):
            if arr[j] < arr[min_index]:
                min_index = j
            
        arr[i], arr[min_index] = arr[min_index], arr[i]
    return arr

sorted_arr = selection_sort(arr)
print("排序后的列表：", sorted_arr)

快速排序

arr = [4, 2, 7, 1, 9, 5]

def quick_sort(arr):
    if len(arr) <= 1:
        return arr

    pivot = arr[0]
    less = [x for x in arr[1:] if x <= pivot]
    greater = [x for x in arr[1:] if x > pivot]

    return quick_sort(less) + [pivot] + quick_sort(greater)

sorted_arr = quick_sort(arr)
print("排序后的列表：", sorted_arr)

歸并排序

arr = [4, 2, 7, 1, 9, 5]

def merge_sort(arr):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left_half = arr[:mid]
    right_half = arr[mid:]

    left_half = merge_sort(left_half)
    right_half = merge_sort(right_half)

    return merge(left_half, right_half)

def merge(left, right):
    result = []
    i, j = 0, 0

    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result.extend(left[i:])
    result.extend(right[j:])

    return result

sorted_arr = merge_sort(arr)