Python如何定義和使用列表

本篇內容主要講解“Python如何定義和使用列表”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“Python如何定義和使用列表”吧!

在開始本節課的內容之前，我們先給大家一個編程任務，將一顆篩子擲6000次，統計每個點數出現的次數。這個任務對大家來說應該是非常簡單的，我們可以用1到6均勻分布的隨機數來模擬擲篩子，然后用6個變量分別記錄每個點數出現的次數，相信大家都能寫出下面的代碼。

import random

f1 = 
0
f2 = 
0
f3 = 
0
f4 = 
0
f5 = 
0
f6 = 
0
for _ 
in range(6000):
    face = random.randint(1, 
6)
    if face == 
1:
        f1 += 
1
    elif face == 
2:
        f2 += 
1
    elif face == 
3:
        f3 += 
1
    elif face == 
4:
        f4 += 
1
    elif face == 
5:
        f5 += 
1
    else:
        f6 += 
1
print(f'1點出現了{f1}次')
print(f'2點出現了{f2}次')
print(f'3點出現了{f3}次')
print(f'4點出現了{f4}次')
print(f'5點出現了{f5}次')
print(f'6點出現了{f6}次')

看看上面的代碼，相信大家一定覺得它非常的“笨重”和“丑陋”，更可怕的是，如果要統計擲2顆或者更多的篩子統計每個點數出現的次數，那就需要定義更多的變量，寫更多的分支結構。講到這里，相信大家一定想問：有沒有辦法用一個變量來保存多個數據，有沒有辦法用統一的代碼對多個數據進行操作？答案是肯定的，在Python中我們可以通過容器類型的變量來保存和操作多個數據，我們首先為大家介紹列表（list）這種新的數據類型。

定義和使用列表

在Python中，列表是由一系元素按特定順序構成的數據序列，這樣就意味著定義一個列表類型的變量，可以保存多個數據，而且允許有重復的數據。跟上一課我們講到的字符串類型一樣，列表也是一種結構化的、非標量類型，操作一個列表類型的變量，除了可以使用運算符還可以使用它的方法。

在Python中，可以使用[]字面量語法來定義列表，列表中的多個元素用逗號進行分隔，代碼如下所示。

items1 = [35, 12, 99, 68, 55, 87]
print(items1)
items2 = ['Python', 
'Java', 
'Go', 
'Kotlin']
print(items2)

除此以外，還可以通過Python內置的list函數將其他序列變成列表。準確的說，list并不是一個函數，而是創建列表對象的構造器（后面會講到對象和構造器這兩個概念）。

items1 = list(range(1, 
10))
print(items1)    # [1, 
2, 
3, 
4, 
5, 
6, 
7, 
8, 
9]
items2 = list('hello')
print(items2)    # ['h', 
'e', 
'l', 
'l', 
'o']

需要說明的是，列表是一種可變數據類型，也就是說列表可以添加元素、刪除元素、更新元素，這一點跟我們上一課講到的字符串有著鮮明的差別。字符串是一種不可變數據類型，也就是說對字符串做拼接、重復、轉換大小寫、修剪空格等操作的時候會產生新的字符串，原來的字符串并沒有發生任何改變。

列表的運算符

和字符串類型一樣，列表也支持拼接、重復、成員運算、索引和切片以及比較運算，對此我們不再進行贅述，請大家參考下面的代碼。

items1 = [35, 
12, 
99, 
68, 
55, 
87]
items2 = [45, 
8, 
29]

# 列表的拼接
items3 = items1 + items2
print(items3)    # [35, 
12, 
99, 
68, 
55, 
87, 
45, 
8, 
29]

# 列表的重復
items4 = ['hello'] * 
3
print(items4)    # ['hello', 
'hello', 
'hello']

# 列表的成員運算
print(100 in items3)        # False
print('hello' in items4)    # True

# 獲取列表的長度(元素個數)
size = 
len(items3)
print(size)                 # 
9

# 列表的索引
print(items3[0], items3[-size])        # 
35 35
items3[-1] = 
100
print(items3[size - 
1], items3[-1])    # 
100 100

# 列表的切片
print(items3[:5])          # [35, 
12, 
99, 
68, 
55]
print(items3[4:])          # [55, 
87, 
45, 
8, 
100]
print(items3[-5:-7:-1])    # [55, 
68]
print(items3[::-2])        # [100, 
45, 
55, 
99, 
35]

# 列表的比較運算
items5 = [1, 
2, 
3, 
4]
items6 = list(range(1, 
5))
# 兩個列表比較相等性比的是對應索引位置上的元素是否相等
print(items5 == items6)    # True
items7 = [3, 
2, 
1]
# 兩個列表比較大小比的是對應索引位置上的元素的大小
print(items5 <= items7)    # True

值得一提的是，由于列表是可變類型，所以通過索引操作既可以獲取列表中的元素，也可以更新列表中的元素。對列表做索引操作一樣要注意索引越界的問題，對于有N個元素的列表，正向索引的范圍是0到N-1，負向索引的范圍是-1到-N，如果超出這個范圍，將引發IndexError異常，錯誤信息為：list index out of range。

列表元素的遍歷

如果想逐個取出列表中的元素，可以使用for循環的，有以下兩種做法。

方法一：

items = ['Python', 
'Java', 
'Go', 
'Kotlin']

for index in 
range(len(items)):
    print(items[index])

方法二：

items = ['Python', 
'Java', 
'Go', 
'Kotlin']

for item in items:
    print(item)

講到這里，我們可以用列表的知識來重構上面“擲篩子統計每個點數出現次數”的代碼。

import random

counters = [0] * 
6
for _ in 
range(6000):
    face = random.randint(1, 
6)
    counters[face - 
1] += 
1
for face in 
range(1, 
7):
    print(f'{face}點出現了{counters[face - 1]}次')

上面的代碼中，我們用counters列表中的六個元素分別表示1到6的點數出現的次數，最開始的時候六個元素的值都是0。接下來用隨機數模擬擲篩子，如果搖出1點counters[0]的值加1，如果搖出2點counters[1]的值加1，以此類推。大家感受一下，這段代碼是不是比之前的代碼要簡單優雅很多。

列表的方法

和字符串一樣，列表類型的方法也很多，下面為大家講解比較重要的方法。

添加和刪除元素

items = ['Python', 
'Java', 
'Go', 
'Kotlin']

# 使用append方法在列表尾部添加元素
items.append('Swift')
print(items)    # ['Python', 
'Java', 
'Go', 
'Kotlin', 
'Swift']
# 使用insert方法在列表指定索引位置插入元素
items.insert(2, 
'SQL')
print(items)    # ['Python', 
'Java', 
'SQL', 
'Go', 
'Kotlin', 
'Swift']

# 刪除指定的元素
items.remove('Java')
print(items)    # ['Python', 
'SQL', 
'Go', 
'Kotlin', 
'Swift']
# 刪除指定索引位置的元素
items.pop(0)
items.pop(len(items) - 
1)
print(items)    # ['SQL', 
'Go', 
'Kotlin']

# 清空列表中的元素
items.clear()
print(items)    # []

需要提醒大家，在使用remove方法刪除元素時，如果要刪除的元素并不在列表中，會引發ValueError異常，錯誤消息是：list.remove(x): x not in list。在使用pop方法刪除元素時，如果索引的值超出了范圍，會引發IndexError異常，錯誤消息是：pop index out of range。

從列表中刪除元素其實還有一種方式，就是使用Python中的del關鍵字后面跟要刪除的元素，這種做法跟使用pop方法指定索引刪除元素沒有實質性的區別，但后者會返回刪除的元素，前者在性能上略優（del對應字節碼指令是DELETE_SUBSCR，而pop對應的字節碼指令是CALL_METHOD和POP_TOP）。

items = ['Python', 
'Java', 
'Go', 
'Kotlin']
del items[1]
print(items)    # ['Python', 
'Go', 
'Kotlin']

元素位置和次數

列表類型的index方法可以查找某個元素在列表中的索引位置；因為列表中允許有重復的元素，所以列表類型提供了count方法來統計一個元素在列表中出現的次數。請看下面的代碼。

items = ['Python', 
'Java', 
'Java', 
'Go', 
'Kotlin', 
'Python']

# 查找元素的索引位置
print(items.index('Python'))       # 
0
print(items.index('Python', 
2))    # 
5
# 注意：雖然列表中有'Java'，但是從索引為3這個位置開始后面是沒有'Java'的
print(items.index('Java', 
3))      # ValueError: 
'Java' is not in list

再來看看下面這段代碼。

items = ['Python', 
'Java', 
'Java', 
'Go', 
'Kotlin', 
'Python']

# 查找元素出現的次數
print(items.count('Python'))    # 
2
print(items.count('Go'))        # 
1
print(items.count('Swfit'))     # 
0

元素排序和反轉

列表的sort操作可以實現列表元素的排序，而reverse操作可以實現元素的反轉，代碼如下所示。

items = ['Python', 
'Java', 
'Go', 
'Kotlin', 
'Python']

# 排序
items.sort()
print(items)    # ['Go', 
'Java', 
'Kotlin', 
'Python', 
'Python']
# 反轉
items.reverse()
print(items)    # ['Python', 
'Python', 
'Kotlin', 
'Java', 
'Go']

列表的生成式

在Python中，列表還可以通過一種特殊的字面量語法來創建，這種語法叫做生成式。我們給出兩段代碼，大家可以做一個對比，看看哪一種方式更加簡單優雅。

通過for循環為空列表添加元素。

# 創建一個由1到9的數字構成的列表
items1 = []
for x in 
range(1, 
10):
    items1.append(x)
print(items1)

# 創建一個由'hello world'中除空格和元音字母外的字符構成的列表
items2 = []
for x in 
'hello world':
    if x not in 
' aeiou':
        items2.append(x)
print(items2)

# 創建一個由個兩個字符串中字符的笛卡爾積構成的列表
items3 = []
for x in 
'ABC':
    for y in 
'12':
        items3.append(x + y)
print(items3)

通過生成式創建列表。

# 創建一個由1到9的數字構成的列表
items1 = [x 
for x in 
range(1, 
10)]
print(items1)    # [1, 
2, 
3, 
4, 
5, 
6, 
7, 
8, 
9]

# 創建一個由'hello world'中除空格和元音字母外的字符構成的列表
items2 = [x 
for x in 
'hello world' if x not in 
' aeiou']
print(items2)    # ['h', 
'l', 
'l', 
'w', 
'r', 
'l', 
'd']

# 創建一個由個兩個字符串中字符的笛卡爾積構成的列表
items3 = [x + y 
for x in 
'ABC' for y in 
'12']
print(items3)    # ['A1', 
'A2', 
'B1', 
'B2', 
'C1', 
'C2']

下面這種方式不僅代碼簡單優雅，而且性能也優于上面使用for循環和append方法向空列表中追加元素的方式。可以簡單跟大家交待下為什么生成式擁有更好的性能，那是因為Python解釋器的字節碼指令中有專門針對生成式的指令（LIST_APPEND指令）；而for循環是通過方法調用（LOAD_METHOD和CALL_METHOD指令）的方式為列表添加元素，方法調用本身就是一個相對耗時的操作。對這一點不理解也沒有關系，記住“強烈建議用生成式語法來創建列表”這個結論就可以了。

嵌套的列表

Python語言沒有限定列表中的元素必須是相同的數據類型，也就是說一個列表中的元素可以任意的數據類型，當然也包括列表。如果列表中的元素又是列表，那么我們可以稱之為嵌套的列表。嵌套的列表可以用來表示表格或數學上的矩陣，例如：我們想保存5個學生3門課程的成績，可以定義一個保存5個元素的列表保存5個學生的信息，而每個列表元素又是3個元素構成的列表，分別代表3門課程的成績。但是，一定要注意下面的代碼是有問題的。

scores = [[0] * 
3] * 
5
print(scores)    # [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

看上去我們好像創建了一個5 * 3的嵌套列表，但實際上當我們錄入第一個學生的第一門成績后，你就會發現問題來了，我們看看下面代碼的輸出。

# 嵌套的列表需要多次索引操作才能獲取元素
scores[0][0] = 
95
print(scores)    # 
[[95, 0, 0], [95, 0, 0], [95, 0, 0], [95, 0, 0], [95, 0, 0]]

我們不去過多的解釋為什么會出現這樣的問題，如果想深入研究這個問題，可以通過Python Tutor網站的可視化代碼執行功能，看看創建列表時計算機內存中發生了怎樣的變化，下面的圖就是在這個網站上生成的。建議大家不去糾結這個問題，現階段只需要記住不能用[[0] * 3] * 5]這種方式來創建嵌套列表就行了。那么創建嵌套列表的正確做法是什么呢，下面的代碼會給你答案。

scores = [[0] * 3 for _ in range(5)]
scores[0][0] = 95
print(scores)    # [[95, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

到此，相信大家對“Python如何定義和使用列表”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！