Python的列表常用方法詳解

更新時(shí)間：2019年06月14日 10:11:30 作者：殤淋獄陌

本文介紹了Python語言的列表及其操作方法,還介紹了列表的運(yùn)算,通過實(shí)例,展示了列表生成式和傳統(tǒng)方法的對比,以及如何使用生成式對列表進(jìn)行高效的生成和操作,感興趣的朋友一起看看吧

一、列表

列表是由一系元素按特定順序構(gòu)成的數(shù)據(jù)序列，這就意味著如果我們定義一個(gè)列表類型的變量，可以用它來保存多個(gè)數(shù)據(jù)。在 Python 中，可以使用[]字面量語法來定義列表，列表中的多個(gè)元素用逗號進(jìn)行分隔

特點(diǎn)：

列表中可以有重復(fù)元素；
列表中可以有不同類型的元素；

二、序列類型-列表

在操作序列類型數(shù)據(jù)的時(shí)候，會經(jīng)常用到增刪改查操作，所以Python給我們提供了一些內(nèi)置的功能函數(shù)：
作用就是幫助我們更好的對數(shù)據(jù)增刪改查。
方法都是固定好的語法，不需要去死記硬背。
用pycharm，有代碼補(bǔ)全，如果忘了，翻筆記/查資料。

什么是內(nèi)置方法：
內(nèi)置方法是python自帶的方法，直接可以使用；
好處：可以用來快速處理數(shù)據(jù)。

1、列表

1.1 創(chuàng)建列表

在Python中，列表是由一系元素按特定順序構(gòu)成的數(shù)據(jù)序列，這就意味著如果我們定義一個(gè)列表類型的變量，可以用它來保存多個(gè)數(shù)據(jù)。在 Python 中，可以使用[]字面量語法來定義列表，列表中的多個(gè)元素用逗號進(jìn)行分隔，代碼如下所示。

# 列表：列表是由一系列元素按特定順序組成的數(shù)據(jù)序列；
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 9.0, True, 'Hello']
b = ['python', 'java', 'ruby', 'javascript']
c = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(a)  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 9.0, True, 'Hello']
print(b)  # ['python', 'java', 'ruby', 'javascript']
print(c)  # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

1.2 列表的訪問

列表的訪問：與字符串一樣，列表索引是從0開始，第二個(gè)索引是1，依此類推。通過索引列表，可以進(jìn)行截取、組合等操作。

list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

索引也可以從尾部開始，最后一個(gè)元素的索引為 -1，往前一位為 -2，以此類推。

使用下標(biāo)索引來訪問列表中的值，同樣你也可以使用方括號 [] 的形式截取字符，如下所示：

1.3 特別注意事項(xiàng)

列表中可以有重復(fù)元素，例如a中的9；列表中可以有不同類型的元素，例如a中有int類型、float類型、str類型和bool類型的元素，但是我們通常并不建議將不同類型的元素放在同一個(gè)列表中，主要是操作起來極為不便。

1.4list()函數(shù)

通過 Python 內(nèi)置的list()函數(shù)將其他序列變成列表。準(zhǔn)確的說，list并不是一個(gè)普通的函數(shù)，它是創(chuàng)建列表對象的構(gòu)造器，后面會為大家介紹對象和構(gòu)造器這些概念。

hello = 'Python, Hello!'
d = list(hello)
print(d)  # ['P', 'y', 't', 'h', 'o', 'n', ',', ' ', 'H', 'e', 'l', 'l', 'o', '!']

2、列表的方法

列表類型的變量，擁有很多方法，比如增（append()、insert()、extend()）、刪（pop()、remove()、del、clear()）、改（通過索引直接修改）、查（所有的查詢方法，里面的內(nèi)容是顯示出來看的，而不是修改的,，所以都要加print）、排序（sort()）等等方法。

2.1 增-添加元素

列表是一種可變?nèi)萜?，可變?nèi)萜髦傅氖俏覀兛梢韵蛉萜髦刑砑釉?、可以向容器中移除元素、也可以向現(xiàn)有容器中修改元素。我們可以使用append()方法向列表中追加元素，使用insert()向列表中插入元素。追加指的是將元素添加到列表的末尾，而插入則是在指定的位置添加新元素。

2.1.1append()

追加一個(gè)數(shù)據(jù)，添加一個(gè)數(shù)據(jù)到列表的最后一位：

列表名.append(內(nèi)容)

food.append('可樂')

2.1.2insert()

在指定的位置上添加一個(gè)數(shù)據(jù)，原數(shù)據(jù)會被擠到后面，也就是插隊(duì)。

列表名.insert(下標(biāo),內(nèi)容)

food.insert(0,'烤鴨')

2.1.3extend()

追加一個(gè)序列類型,把數(shù)據(jù)打散/拆分后再添加。

列表.extend(序列內(nèi)容) 【加的數(shù)據(jù)他可以是單個(gè)元素,也可以是列表元組等等但是不能是單個(gè)數(shù)字】

food.extend('麻辣燙')

2.1.4 代碼示例

# 定義一個(gè)列表
food = ['蘋果', '香蕉', '珍珠奶茶', '西瓜', '炸雞', '雞爪', '粑粑柑']
# 列表方法
# 增 append()
# 追加一個(gè)元素 “可樂”
food.append('可樂')  # ['蘋果', '香蕉', '珍珠奶茶', '西瓜', '炸雞', '雞爪', '粑粑柑', '可樂']
print(food)
# 在西瓜后面插入一個(gè)元素“缽缽雞”
food.insert(4, '缽缽雞')  # ['蘋果', '香蕉', '珍珠奶茶', '西瓜', '缽缽雞', '炸雞', '雞爪', '粑粑柑', '可樂']
print(food)
# 追加一個(gè)序列類型，比如“餃子”
food.extend('餃子')  # ['蘋果', '香蕉', '珍珠奶茶', '西瓜', '缽缽雞', '炸雞', '雞爪', '粑粑柑', '可樂', '餃', '子']
print(food)

2.2 刪-刪除元素

我們可以用列表的remove方法從列表中刪除指定元素，需要注意的是，如果要刪除的元素并不在列表中，會引發(fā)ValueError錯誤導(dǎo)致程序崩潰，所以建議大家在刪除元素時(shí)，先用之前講過的成員運(yùn)算做一個(gè)判斷。我們還可以使用pop方法從列表中刪除元素，pop方法默認(rèn)刪除列表中的最后一個(gè)元素，當(dāng)然也可以給一個(gè)位置，刪除指定位置的元素。在使用pop方法刪除元素時(shí)，如果索引的值超出了范圍，會引發(fā)IndexError異常，導(dǎo)致程序崩潰。除此之外，列表還有一個(gè)clear方法，可以清空列表中的元素。

2.2.1pop()

刪除一個(gè)值，默認(rèn)從最后一個(gè)元素開始刪除，也可以刪指定下標(biāo)。

列表.pop()

food.pop()  # 默認(rèn)刪最后一個(gè)元素

列表.pop(下標(biāo))

food.pop(0)  # 默認(rèn)刪第一個(gè)元素

2.2.2remove()

刪除一個(gè)指定的值，如果有多個(gè)重復(fù)的數(shù)據(jù)，就從第一個(gè)開始刪：

列表.remove(數(shù)據(jù))

food.remove('雞腿')

2.2.3clear()

清空列表里的所有數(shù)據(jù)：

列表.clear()

food.clear()

2.2.4del刪除數(shù)據(jù)

直接刪除變量或者刪除變量中的某個(gè)值：

del變量名

del food  # 刪除food這個(gè)變量

del列表[下標(biāo)]

del food[2] # 刪除下標(biāo)為2的數(shù)據(jù)

2.2.5 代碼示例

# 定義一個(gè)列表
food = ['蘋果', '香蕉', '珍珠奶茶', '西瓜', '炸雞', '雞爪', '粑粑柑']
# 列表方法
# 增 append()
# 追加一個(gè)元素 “可樂”
food.append('可樂')  # ['蘋果', '香蕉', '珍珠奶茶', '西瓜', '炸雞', '雞爪', '粑粑柑', '可樂']
print(food)
# 在西瓜后面插入一個(gè)元素“缽缽雞”
food.insert(4, '缽缽雞')  # ['蘋果', '香蕉', '珍珠奶茶', '西瓜', '缽缽雞', '炸雞', '雞爪', '粑粑柑', '可樂']
print(food)
# 追加一個(gè)序列類型，比如“餃子”
food.extend('餃子')  # ['蘋果', '香蕉', '珍珠奶茶', '西瓜', '缽缽雞', '炸雞', '雞爪', '粑粑柑', '可樂', '餃', '子']
print(food)
# 定義一個(gè)列表
food_list = ['蘋果', '香蕉', '珍珠奶茶', '西瓜', '炸雞', '雞爪', '粑粑柑']
print(food_list)  # ['蘋果', '香蕉', '珍珠奶茶', '西瓜', '炸雞', '雞爪', '粑粑柑']
# 刪除一個(gè)值,默認(rèn)從最后一個(gè)數(shù)據(jù)開始刪,也可以刪指定下標(biāo)
food_list.pop()
print(food_list)  # ['蘋果', '香蕉', '珍珠奶茶', '西瓜', '炸雞', '雞爪']
# 刪除指定下標(biāo)的數(shù)據(jù)，比如刪除蘋果
food_list.pop(0)
print(food_list)  # ['香蕉', '珍珠奶茶', '西瓜', '炸雞', '雞爪']
# 刪除一個(gè)指定的值,如果有多個(gè)重復(fù)的數(shù)據(jù).就從第一個(gè)開始刪 先追加一個(gè)蘋果、一個(gè)粑粑柑、一個(gè)炸雞
food_list.insert(0,'蘋果')
food_list.append('蘋果')
food_list.append('粑粑柑')
food_list.append('蘋果')
food_list.append('粑粑柑')
food_list.append('炸雞')
print(food_list)  # ['蘋果', '香蕉', '珍珠奶茶', '西瓜', '炸雞', '雞爪', '蘋果', '粑粑柑', '蘋果', '粑粑柑', '炸雞']
# 使用remove來刪除炸雞
food_list.remove('炸雞')
print(food_list)  # ['蘋果', '香蕉', '珍珠奶茶', '西瓜', '雞爪', '蘋果', '粑粑柑', '蘋果', '粑粑柑', '炸雞']
# 清空列表中的所有數(shù)據(jù)
# food_list.clear()
print(food_list)  # []
# 刪除數(shù)據(jù).直接刪除這個(gè)變量或者變量中的值
# del food_list
print(food_list)  # 直接報(bào)錯 NameError: name 'food_list' is not defined
del food_list[0]
print(food_list)  # ['香蕉', '珍珠奶茶', '西瓜', '雞爪', '蘋果', '粑粑柑', '蘋果', '粑粑柑', '炸雞']

2.3 改-改列表中的元素

2.3.1 修改單個(gè)值

列表[下標(biāo)] = 值
```
food[0] = "洋芋"
```

2.3.2 修改多個(gè)值

列表[起點(diǎn):終點(diǎn)] = 數(shù)據(jù)1，數(shù)據(jù)2，數(shù)據(jù)3，…

food[1:4] = '珍珠奶茶','楊枝甘露','草莓奶茶','抹茶拿鐵'

2.4 查-查詢列表中的元素

所有的查詢方法，里面的內(nèi)容是顯示出來看的，而不是修改的，所以都要加print；

```
number=[1,2,5,3,4,68,4,2,6,1,1,66]
```

2.4.1index：根據(jù)內(nèi)容，獲取指定數(shù)據(jù)的下標(biāo)

列表.index(數(shù)據(jù))

print(number.index(5)) # 默認(rèn)從下標(biāo)為0的位置開始搜索 得到2

列表.index(數(shù)據(jù),起點(diǎn)下標(biāo))

print(number.index(1,2)) # 從起點(diǎn)下標(biāo)開始找數(shù)據(jù) 得到9

2.4.2count求和

統(tǒng)計(jì)數(shù)據(jù)出現(xiàn)的次數(shù)

列表.count(數(shù)據(jù))

print(number.count(2))  # 得到結(jié)果2

2.5 排序

對列表的內(nèi)容進(jìn)行排序；如果列表里面有字符串是不可以排序。

列表.sort()

num.sort() # 默認(rèn)是升序排序,從小到大

列表.sort(reverse = True)

num.sort(reverse = True) # 降序排序.從大大小

number = [1, 2, 5, 3, 4, 68, 4, 2, 6, 1, 1, 66]
print(number.index(5))  # 2
print(number.index(1, 2))  # 9
print(number.count(2))  # 2

number1 = number.sort()
print(number1)  # None
print(number)  # [1, 1, 1, 2, 2, 3, 4, 4, 5, 6, 66, 68]
number2 = number.sort(reverse=True)
print(number2)  # None
print(number)  # [68, 66, 6, 5, 4, 4, 3, 2, 2, 1, 1, 1]

代碼解釋：

number1 = number.sort() → None ??

關(guān)鍵陷阱：list.sort() 是原地排序（in-place），返回 None。

number1 = number.sort()
# number  變成了 [1, 1, 1, 2, 2, 3, 4, 4, 5, 6, 66, 68]
# number1 是 None

number2 = number.sort(reverse=True) → None

再次原地排序并反轉(zhuǎn)，number2 依然是 None。此時(shí) number 變?yōu)榻敌颍?/p>

# number 變?yōu)?[68, 66, 6, 5, 4, 4, 3, 2, 2, 1, 1, 1]

需求	正確寫法	說明
原地排序，不返回新列表	`number.sort()`	修改原列表，返回 `None`
返回新列表，不修改原列表	`sorted(number)`	原列表不變，返回排序后的新列表

number = [1, 2, 5, 3, 4, 68, 4, 2, 6, 1, 1, 66]
number1 = sorted(number)
print(number1)  # [1, 1, 1, 2, 2, 3, 4, 4, 5, 6, 66, 68]
number2 = sorted(number, reverse=True)
print(number2)  # [68, 66, 6, 5, 4, 4, 3, 2, 2, 1, 1, 1]

核心要點(diǎn)：sort() 修改列表本身，永遠(yuǎn)返回 None。要獲得排序后的新列表，請使用 sorted()。

2.6 列表方法總結(jié)

Python列表常用方法:

序號	方法
1	`list.append(obj)` 在列表末尾添加新的對象
2	`list.count(obj)` 統(tǒng)計(jì)某個(gè)元素在列表中出現(xiàn)的次數(shù)
3	`list.extend(seq)`在列表末尾一次性追加另一個(gè)序列中的多個(gè)值（用新列表擴(kuò)展原來的列表）
4	`list.index(obj)`從列表中找出某個(gè)值第一個(gè)匹配項(xiàng)的索引位置
5	`list.insert(index, obj)`將對象插入列表
6	`list.pop(index=-1)` 移除列表中的一個(gè)元素（默認(rèn)最后一個(gè)元素），并且返回該元素的值
7	`list.remove(obj)` 移除列表中某個(gè)值的第一個(gè)匹配項(xiàng)
8	`list.reverse()`反向列表中元素
9	`list.sort( key=None, reverse=False)`對原列表進(jìn)行排序
10	`list.clear()`清空列表
11	`list.copy()` 復(fù)制列表

三、列表的運(yùn)算

3.1 列表的運(yùn)算

3.1.1 列表拼接

我們可以使用+運(yùn)算符實(shí)現(xiàn)兩個(gè)列表的拼接，拼接運(yùn)算會將兩個(gè)列表中的元素連接起來放到一個(gè)列表中：

items5 = [35, 12, 99, 45, 66]
items6 = [45, 58, 29]
items7 = ['Python', 'Java', 'JavaScript']
print(items5 + items6)  # [35, 12, 99, 45, 66, 45, 58, 29]
print(items6 + items7)  # [45, 58, 29, 'Python', 'Java', 'JavaScript']
items5 += items6
print(items5)  # [35, 12, 99, 45, 66, 45, 58, 29]

3.1.2 列表的重復(fù)運(yùn)算

我們可以使用*運(yùn)算符實(shí)現(xiàn)列表的重復(fù)運(yùn)算，*運(yùn)算符會將列表元素重復(fù)指定的次數(shù)：

print(items6 * 3)  # [45, 58, 29, 45, 58, 29, 45, 58, 29]
print(items7 * 2)  # ['Python', 'Java', 'JavaScript', 'Python', 'Java', 'JavaScript']

3.1.3 判斷元素是否在列表中

我們可以使用in或not in運(yùn)算符，來判斷一個(gè)元素是否在一個(gè)列表中，返回的值是布爾類型：

print(29 in items6)  # True
print(99 in items6)  # False
print('C++' not in items7)     # True
print('Python' not in items7)  # False

3.1.4 索引運(yùn)算

索引運(yùn)算：由于列表中有多個(gè)元素，而且元素按特定順序放在列表中，所以當(dāng)我們想操作列表中的某個(gè)元素時(shí)，可以使用[]運(yùn)算符，通過在[]中指定元素的位置來訪問該元素，這種運(yùn)算就稱為索引運(yùn)算。

特殊注意：[]的元素位置可以是0到N - 1的整數(shù)，也可以是-1到-N的整數(shù)，分別稱為正向索引和反向索引，其中N代表列表元素的個(gè)數(shù)。對于正向索引，[0]可以訪問列表中的第一個(gè)元素，[N - 1]可以訪問最后一個(gè)元素；對于反向索引，[-1]可以訪問列表中的最后一個(gè)元素，[-N]可以訪問第一個(gè)元素。

# 索引運(yùn)算
item_list = ['Python', 'Java', 'JavaScript', 'apple', 'waxberry', 'pitaya', 'peach']
print(item_list[0])  # Python 訪問第一個(gè)元素
print(item_list[5])  # pitaya 訪問第六個(gè)元素
print(len(item_list))  # 7 計(jì)算列表item_list的個(gè)數(shù)
print(item_list[-7])  # Python  [-7]可以訪問第一個(gè)元素
print(item_list[-1])  # peach 訪問最后一個(gè)元素

在使用索引運(yùn)算的時(shí)候要避免出現(xiàn)索引越界的情況，對于上面的item_list，如果我們訪問item_list[9]或item_list[-8]，就會引發(fā)IndexError錯誤，導(dǎo)致程序崩潰，對應(yīng)的錯誤信息是：list index out of range，翻譯成中文就是“數(shù)組索引超出范圍”。因?yàn)閷τ谥挥?個(gè)元素的列表item_list，有效的正向索引是0到6，有效的反向索引是-1到-7。

3.1.5 切片運(yùn)算

如果希望一次性訪問列表中的多個(gè)元素，我們可以使用切片運(yùn)算。切片運(yùn)算是形如[start:end:stride]的運(yùn)算符，其中start代表訪問列表元素的起始位置，end代表訪問列表元素的終止位置（終止位置的元素?zé)o法訪問），而stride則代表了跨度，簡單的說就是位置的增量，比如我們訪問的第一個(gè)元素在start位置，那么第二個(gè)元素就在start + stride位置，當(dāng)然start + stride要小于end。我們給上面的代碼增加下面的語句，來使用切片運(yùn)算符訪問列表元素。

3.1.5.1 切片訪問列表

3.1.5.1.1 切片和索引的關(guān)系

在Python中，下標(biāo)索引和切片是訪問序列的兩種密切相關(guān)但機(jī)制不同的方式。

概念	本質(zhì)	視角
下標(biāo)索引 `[i]`	指向具體的元素	“我要第 i 個(gè)元素”
切片 `[i:j]`	指向元素之間的邊界	“從邊界 i 到邊界 j 的元素”

直觀理解：把索引看成“隔板”

想象序列中的元素放在一個(gè)個(gè)格子中，索引數(shù)字式隔板的位置：

    0     1     2     3     4     5     6
    |  P  |  y  |  t  |  h  |  o  |  n  |
    ↑     ↑     ↑     ↑     ↑     ↑     ↑
   隔板0  隔板1  隔板2  隔板3  隔板4  隔板5  隔板6

下標(biāo)索引[i] — 訪問單個(gè)格子：

s = "Python"
s[0]  # 'P'  → 取隔板0和隔板1之間的元素
s[3]  # 'h'  → 取隔板3和隔板4之間的元素

切片[start:stop] — 取兩個(gè)隔板之間的所有元素

s[0:3]  # 'Pyt'  → 從隔板0到隔板3，包含0不包含3
s[2:5]  # 'tho'  → 從隔板2到隔板5，包含2不包含5

這就是為什么切片是"左閉右開" [start, stop) 的原因——它描述的是邊界范圍，而不是元素本身。

關(guān)鍵區(qū)別：

nums = [0, 1, 2, 3]

# 索引: 超出范圍報(bào)錯
nums[4]     # ? IndexError

# 切片: 超出范圍不報(bào)錯，自動截?cái)?
nums[2:10]  # ? [2, 3]  (不會報(bào)錯，取到末尾為止)
nums[5:8]   # ? []      (空列表，不會報(bào)錯)

3.1.5.1.2 切片訪問列表

item_list = ['Python', 'Java', 'JavaScript', 'apple', 'waxberry', 'pitaya', 'peach']
print(item_list[0:6])  # ['Python', 'Java', 'JavaScript', 'apple', 'waxberry', 'pitaya']
print(item_list[6:9])  # ['peach'] 正向索引，從第六個(gè)元素開始訪問，到第9-1個(gè)元素，因?yàn)橹挥衅邆€(gè)元素，顧到列表的最后一個(gè)元素
print(item_list[-2:])  # ['pitaya', 'peach'] 反向索引，從索引-2的位置開始訪問，到結(jié)束，每隔1個(gè)進(jìn)行訪問
print(item_list[-4::2])  # ['apple', 'pitaya'] 反向索引，從索引-4的位置開始訪問，到結(jié)束，每隔2個(gè)進(jìn)行訪問

如果start值等于0，那么在使用切片運(yùn)算符時(shí)可以將其省略；如果end值等于N，N代表列表元素的個(gè)數(shù)，那么在使用切片運(yùn)算符時(shí)可以將其省略；如果stride值等于1，那么在使用切片運(yùn)算符時(shí)也可以將其省略。所以，下面的代碼跟上面的代碼作用完全相同。

3.1.5.1.3 通過切片修改列表中的元素

# 通過切片修改列表中的元素
item_list[-3:] = ['C', 'Android', 'C++', 'PHP', 'C#']
print(item_list)  # ['Python', 'Java', 'JavaScript', 'apple', 'C', 'Android', 'C++', 'PHP', 'C#']

切片：[-3:]也就是從列表元素waxberry開始修改，直到列表中的最后一個(gè)元素，按列表item_list的長度7，應(yīng)該將peach修改為C++就結(jié)束，但是切片：有自增元素的功能，也就是將PHP、C++插入到列表item_list中。

3.1.6 關(guān)系運(yùn)算

兩個(gè)列表還可以做關(guān)系運(yùn)算，我們可以比較兩個(gè)列表是否相等，也可以給兩個(gè)列表比大?。?/p>

nums1 = [1, 2, 3, 4]
nums2 = list(range(1, 5))
nums3 = [3, 2, 1]
print(nums1 == nums2)  # True
print(nums1 != nums2)  # False
print(nums1 <= nums3)  # True
print(nums2 >= nums3)  # False

說明：上面的nums1和nums2對應(yīng)元素完全相同，所以==運(yùn)算的結(jié)果是True。nums2和nums3的比較，由于nums2的第一個(gè)元素1小于nums3的第一個(gè)元素3，所以nums2 >= nums3比較的結(jié)果是False。兩個(gè)列表的關(guān)系運(yùn)算在實(shí)際工作并不那么常用，如果實(shí)在不理解就跳過吧，不用糾結(jié)。

四、元素的遍歷

如果想逐個(gè)取出列表中的元素，可以使用for-in循環(huán)的，有以下兩種做法。

4.1 循環(huán)中通過索引

在循環(huán)結(jié)構(gòu)中通過索引運(yùn)算，遍歷列表元素：

# 列表元素遍歷
item_list = ['Python', 'Java', 'JavaScript', 'apple', 'C', 'Android', 'C++', 'PHP', 'C#']
language_list = item_list.copy()
print(language_list)
for i in range(len(language_list)):
    print(language_list[i])

輸出：

Python
Java
JavaScript
apple
C
Android
C
Android
C++
PHP
C#

4.2 做列表循環(huán)

直接對列表做循環(huán)，循環(huán)變量就是列表元素的代表：

# 列表元素遍歷
item_list = ['Python', 'Java', 'JavaScript', 'apple', 'C', 'Android', 'C++', 'PHP', 'C#']
language_list = item_list.copy()
print(language_list)
for i in language_list:
    print(i)

輸出：

Python
Java
JavaScript
apple
C
Android
C
Android
C++
PHP
C#

五、列表生成式

在 Python 中，列表還可以通過一種特殊的字面量語法來創(chuàng)建，這種語法叫做生成式。

5.1 列表生成式

在Python中，列表還可以通過一些特殊的字面量語法來創(chuàng)建，也就是【生成式】，它允許我們以簡潔和高效的方式創(chuàng)建列表。下面的是一些列子來說明使用列表生成式，有啥好處；

5.1.1 生成平方數(shù)列表

傳統(tǒng)方式：

# 定義一個(gè)空的列表
squares = []
for i in range(1,8):
    squares.append(i ** 2)
print(squares)                       # 輸出：[1, 4, 9, 16, 25, 36, 49]

漢字解釋：

定義一個(gè)空列表squares；
使用for循環(huán)來遍歷這個(gè)左閉右開的整數(shù)序列；
最后使用函數(shù)append()來將這個(gè)運(yùn)算結(jié)果i ** 2追加到列表squares中；

使用生成式：

# 使用生成式
squares = [i ** 2 for i in range(1, 8)]
print(squares)                       # 輸出：[1, 4, 9, 16, 25, 36, 49]

漢字解釋：

使用 for 循環(huán)遍歷 range(1,8)（生成1到8的數(shù)字）；
對每個(gè)數(shù)字 i，計(jì)算其平方 i**2；
將所有平方結(jié)果存儲在 squares 列表中；

對比：

列表生成式將傳統(tǒng)for和append相結(jié)合，代碼更加簡潔；
列表生成式直接計(jì)算所有平方，而傳統(tǒng)方式，需要每次迭代調(diào)用append；
列表生成式更高效，因?yàn)樗昧藘?nèi)置函數(shù)的優(yōu)化；

5.1.2 生成奇數(shù)列表

傳統(tǒng)方式：

# for循環(huán)和if的運(yùn)用
a = []
for i in range(1, 8):
    if i % 2 != 0:
        a.append(i)
print(a)
# 運(yùn)行結(jié)果：[1, 3, 5, 7]

漢字解釋：

1、初始化空列表：a = []創(chuàng)建一個(gè)空列表用于存儲奇數(shù)；
2、遍歷整數(shù)序列range(1, 8)：range(1, 8)生成[1, 2, 3, 4, 5, 6, 7]的整數(shù)序列；
3、條件判斷if i % 2 != 0：如果等于零，則說明是偶數(shù)，不將i添加到空列表a中；
4、添加元素：符合條件的數(shù)通過append()方法加入列表a中；
5、輸出列表a中的數(shù)據(jù)項(xiàng)：最終列表為[1, 3, 5, 7]；

列表生成式（更高效簡潔）：

語法生成式：

[表達(dá)式 for 變量 in 可迭代對象 if 條件]
[expression for item in iterable if condition]

語法解釋：
1、expression ：表達(dá)式；
2、item ：變量；
3、iterable：可迭代對象；
4、condition：條件；
代碼呈現(xiàn)：

""" 列表生成式"""
a = [x for x in range(1, 8) if x % 2 != 0]
print(a)
"""運(yùn)行結(jié)果：[1, 3, 5, 7]"""

列表生成式漢字解釋：
1、在for循環(huán)后加if x % 2 != 0，自動過濾奇數(shù)；
2、好處：邏輯相對而言，減少縮進(jìn)層級；

5.1.3 嵌套循環(huán)（多層for）

生成二維坐標(biāo)列表的例子：
傳統(tǒng)方式：

"""嵌套循環(huán)（多層for循環(huán)）"""
a = []
for i in range(1, 8):
    for j in range(1, 8):
        if (i + j) % 2 == 0:
            a.append((i, j))
print(a)
"""運(yùn)行結(jié)果：
[(1, 1), (1, 3), (1, 5), (1, 7), (2, 2), (2, 4), (2, 6), (3, 1),
 (3, 3), (3, 5), (3, 7), (4, 2), (4, 4), (4, 6), (5, 1), (5, 3), 
 (5, 5), (5, 7), (6, 2), (6, 4), (6, 6), (7, 1), (7, 3), (7, 5), (7, 7)]
"""

漢字解釋：
結(jié)構(gòu)特點(diǎn)：顯式的多層for循環(huán)，通過控制縮進(jìn)控制層級，然后使用方法append()追加元素；
核心步驟：
（1）、初始化空列表a；
（2）、外層循環(huán)遍歷第一個(gè)可迭代對象；
（3）、內(nèi)存循環(huán)遍歷第二個(gè)可迭代對象；
（4）、條件判斷后追加元素；

列表生成式：

"""列表生成式"""
a = [
    (i, j)
    for i in range(1, 8)
    for j in range(1, 8)
    if (i + j) % 2 == 0
]
print(a)
"""運(yùn)行結(jié)果：
[(1, 1), (1, 3), (1, 5), (1, 7), (2, 2), (2, 4), (2, 6), (3, 1),
 (3, 3), (3, 5), (3, 7), (4, 2), (4, 4), (4, 6), (5, 1), (5, 3), 
 (5, 5), (5, 7), (6, 2), (6, 4), (6, 6), (7, 1), (7, 3), (7, 5), (7, 7)]
"""

漢字解釋：
結(jié)構(gòu)特點(diǎn)：
隱式嵌套，循環(huán)順序與書寫順序一致（外層 ——> 內(nèi)層），if條件直接過濾元素。
核心語法：

[元素表達(dá)式
for 外層循環(huán) in 外層可迭代對象
for 內(nèi)層循環(huán) in 內(nèi)層可迭代對象
if 條件
]

性能與可讀性對比：

特性	傳統(tǒng)嵌套循環(huán)	列表生成式嵌套循環(huán)
代碼長度	較長（需顯式循環(huán)和追加）	極短（一行代碼完成）
執(zhí)行效率	較慢（每次循環(huán)調(diào)用append()）	較快（Python底層優(yōu)化）
可讀性	高（邏輯分步清晰）	中（需理解生成式結(jié)構(gòu)）
調(diào)試難度	易調(diào)試（可逐行檢查變量）	難調(diào)試（無法逐步跟蹤）

列表生成式適用場景：
1、簡單數(shù)據(jù)生成：如生成矩陣、坐標(biāo)、笛卡爾積等結(jié)構(gòu)化的數(shù)據(jù)；
2、快速過濾數(shù)據(jù)：結(jié)合條件語句篩選嵌套結(jié)構(gòu)中的元素；
3、代碼簡潔性優(yōu)先的場景：需要快速實(shí)現(xiàn)且邏輯簡單時(shí)使用；

傳統(tǒng)嵌套循環(huán)適合：
1、復(fù)雜邏輯處理：如需要中間變量、循環(huán)內(nèi)外混合操作；

"""處理多層列表"""
b = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 將列表b中的元素，是偶數(shù)的挑選出來
# 定義一個(gè)空列表
c = []
for i in b:
    temp = []
    for j in i:
        if j % 2 == 0:
            temp.append(j)
    c.append(temp)
print(c)

# 運(yùn)行結(jié)果：[[2], [4, 6], [8]]

2、調(diào)試要求高：需要逐步檢查循環(huán)中的變量狀態(tài)時(shí)；
3、多層循環(huán)嵌套（3層以上）：生成式多層嵌套循環(huán)可讀性差，傳統(tǒng)循環(huán)更加清晰；

"""列表生成式：生成四維坐標(biāo)"""
d = [
    (x, y, z, j)
    for x in range(1,3)
    for y in range(1,3)
    for z in range(1,3)
    for j in range(1,3)
]
print(d)
"""傳統(tǒng)方式"""
d = []
for x in range(1,3):
    for y in range(1,3):
        for z in range(1,3):
            for j in range(1,3):
                d.append((x, y, z, j))
print(d)
# 由比較可知，傳統(tǒng)方式更具可讀性

輸出完美的九九乘法表：

"""九九乘法表"""
# 傳統(tǒng)方式
for i in range(1,10):
    for j in range(1, i+1):
        print(f"{j} * {i} = {i*j:2}", end = "  ")
    print()

**輸出結(jié)果**：
1 * 1 =  1   
1 * 2 =  2   2 * 2 =  4   
1 * 3 =  3   2 * 3 =  6   3 * 3 =  9   
1 * 4 =  4   2 * 4 =  8   3 * 4 = 12   4 * 4 = 16   
1 * 5 =  5   2 * 5 = 10   3 * 5 = 15   4 * 5 = 20   5 * 5 = 25   
1 * 6 =  6   2 * 6 = 12   3 * 6 = 18   4 * 6 = 24   5 * 6 = 30   6 * 6 = 36   
1 * 7 =  7   2 * 7 = 14   3 * 7 = 21   4 * 7 = 28   5 * 7 = 35   6 * 7 = 42   7 * 7 = 49   
1 * 8 =  8   2 * 8 = 16   3 * 8 = 24   4 * 8 = 32   5 * 8 = 40   6 * 8 = 48   7 * 8 = 56   8 * 8 = 64   
1 * 9 =  9   2 * 9 = 18   3 * 9 = 27   4 * 9 = 36   5 * 9 = 45   6 * 9 = 54   7 * 9 = 63   8 * 9 = 72   9 * 9 = 81

外層循環(huán) (i)
- for i in range(1, 10) 控制乘法表的行數(shù)
- 變量i表示乘法表中的第二個(gè)乘數(shù)（即"*"號后面的數(shù)字）
- 范圍1-9對應(yīng)乘法表的9行
內(nèi)層循環(huán) (j)
- for j in range(1, i + 1) 控制每行輸出的列數(shù)
- 變量j表示乘法表中的第一個(gè)乘數(shù)（即"×"號前面的數(shù)字）
- 每行的列數(shù)等于當(dāng)前行號（第1行1列，第2行2列…第9行9列）
格式化輸出
- f"{j}*{i}={i*j:2}" 使用f-string格式化字符串
  - j×i= 顯示乘法表達(dá)式
  - {i*j:2} 將乘積格式化為2位寬度，實(shí)現(xiàn)右對齊
- end=" " 指定每個(gè)乘法式后跟兩個(gè)空格（不換行）
換行控制
- print() 在內(nèi)層循環(huán)結(jié)束后執(zhí)行，實(shí)現(xiàn)每行輸出后的換行

高級的寫法：

"""高級的寫法"""
for i in range(1, 10):
    # 列表生成式完成
    row = [f"{j} x {i} = {i*j:3}" for j in range(1, i + 1)]
    # 使用join來將每行的表達(dá)式用三個(gè)空格連接，確保末尾無多余的空格
    print("   ".join(row))

語法解釋：
1、外層循環(huán)（i）：控制行數(shù)，從1到9；
2、內(nèi)層循環(huán)（j）：控制每行的列數(shù)，從1到當(dāng)前行號i；
3、列表生成式：生成每行的所有乘法表達(dá)式，格式為j * i = 結(jié)果，使其結(jié)果右對齊三位（i * j : 3）；
4、字符串拼接：使用join方法將每行的表達(dá)式用三個(gè)空格連接，確保對齊且無多余的空格；
5、打印輸出：每生成一行立即打印，保持格式整齊；

六、列表的總結(jié)

1、Python列表方法主要用于動態(tài)修改、查詢和操作列表。掌握這些方法可以高效處理列表數(shù)據(jù)。注意區(qū)分原地操作（如 sort()）與非原地操作（如 sorted() 函數(shù)）;
2、列表生成式與傳統(tǒng)Python程序的寫法對比，優(yōu)缺點(diǎn)；

場景	傳統(tǒng)方式	列表生成式	核心優(yōu)勢
基本遍歷	`for` + `append`	`[x for x in iterable]`	代碼更短，執(zhí)行更快
條件過濾	`for` + `if` + `append`	`[x for x in iterable if cond]`	邏輯更清晰
嵌套循環(huán)	多層 `for`	`[x for a in A for b in B]`	減少嵌套，代碼緊湊

您可能感興趣的文章:

最新国产好看的视频,伊人天堂AV在线,国产Aaaaaa视频,蜜臀视频在线观看一区,人妻av色图,密臀久久久精品影片,青青视频免费观看毛片,久草在线观看视,国产三级精品色情在线