返回文章列表
玄貓（BlackCat）

Python 列表操作與資料結構應用

本文深入探討 Python 列表的各種操作技巧，包含索引、切片、迴圈遍歷、多重指定、元素增刪、排序、反轉以及與 `random` 模組的整合應用。同時，也詳細比較了列表與元組的特性差異，並說明瞭可變與不可變資料型別在 Python 中的應用。

Python 程式設計
列表 元組 迴圈 索引 切片 資料結構

Python 的列表是極為重要的資料結構，其靈活性和功能性在程式設計中扮演關鍵角色。理解列表操作的技巧，例如索引、切片、迴圈遍歷、多重指定，以及元素的新增、刪除、排序和反轉，能大幅提升程式碼的效率和可讀性。結合 random 模組，更能實作隨機選取和排序等進階功能。此外，區分可變的列表和不可變的元組，並瞭解它們之間的轉換方式，對於資料處理和程式碼安全至關重要。掌握這些技巧，能更有效地運用列表和元組，提升 Python 程式設計的效率。

練習程式：硬幣猜測遊戲

以下程式是一個簡單的硬幣猜測遊戲，玩家有兩次猜測機會。然而，程式中有多個錯誤，請執行程式幾次來找出錯誤。

import random

guess = ''

while guess not in ('heads', 'tails'):
    print('Guess the coin toss! Enter heads or tails.')
    guess = input()

內容解密：

  • 上述程式使用了一個 while 迴圈來不斷地詢問玩家猜測，直到玩家輸入 ‘heads’ 或 ’tails’。
  • 程式使用 random 模組來模擬硬幣翻轉。
  • 玩家有兩次猜測機會，如果兩次都猜錯，程式就會結束。

圖表翻譯：

  • 圖表顯示了程式的流程，從開始到結束。
  • 玩家的猜測會被檢查，如果正確，程式就會結束。如果不正確，程式就會繼續詢問玩家猜測。

列表資料型別

列表（list）是一種可以包含多個值的資料型別，它的表達方式是以方括號 [] 包圍，並以逗號分隔各個值。列表中的每個值被稱為「專案」（item）。例如，['cat', 'bat', 'rat', 'elephant'] 就是一個列表，其中包含四個字串值。

列表索引

列表中的每個專案都有一個對應的索引（index），索引從 0 開始。也就是說，第一個專案的索引是 0，第二個專案的索引是 1，以此類別推。例如，對於列表 ['cat', 'bat', 'rat', 'elephant']，索引 0 對應的值是 'cat'，索引 1 對應的值是 'bat'，依此類別推。

列表操作

列表支援多種操作，包括索引、切片、追加、插入和刪除等。以下是一些基本的列表操作：

  • 索引：可以使用方括號 [] 來存取列表中的特定專案，例如 my_list[0] 可以存取列表的第一個專案。
  • 切片：可以使用方括號 [] 來存取列表中的連續專案，例如 my_list[1:3] 可以存取列表中的第二個和第三個專案。
  • 追加：可以使用 append() 方法來在列表末尾新增新的專案。
  • 插入：可以使用 insert() 方法來在列表中的特定位置插入新的專案。
  • 刪除：可以使用 remove() 方法來刪除列表中的特定專案。

列表方法

列表有一些內建的方法，可以用來執行各種操作。以下是一些常用的列表方法：

  • append(): 在列表末尾新增新的專案。
  • insert(): 在列表中的特定位置插入新的專案。
  • remove(): 刪除列表中的特定專案。
  • sort(): 對列表中的專案進行排序。
  • reverse(): 對列表中的專案進行反轉。

列表與其他資料型別

列表可以包含其他資料型別的值，例如整數、浮點數、字串和其他列表等。這使得列表成為了一種非常靈活和強大的資料型別。

實際應用

列表在實際應用中非常常見，例如：

  • 資料儲存：列表可以用來儲存和管理大量的資料。
  • 演算法實作：列表可以用來實作各種演算法，例如排序和查詢等。
  • 網頁開發：列表可以用來儲存和顯示網頁中的資料。

列表索引的運用

在Python中，列表是一種重要的資料結構，透過索引（index）可以存取列表中的特定元素。索引是從0開始的，這意味著第一個元素的索引是0，第二個元素的索引是1，依此類別推。

基本索引

首先，我們來看一個基本的例子：

spam = ['cat', 'bat', 'rat', 'elephant']
print(spam[0])  # 輸出：'cat'
print(spam[1])  # 輸出：'bat'
print(spam[2])  # 輸出：'rat'

在這個例子中，我們使用索引來存取列表中的特定元素。索引0對應於第一個元素'cat'，索引1對應於第二個元素'bat'，依此類別推。

字串串接

我們也可以使用索引來存取列表中的元素，並將其與其他字串串接起來：

print('Hello, ' + spam[0])  # 輸出：'Hello, cat'
print('The ' + spam[1] + ' ate the ' + spam[0] + '.')  # 輸出：'The bat ate the cat.'

在這個例子中，我們使用索引來存取列表中的元素，並將其與其他字串串接起來。

多維列表

列表也可以包含其他列表作為其元素。這種情況下，我們可以使用多個索引來存取內部列表中的元素：

spam = [['cat', 'bat'], [10, 20, 30, 40, 50]]
print(spam[0])  # 輸出：['cat', 'bat']
print(spam[0][1])  # 輸出：'bat'
print(spam[1][4])  # 輸出：50

在這個例子中，我們使用兩個索引來存取內部列表中的元素。第一個索引0對應於外部列表中的第一個元素['cat', 'bat']，第二個索引1對應於內部列表中的第二個元素'bat'。

負數索引

Python也支援負數索引。負數索引從列表的末尾開始計數，-1對應於最後一個元素，-2對應於倒數第二個元素，依此類別推：

spam = [['cat', 'bat'], [10, 20, 30, 40, 50]]
print(spam[-1])  # 輸出：[10, 20, 30, 40, 50]
print(spam[-1][-1])  # 輸出：50

在這個例子中，我們使用負數索引來存取列表中的最後一個元素。

圖表翻譯：

這個圖表展示了列表索引的運用，包括基本索引、多維列表和負數索引。

列表索引和切片

在 Python 中，列表（list）是一種可變的資料結構，允許您儲存多個值。您可以使用索引（index）來存取列表中的特定元素。

索引

索引是列表中每個元素的唯一標識。索引從 0 開始，因此第一個元素的索引是 0，第二個元素的索引是 1，依此類別推。

spam = ['cat', 'bat', 'rat', 'elephant']
print(spam[0])  # 輸出：cat
print(spam[1])  # 輸出：bat
print(spam[-1])  # 輸出：elephant

切片

切片（slice）是從列表中提取一部分元素的方法。您可以使用 [:] 來指定切片的範圍。

spam = ['cat', 'bat', 'rat', 'elephant']
print(spam[0:2])  # 輸出：['cat', 'bat']
print(spam[1:3])  # 輸出：['bat', 'rat']
print(spam[:2])  # 輸出：['cat', 'bat']
print(spam[1:])  # 輸出：['bat', 'rat', 'elephant']
print(spam[:])  # 輸出：['cat', 'bat', 'rat', 'elephant']

列表長度

您可以使用 len() 函式來取得列表的長度。

spam = ['cat', 'dog', 'moose']
print(len(spam))  # 輸出：3

更新列表元素

您可以使用索引來更新列表中的特定元素。

spam = ['cat', 'bat', 'rat', 'elephant']
spam[1] = 'aardvark'
print(spam)  # 輸出：['cat', 'aardvark', 'rat', 'elephant']

列表連線和複製

您可以使用 + 和 * 運算子來連線和複製列表。

print([1, 2, 3] + ['A', 'B', 'C'])  # 輸出：[1, 2, 3, 'A', 'B', 'C']
print(['X', 'Y', 'Z'] * 3)  # 輸出：['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z']

圖表翻譯：

以上內容介紹了 Python 中的列表索引、切片、長度、更新元素、連線和複製等操作。透過這些操作，您可以輕松地處理和操縱列表資料。

列表操作與管理

列表是Python中的一種基本資料結構，允許您儲存和操作多個值。您可以使用+運算子將兩個列表合併成一個新的列表，並使用*運算子將列表複製多次。

列表合併

以下示例展示瞭如何使用+運算子合併兩個列表：

spam = [1, 2, 3]
spam = spam + ['A', 'B', 'C']
print(spam)  # [1, 2, 3, 'A', 'B', 'C']

列表複製

以下示例展示瞭如何使用*運算子複製一個列表：

numbers = [1, 2, 3]
numbers = numbers * 3
print(numbers)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

刪除列表元素

您可以使用del陳述式刪除列表中的元素。以下示例展示瞭如何刪除列表中的元素：

spam = ['cat', 'bat', 'rat', 'elephant']
del spam[2]
print(spam)  # ['cat', 'bat', 'elephant']

注意，當您刪除一個元素時，列表中的其他元素將會向前移動，以填充被刪除的元素的位置。

刪除變數

您也可以使用del陳述式刪除一個變數。以下示例展示瞭如何刪除一個變數：

x = 5
del x
print(x)  # NameError: name 'x' is not defined

注意，當您刪除一個變數時，您將無法再使用它。

使用列表儲存資料

列表是儲存多個值的理想資料結構。以下示例展示瞭如何使用列表儲存資料：

cat_names = []
while True:
    name = input("Enter the name of a cat (or 'quit' to stop): ")
    if name.lower() == 'quit':
        break
    cat_names.append(name)
print(cat_names)

這個示例展示瞭如何使用列表儲存使用者輸入的資料。

實踐中避免使用多個變數

在實踐中，避免使用多個變數來儲存類別似的資料。以下示例展示瞭如何使用列表來儲存多個值：

cat_name_1 = 'Zophie'
cat_name_2 = 'Pooka'
cat_name_3 = 'Simon'
cat_name_4 = 'Lady Macbeth'

這種方法有很多缺點，包括：

  • 如果您需要儲存更多的值，您需要建立更多的變數。
  • 這種方法包含很多重複的程式碼。

以下示例展示瞭如何使用列表來儲存多個值：

cat_names = ['Zophie', 'Pooka', 'Simon', 'Lady Macbeth']

這種方法更為簡潔和高效。

使用列表進行迴圈

您可以使用迴圈來遍歷列表中的元素。以下示例展示瞭如何使用迴圈來遍歷列表：

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

這個示例展示瞭如何使用迴圈來遍歷列表中的元素。

使用列表儲存多個貓咪名稱

在前面的範例中，我們使用多個變數來儲存貓咪的名稱，但這種方法並不適合儲存大量的資料。為瞭解決這個問題，我們可以使用列表（list）來儲存多個貓咪的名稱。

列表的優點

使用列表可以讓我們更容易地管理和處理大量的資料。列表是一種可以儲存多個值的資料結構，每個值都有自己的索引（index）。這讓我們可以輕易地存取和修改列表中的值。

實際範例

下面是使用列表儲存貓咪名稱的範例程式：

cat_names = []
while True:
    print('Enter the name of cat ' + str(len(cat_names) + 1) + ' (Or enter nothing to stop.):')
    name = input()
    if name == '':
        break
    cat_names = cat_names + [name]  # 列表串接

print('The cat names are:')
for name in cat_names:
    print(' ' + name)

在這個範例中，我們使用一個空列表 cat_names 來儲存貓咪的名稱。然後，我們使用一個 while 迴圈來反覆詢問使用者輸入貓咪的名稱。如果使用者輸入空白，則結束迴圈。否則，我們將輸入的名稱加入到列表中。

列表串接

在上面的範例中，我們使用了列表串接（list concatenation）的方法來將新的名稱加入到列表中。這是透過使用 + 運算子來實作的，例如 cat_names + [name]。

列表迭代

最後，我們使用了一個 for 迴圈來迭代列表中的每個值，並將其印出。這是透過使用 for 迴圈的語法來實作的，例如 for name in cat_names:。

內容解密：

在這個範例中，我們使用了列表來儲存多個貓咪的名稱。列表是一種可以儲存多個值的資料結構，每個值都有自己的索引。這讓我們可以輕易地存取和修改列表中的值。透過使用列表串接和迭代，我們可以更容易地管理和處理大量的資料。

圖表翻譯：

在這個圖表中，我們展示了程式的流程。首先，使用者輸入貓咪的名稱。然後，程式檢查是否為空白。如果是，則結束。如果否，則將名稱加入到列表中。最後，程式印出列表中的值。

迴圈與列表

在第三章中，您學習瞭如何使用 for 迴圈來執行一段程式碼一定次數。從技術上講，for 迴圈會重複執行程式碼區塊一次，以便於列表中的每個專案。例如，如果您執行以下程式碼：

for i in range(4):
    print(i)

輸出結果將會是：

0
1
2
3

這是因為 range(4) 的傳回值是一個序列值，Python 將其視為 [0, 1, 2, 3]。以下程式碼的輸出結果與前一個相同：

for i in [0, 1, 2, 3]:
    print(i)

前面的 for 迴圈實際上會迭代其子句，並將變數 i 設定為 [0, 1, 2, 3] 列表中每次迭代的連續值。

一個常見的 Python 技術是使用 range(len(some_list)) 與 for 迴圈來迭代列表的索引。例如，輸入以下程式碼到互動式 shell 中：

supplies = ['pens', 'staplers', 'flamethrowers']
for i in range(len(supplies)):
    print('Index ' + str(i) + ' in supplies is: ' + supplies[i])

這個程式碼會輸出：

Index 0 in supplies is: pens
Index 1 in supplies is: staplers
Index 2 in supplies is: flamethrowers

內容解密：

在這個例子中，我們使用 range(len(supplies)) 來生成一個索引序列，然後使用 for 迴圈來迭代這個序列。每次迭代，我們都會將變數 i 設定為序列中的連續值，並使用 supplies[i] 來存取列表中的對應元素。

圖表翻譯：

這個圖表展示了程式碼的邏輯流程，從初始化 supplies 列表開始，到使用 for 迴圈迭代索引序列，然後存取列表中的對應元素，並最終輸出結果。

列表索引和in/not in運算元

在Python中，列表是一種重要的資料結構，允許我們儲存和操作多個值。列表中的每個值都有一個唯一的索引，可以用來存取該值。

列表索引

列表索引是從0開始的，這意味著第一個元素的索引是0，第二個元素的索引是1，以此類別推。例如：

supplies = ['pens', 'staplers', 'flamethrowers', 'binders']
print("Index 0 in supplies is:", supplies[0])
print("Index 1 in supplies is:", supplies[1])

輸出：

Index 0 in supplies is: pens
Index 1 in supplies is: staplers

使用range(len(supplies))可以輕鬆地遍歷列表中的所有索引。

in/not in運算元

in和not in運算元可以用來檢查一個值是否在列表中。這些運算元會傳回一個布林值（True或False）。例如：

print('howdy' in ['hello', 'hi', 'howdy', 'heyas'])  # True
spam = ['hello', 'hi', 'howdy', 'heyas']
print('cat' in spam)  # False
print('howdy' not in spam)  # False
print('cat' not in spam)  # True

實際應用

以下是一個簡單的程式，讓使用者輸入一個寵物名稱，然後檢查該名稱是否在一個寵物列表中：

my_pets = ['Zophie', 'Pooka', 'Fat-tail']
print('Enter a pet name:')
name = input()
if name not in my_pets:
    print('I do not have a pet named ' + name)
else:
    print(name + ' is my pet.')

這個程式使用in運算元來檢查使用者輸入的名稱是否在my_pets列表中。如果名稱不在列表中，程式會輸出一條訊息說明沒有這個寵物；否則，程式會輸出一條訊息說明這個寵物是屬於你的。

內容解密：

上述程式碼使用了in運算元來檢查一個值是否在列表中。in運算元會傳回一個布林值（True或False），這可以用來控制程式的流程。例如，在上述程式碼中，如果使用者輸入的名稱不在my_pets列表中，程式會輸出一條訊息說明沒有這個寵物。

圖表翻譯：

這個圖表展示了程式的流程：使用者輸入寵物名稱，程式檢查名稱是否在列表中，如果是，輸出寵物屬於你的訊息；否則，輸出沒有這個寵物的訊息。

列表操作技巧

在 Python 中，列表是一種非常重要的資料結構。以下是幾種常用的列表操作技巧。

多重指定技巧

多重指定技巧（technically called tuple unpacking）是一種捷徑，讓你可以在一行程式碼中將多個變數指定為列表中的值。例如：

cat = ['fat', 'gray', 'loud']
size, color, disposition = cat

這樣可以取代以下三行程式碼：

cat = ['fat', 'gray', 'loud']
size = cat[0]
color = cat[1]
disposition = cat[2]

注意，變數的數量和列表的長度必須完全相等，否則 Python 會丟擲 ValueError。

列表專案列舉

如果你需要在迴圈中取得列表專案的索引和值，可以使用 enumerate() 函式。這個函式會在每次迴圈迭代中傳回兩個值：專案的索引和專案本身。例如：

supplies = ['pens', 'staplers', 'flamethrowers']
for index, item in enumerate(supplies):
    print('Index ' + str(index) + ' in supplies is: ' + item)

這樣可以取代以下程式碼：

supplies = ['pens', 'staplers', 'flamethrowers']
for i in range(len(supplies)):
    print('Index ' + str(i) + ' in supplies is: ' + supplies[i])

enumerate() 函式非常有用，如果你需要在迴圈中取得專案的索引和值。

隨機選擇和排序

random 模組有一些函式可以接受列表作為引數。例如，random.choice() 函式會從列表中隨機選擇一個專案。例如：

import random
supplies = ['pens', 'staplers', 'flamethrowers']
print(random.choice(supplies))

這會從 supplies 列表中隨機選擇一個專案並列印預出來。

內容解密：

  • 多重指定技巧可以簡化程式碼，提高可讀性。
  • enumerate() 函式可以在迴圈中取得專案的索引和值。
  • random 模組提供了隨機選擇和排序的功能。

圖表翻譯：

這個圖表展示了列表操作的不同技巧，包括多重指定技巧、列表專案列舉和隨機選擇和排序。每個技巧都有其自己的優點和應用場景。

列表和隨機選擇

在 Python 中，列表是一種重要的資料結構，允許您儲存多個值。您可以使用索引來存取列表中的特定元素，索引從 0 開始。例如：

supplies = ['pens', 'staplers', 'flamethrowers', 'binders']
print("Index 0 in supplies is:", supplies[0])
print("Index 1 in supplies is:", supplies[1])
print("Index 2 in supplies is:", supplies[2])
print("Index 3 in supplies is:", supplies[3])

此外，Python 的 random 模組提供了 choice() 函式，可以從列表中隨機選擇一個元素：

import random
pets = ['Dog', 'Cat', 'Moose']
print(random.choice(pets))

您也可以使用 shuffle() 函式來重新排列列表中的元素：

import random
people = ['Alice', 'Bob', 'Carol', 'David']
random.shuffle(people)
print(people)

增強指定運算子

增強指定運算子是 Python 中的一種簡便的指定方式。例如，當您想要將一個變數的值增加 1 時，可以使用 += 運算子：

spam = 42
spam += 1
print(spam)  # Output: 43

這等同於以下程式碼：

spam = 42
spam = spam + 1
print(spam)  # Output: 43

Python 中的增強指定運算子包括 +=、-=、*=、/= 和 %= 等。

表格：增強指定運算子

增強指定運算子相等的指定運算子
a += ba = a + b
a -= ba = a - b
a *= ba = a * b
a /= ba = a / b
a %= ba = a % b

這些增強指定運算子可以簡化您的程式碼，使其更容易閱讀和維護。

等價指定運算元

在 Python 中，等價指定運算元（Augmented Assignment Operators）是一種方便的方式，可以讓你簡化程式碼並提高可讀性。這些運算元包括 +=、-=、*=、/= 和 %=。

以下是一些等價指定運算元的例子：

  • spam += 1 等價於 spam = spam + 1
  • spam -= 1 等價於 spam = spam - 1
  • spam *= 1 等價於 spam = spam * 1
  • spam /= 1 等價於 spam = spam / 1
  • spam %= 1 等價於 spam = spam % 1

除了數字運算外，+= 運算元還可以用於字串和列表的連線，而 *= 運算元可以用於字串和列表的複製。例如：

spam = 'Hello,'
spam += ' world!'  # 等價於 spam = spam + 'world!'
print(spam)  # 輸出：'Hello, world!'

bacon = ['Zophie']
bacon *= 3  # 等價於 bacon = bacon * 3
print(bacon)  # 輸出：['Zophie', 'Zophie', 'Zophie']

方法

方法（Method）是與函式（Function）類別似的東西，但它是被呼叫在一個值上的。例如，如果有一個列表值儲存在 spam 變數中，你可以呼叫列表的 index() 方法來查詢某個值的索引。方法的呼叫方式是 值.方法名稱()。

每種資料型別都有它自己的方法集。例如，列表資料型別有多個有用的方法，可以用於查詢、新增、刪除和操作列表中的值。

查詢值

列表值有一個 index() 方法，可以傳遞一個值。如果該值存在於列表中，方法會傳回該值的索引。如果值不存在於列表中，Python 會產生一個 ValueError 錯誤。以下是一個例子：

spam = ['hello', 'hi', 'howdy', 'heyas']
print(spam.index('hello'))  # 輸出：0
print(spam.index('heyas'))  # 輸出：3

注意，如果你呼叫 index() 方法時傳遞的值不存在於列表中，Python 會產生一個 ValueError 錯誤。例如：

spam = ['hello', 'hi', 'howdy', 'heyas']
try:
    print(spam.index('nonexistent'))
except ValueError:
    print("該值不存在於列表中")

這個例子會輸出 “該值不存在於列表中”，因為 'nonexistent' 值不存在於 spam 列表中。

列表操作方法

查詢元素索引

在 Python 中，列表提供了 index() 方法來查詢元素的索引。這個方法傳回元素在列表中第一次出現的索引。如果元素在列表中不存在，則會引發 ValueError。

spam = ['cat', 'dog', 'bat']
print(spam.index('dog'))  # 輸出：1

新增元素

列表提供了兩種方法來新增新元素：append() 和 insert()。

  • append() 方法在列表末尾新增一個元素。
  • insert() 方法可以在列表的任意位置插入一個元素。它需要兩個引數：插入位置的索引和要插入的元素。
# append() 示例
spam = ['cat', 'dog', 'bat']
spam.append('moose')
print(spam)  # 輸出：['cat', 'dog', 'bat', 'moose']

# insert() 示例
spam = ['cat', 'dog', 'bat']
spam.insert(1, 'chicken')
print(spam)  # 輸出：['cat', 'chicken', 'dog', 'bat']

注意，這些方法直接修改了列表，不需要重新指定給列表變數。

刪除元素

列表提供了 remove() 方法來刪除元素。這個方法需要一個引數，即要刪除的元素值。如果列表中存在多個相同的元素，則只會刪除第一次出現的那個。

spam = ['cat', 'bat', 'rat', 'elephant']
spam.remove('bat')
print(spam)  # 輸出：['cat', 'rat', 'elephant']

如果要刪除的元素不存在於列表中，則會引發 ValueError。

錯誤示例

嘗試在非列表物件上呼叫列表方法會引發 AttributeError。例如，嘗試在字串上呼叫 append() 方法：

eggs = 'hello'
try:
    eggs.append('world')
except AttributeError as e:
    print(e)  # 輸出：'str' object has no attribute 'append'

這些方法和屬性是列表特有的，不能在其他型別的物件上使用。

列表操作與排序

在 Python 中，列表（list）是一種可變的集合型別，可以儲存多種型別的資料。列表操作是指對列表進行增、刪、改、查等操作。

列表插入

列表插入是指在列表中新增新的元素。可以使用 insert() 方法來實作列表插入。例如：

bacon = [1, 2, 3]
bacon.insert(1, 'world')
print(bacon)  # [1, 'world', 2, 3]

但是，如果試圖將字串插入整數列表中，會出現錯誤：

bacon = 1
bacon.insert(1, 'world')  # AttributeError: 'int' object has no attribute 'insert'

列表刪除

列表刪除是指從列表中移除元素。可以使用 remove() 方法來實作列表刪除。例如：

spam = ['cat', 'bat', 'rat', 'elephant']
spam.remove('bat')
print(spam)  # ['cat', 'rat', 'elephant']

但是，如果試圖刪除列表中不存在的元素，會出現錯誤：

spam = ['cat', 'bat', 'rat', 'elephant']
spam.remove('chicken')  # ValueError: list.remove(x): x not in list

列表排序

列表排序是指將列表中的元素按照一定的順序排列。可以使用 sort() 方法來實作列表排序。例如：

spam = [2, 5, 3.14, 1, -7]
spam.sort()
print(spam)  # [-7, 1, 2, 3.14, 5]

也可以使用 reverse 引數來實作反向排序：

spam = [2, 5, 3.14, 1, -7]
spam.sort(reverse=True)
print(spam)  # [5, 3.14, 2, 1, -7]

需要注意的是，sort() 方法只能對同型別的元素進行排序，如果列表中包含不同型別的元素，會出現錯誤：

spam = [1, 3, 2, 4, 'Alice', 'Bob']
spam.sort()  # TypeError: '<' not supported between instances of 'str' and 'int'

圖表翻譯：

內容解密：

在上面的例子中，我們使用了 insert() 方法來新增新的元素到列表中，使用 remove() 方法來移除列表中的元素，使用 sort() 方法來排序列表中的元素。需要注意的是，sort() 方法只能對同型別的元素進行排序，如果列表中包含不同型別的元素，會出現錯誤。

排序和反轉列表

在 Python 中，sort() 方法用於排序列表中的元素。預設情況下，sort() 方法按照 ASCII 字母順序對字串進行排序，這意味著大寫字母在小寫字母之前。例如：

spam = ['a', 'z', 'A', 'Z']
spam.sort()
print(spam)  # 輸出：['A', 'Z', 'a', 'z']

如果您需要按照實際的字母順序對字串進行排序，可以使用 key 引數並傳遞 str.lower：

spam = ['a', 'z', 'A', 'Z']
spam.sort(key=str.lower)
print(spam)  # 輸出：['a', 'A', 'z', 'Z']

此外，reverse() 方法可以用於反轉列表中的元素：

spam = ['cat', 'dog', 'moose']
spam.reverse()
print(spam)  # 輸出：['moose', 'dog', 'cat']

列表和行繼續

在 Python 中，列表可以跨越多行，並且不需要考慮縮排：

spam = ['apples',
        'oranges',
        'bananas',
        'cats']
print(spam[0])  # 輸出：apples

您也可以使用行繼續符 \ 來將長的程式碼行分割成多行：

print('Four score and seven ' + \
      'years ago...')

短路布林運算子

布林運算子具有短路行為，這意味著如果第一個運算元是 False，則不會評估第二個運算元。例如：

spam = ['cat', 'dog']
if spam[0] == 'cat' and len(spam) > 1:
    print('A cat is the first item.')
else:
    print('No cat found.')

在這個例子中，如果 spam[0] 不是 'cat'，則不會評估 len(spam) > 1。這種短路行為可以提高程式碼的效率。

內容解密：

在上面的程式碼中，我們使用了 sort() 方法對列表進行排序，並使用 key 引數來指定排序的鍵。然後，我們使用 reverse() 方法來反轉列表中的元素。另外，我們還展示瞭如何使用行繼續符 \ 來分割長的程式碼行，並介紹了短路布林運算子的行為。

圖表翻譯：

在這個圖表中，我們展示了排序、反轉和短路布林運算子之間的關係，並強調了程式碼最佳化的重要性。

序列資料型別

在 Python 中，序列資料型別（Sequence Data Types）是指可以儲存多個值的資料結構，並且這些值之間存在著順序關係。常見的序列資料型別包括列表（Lists）、字串（Strings）、範圍物件（Range Objects）和元組（Tuples）。

列表（Lists）

列表是最常用的序列資料型別，列表中的每個元素都可以是任意的資料型別，包括整數、浮點數、字串和其他列表。列表使用方括號 [] 來定義，元素之間使用逗號 , 分隔。

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

# 存取列表中的元素
print(my_list[0])  # 輸出：1
print(my_list[-1])  # 輸出：5

# 切片操作
print(my_list[1:3])  # 輸出：[2, 3]

字串（Strings）

字串是另一種序列資料型別，字串中的每個元素都是單個字元。字串使用引號 "" 或撇號 '' 來定義。

# 定義一個字串
my_string = "Hello, World!"

# 存取字串中的字元
print(my_string[0])  # 輸出：H
print(my_string[-1])  # 輸出：!

# 切片操作
print(my_string[0:5])  # 輸出：Hello

範圍物件（Range Objects）

範圍物件是由 range() 函式傳回的物件，代表了一個數值範圍。範圍物件可以用於迭代和計算。

# 定義一個範圍物件
my_range = range(1, 6)

# 迭代範圍物件
for i in my_range:
    print(i)  # 輸出：1, 2, 3, 4, 5

元組（Tuples）

元組是一種不可變的序列資料型別，元組中的每個元素都可以是任意的資料型別。元組使用圓括號 () 來定義，元素之間使用逗號 , 分隔。

# 定義一個元組
my_tuple = (1, 2, 3, 4, 5)

# 存取元組中的元素
print(my_tuple[0])  # 輸出：1
print(my_tuple[-1])  # 輸出：5

# 切片操作
print(my_tuple[1:3])  # 輸出：(2, 3)

序列資料型別的共同特性

所有的序列資料型別都具有以下共同特性：

  • 索引：可以使用索引來存取序列中的元素。
  • 切片：可以使用切片操作來提取序列中的子序列。
  • 長度：可以使用 len() 函式來取得序列的長度。
  • 迭代：可以使用迭代器來遍歷序列中的元素。
# 定義一個列表
my_list = [1, 2, 3, 4, 5]

# 取得列表的長度
print(len(my_list))  # 輸出：5

# 迭代列表中的元素
for i in my_list:
    print(i)  # 輸出：1, 2, 3, 4, 5

瞭解Python中的可變與不可變資料型別

在Python中，資料型別可以分為可變（mutable）和不可變（immutable）兩種。瞭解這兩種型別的差異對於有效地使用Python進行程式設計至關重要。

可變資料型別

可變資料型別是指可以在建立後修改其內容的資料型別。列表（list）是Python中的一種常見的可變資料型別。列表允許你新增、刪除或修改其元素。

# 建立一個列表
my_list = [1, 2, 3]

# 修改列表中的元素
my_list[0] = 10
print(my_list)  # 輸出：[10, 2, 3]

# 新增新的元素到列表中
my_list.append(4)
print(my_list)  # 輸出：[10, 2, 3, 4]

# 刪除列表中的元素
my_list.remove(2)
print(my_list)  # 輸出：[10, 3, 4]

不可變資料型別

另一方面，不可變資料型別是指一旦建立後，其內容就不能被修改的資料型別。字串（string）是Python中的一種常見的不可變資料型別。

# 建立一個字串
my_string = "Hello"

# 試圖修改字串中的字元會引發TypeError
try:
    my_string[0] = "J"
except TypeError:
    print("字串是不可變的，不能直接修改其字元。")

# 要修改字串，需要建立一個新的字串
new_string = "J" + my_string[1:]
print(new_string)  # 輸出：Jello

使用切片和連線來修改字串

由於字串是不可變的，所以如果你想要修改一個字串，你需要使用切片和連線來建立一個新的字串。

# 原始字串
original_string = "Zophie a cat"

# 使用切片和連線來修改字串
new_string = original_string[0:7] + "the" + original_string[8:12]
print(new_string)  # 輸出：Zophie the cat

列表的重新指定

雖然列表是可變的，但重新指定一個新的列表到一個變數上，並不會修改原來的列表。

# 原始列表
eggs = ['A', 'B', 'C']

# 重新指定一個新的列表
eggs = ['x', 'y', 'z']
print(eggs)  # 輸出：['x', 'y', 'z']

瞭解列表和元組的差異

在 Python 中，列表（list）和元組（tuple）都是用來儲存多個值的資料結構。但是，它們之間存在一些重要的差異。

列表（List）

列表是可變的（mutable），意味著你可以在建立後修改它的內容。列表使用方括號 [] 來定義，例如：

my_list = ['A', 'B', 'C']

你可以使用 append() 方法新增新元素，使用 del 陳述式刪除元素，或者使用索引來修改現有的元素。

元組（Tuple）

元組是不可變的（immutable），意味著你不能在建立後修改它的內容。元組使用圓括號 () 來定義，例如：

my_tuple = ('hello', 42, 0.5)

元組和列表一樣，可以使用索引來存取元素，但你不能修改或刪除元素。

列表和元組的轉換

你可以使用 list() 函式將元組轉換為列表，或者使用 tuple() 函式將列表轉換為元組。例如：

my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple)  # (1, 2, 3)

my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)  # [1, 2, 3]

使用元組的好處

使用元組有兩個好處：

  1. 不可變性：元組的內容不能被修改，這可以確保你的程式碼的正確性和安全性。
  2. 效率：因為元組是不可變的，Python 可以對它們進行最佳化，使得使用元組的程式碼比使用列表的程式碼更快。
內容解密：
  • 列表和元組都是序列資料結構。
  • 列表是可變的，元組是不可變的。
  • 可以使用 list() 函式將元組轉換為列表，或者使用 tuple() 函式將列表轉換為元組。
  • 使用元組可以確保程式碼的正確性和安全性，並且可以提高效率。

圖表翻譯：

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

title Python 列表操作與資料結構應用

package "Python 應用架構" {
    package "應用層" {
        component [主程式] as main
        component [模組/套件] as modules
        component [設定檔] as config
    }

    package "框架層" {
        component [Web 框架] as web
        component [ORM] as orm
        component [非同步處理] as async
    }

    package "資料層" {
        database [資料庫] as db
        component [快取] as cache
        component [檔案系統] as fs
    }
}

main --> modules : 匯入模組
main --> config : 載入設定
modules --> web : HTTP 處理
web --> orm : 資料操作
orm --> db : 持久化
web --> cache : 快取查詢
web --> async : 背景任務
async --> fs : 檔案處理

note right of web
  Flask / FastAPI / Django
end note

@enduml

這個圖表展示了列表和元組之間的關係，以及使用元組的好處。

練習程式：硬幣猜測遊戲 結論

從使用者經驗視角來看，這個硬幣猜測遊戲的程式碼片段雖然簡潔，但缺少核心遊戲邏輯和錯誤處理機制。分析程式碼可以發現，它只實作了讓玩家輸入heads或tails的功能，但缺乏隨機產生硬幣結果、判斷猜測是否正確、以及限制猜測次數等關鍵環節。此外，程式碼沒有處理使用者可能輸入錯誤指令的情況，例如輸入數字或其他字串，這會導致程式無法預期地執行。雖然 Python 的列表和字串操作功能強大，能有效處理使用者輸入和遊戲邏輯，但本程式並未善加利用。對於想學習 Python 遊戲開發的初學者，建議參考更完整的遊戲範例，學習如何使用random模組、迴圈控制和條件判斷來構建更具互動性和趣味性的遊戲。未來可以加入計分、難度調整等功能，提升遊戲體驗。玄貓認為，完善核心遊戲邏輯和加入錯誤處理機制，才能將這個簡單的程式碼片段發展成一個真正可玩的遊戲。