Python 列表、元組與集合操作詳解

– 15 分鐘閱讀

Python 的列表、元組和集合是常見的資料結構，各有其特性和適用場景。列表使用方括號 [] 定義，元素可變，支援新增、刪除、修改等操作。元組則以圓括號 () 定義，元素不可變，適用於儲存固定資料。集合使用大括號 {} 定義，元素不重複且無序，適合用於成員測試和去除重複值。理解這些資料結構的特性，有助於選擇合適的結構來處理不同型別的資料，提升程式碼效率。Python 也提供了豐富的運算子，例如算術、比較、位元、邏輯、成員和身份運算子，這些運算子結合變數和常數，構成了表示式，是程式運算的基礎。

列表與元組的比較，可修改性是關鍵差異，列表的彈性使其適用於動態資料處理，而元組的不可變性則確保了資料的完整性。集合則提供了高效的成員測試和去重功能。Python 的運算子種類繁多，涵蓋了算術、比較、位元、邏輯等多種運算，熟練掌握運算子的優先順序和使用方法，是撰寫高效 Python 程式碼的關鍵。

列表

列表是最常用的序列資料型態之一，它可以儲存多種型別的元素，包括字串、整數、浮點數等。列表的元素是可以修改的，也就是說你可以在列表中新增、刪除或修改元素。列表使用方括號 [] 來定義，並使用逗號 , 來分隔元素。

my_list = ['albert', 145, 3.14, 'raman', 36]
print(my_list)  # 顯示列表
print(my_list[0])  # 顯示列表的第一個元素
print(my_list[0:4])  # 顯示列表從第一個元素到第四個元素
print(my_list[2:])  # 顯示列表從第三個元素到結尾

列表也支援運算子，如 * 用於重複列表，+ 用於合併列表。

small_list = [654, 'bose']
print(small_list * 4)  # 重複小列表 4 次
print(my_list + small_list)  # 合併列表

元組

元組是另一種序列資料型態，它也可以儲存多個元素。與列表不同，元組的元素是不可修改的，也就是說你不能在元組中新增、刪除或修改元素。元組使用圓括號 () 來定義，並使用逗號 , 來分隔元素。

my_tuple = ('albert', 145, 3.14, 'raman', 36)
print(my_tuple)  # 顯示元組
print(my_tuple[0])  # 顯示元組的第一個元素
print(my_tuple[0:4])  # 顯示元組從第一個元素到第四個元素
print(my_tuple[2:])  # 顯示元組從第三個元素到結尾

元組也支援運算子，如 * 用於重複元組，+ 用於合併元組。

small_tuple = (654, 'bose')
print(small_tuple * 4)  # 重複小元組 4 次
print(my_tuple + small_tuple)  # 合併元組

列表和元組的主要差異

  1. 可修改性：列表的元素是可以修改的，而元組的元素是不可修改的。
  2. 定義符號：列表使用方括號 [] 來定義，而元組使用圓括號 () 來定義。
  3. 使用場合：列表適合用於需要頻繁修改的資料，而元組適合用於需要保持不變的資料。

圖表翻譯：

  flowchart TD
    A[列表] --> B[可修改]
    A --> C[使用方括號 []]
    D[元組] --> E[不可修改]
    D --> F[使用圓括號 ()]
    B --> G[頻繁修改]
    E --> H[保持不變]

這個圖表顯示了列表和元組的主要差異，包括可修改性、定義符號和使用場合。

Python 程式設計與集合

Python是一種強大的程式設計語言，支援集合（Set）的概念。集合是一組無序的專案，必須使用大括號（{}）括住，並使用逗號分隔專案。Python解譯器會自動移除重複的專案。

集合運算

集合支援基本運算，如交集（Intersection）、聯集（Union）、差集（Difference）和對稱差集（Symmetric Difference）。以下是集合運算的範例：

a = {4, 5, 5, 6, 6, 6}  # 集合 a
b = {4, 7, 8}  # 集合 b

c = a.union(b)  # 聯集
d = a.intersection(b)  # 交集
e = a.difference(b)  # 差集
f = a.symmetric_difference(b)  # 對稱差集

print(c)
print(d)
print(e)
print(f)

變數指定

在Python中，變數指定是透過使用指定運算子（=）來完成的。當變數被例項化時，Python解譯器會分配記憶體位置給變數，記憶體位置的大小取決於變數的資料型別。

speed = 1000  # 整數指定
pi = 3.14  # 浮點數指定
name = "Albert"  # 字串指定

print(speed)
print(pi)
print(name)

多重指定

Python也支援多重指定，可以同時指定多個變數。

j = k = l = 15
x, y, z = 21, 22, "Albert"

基本運運算元

運運算元是程式設計語言中的基本構造，用於操縱運算元的值。Python的運運算元可以分為以下幾類：

  • 算術運運算元
  • 比較運運算元
  • 指定運運算元
  • 邏輯運運算元
  • 位元運運算元
  • 成員運運算元
  • 身份運運算元

算術運運算元

算術運運算元用於執行基本的算術運算，如加、減、乘、除等。

a = 7
b = 3
print(a + b)  # 加
print(a - b)  # 減
print(a * b)  # 乘
print(a / b)  # 除

比較運運算元

比較運運算元用於比較兩個運算元的值。

a = 7
b = 3
print(a > b)  # 大於
print(a < b)  # 小於
print(a == b)  # 等於
print(a != b)  # 不等於

指定運運算元

指定運運算元用於指定變數。

a = 7
b = 3
a += b  # 相加後指定
print(a)

邏輯運運算元

邏輯運運算元用於執行邏輯運算，如與、或、非等。

a = True
b = False
print(a and b)  # 與
print(a or b)  # 或
print(not a)  # 非

位元運運算元

位元運運算元用於執行位元運算，如位元與、位元或、位元非等。

a = 7
b = 3
print(a & b)  # 位元與
print(a | b)  # 位元或
print(~a)  # 位元非

成員運運算元

成員運運算元用於檢查運算元是否為集合的成員。

a = {1, 2, 3}
b = 2
print(b in a)  # 成員
print(b not in a)  # 非成員

身份運運算元

身份運運算元用於檢查兩個運算元是否為同一物件。

a = [1, 2, 3]
b = [1, 2, 3]
print(a is b)  # 身份
print(a is not b)  # 非身份
圖表翻譯：
  graph LR
    A[Python] -->|支援|> B[集合]
    B -->|包含|> C[交集]
    B -->|包含|> D[聯集]
    B -->|包含|> E[差集]
    B -->|包含|> F[對稱差集]
    C -->|使用|> G[union()]
    D -->|使用|> H[intersection()]
    E -->|使用|> I[difference()]
    F -->|使用|> J[symmetric_difference()]

程式設計基礎：運運算元與表示式

在程式設計中，運運算元（operators）是用來進行各種運算的符號，例如加法、減法、乘法、除法等。這些運運算元可以用來操作變數（variables）和常數（constants），從而形成表示式（expressions）。

算術運運算元

算術運運算元是用來進行基本的算術運算，例如加法、減法、乘法、除法等。以下是Python中的一些常見算術運運算元：

運運算元名稱說明
+加法對兩個運算元進行加法運算
-減法對兩個運算元進行減法運算
*乘法對兩個運算元進行乘法運算
/除法對兩個運算元進行除法運算
%取餘數對兩個運算元進行取餘數運算
**指數對兩個運算元進行指數運算
//地板除法對兩個運算元進行地板除法運算

例如：

x = 5
y = 3
print(x + y)  # 輸出：8
print(x - y)  # 輸出：2
print(x * y)  # 輸出：15
print(x / y)  # 輸出：1.6666666666666667
print(x % y)  # 輸出：2
print(x ** y)  # 輸出：125
print(x // y)  # 輸出：1

比較運運算元

比較運運算元是用來比較兩個運算元的大小或相等性。以下是Python中的一些常見比較運運算元：

運運算元名稱說明
==相等檢查兩個運算元是否相等
!=不相等檢查兩個運算元是否不相等
>大於檢查一個運算元是否大於另一個運算元
<小於檢查一個運算元是否小於另一個運算元
>=大於或相等檢查一個運算元是否大於或相等於另一個運算元
<=小於或相等檢查一個運算元是否小於或相等於另一個運算元

例如：

x = 5
y = 3
print(x == y)  # 輸出：False
print(x != y)  # 輸出：True
print(x > y)  # 輸出：True
print(x < y)  # 輸出：False
print(x >= y)  # 輸出：True
print(x <= y)  # 輸出：False

指派運運算元

指派運運算元是用來將一個值指派給一個變數。以下是Python中的一些常見指派運運算元：

運運算元名稱說明
=指派將一個值指派給一個變數
+=加法指派將一個值加法指派給一個變數
-=減法指派將一個值減法指派給一個變數
*=乘法指派將一個值乘法指派給一個變數
/=除法指派將一個值除法指派給一個變數
%=取餘數指派將一個值取餘數指派給一個變數
**=指數指派將一個值指數指派給一個變數
//=地板除法指派將一個值地板除法指派給一個變數

例如：

x = 5
x += 3  # 相當於 x = x + 3
print(x)  # 輸出：8
x -= 2  # 相當於 x = x - 2
print(x)  # 輸出：6
x *= 2  # 相當於 x = x * 2
print(x)  # 輸出：12
x /= 2  # 相當於 x = x / 2
print(x)  # 輸出：6.0
x %= 3  # 相當於 x = x % 3
print(x)  # 輸出：0
x **= 2  # 相當於 x = x ** 2
print(x)  # 輸出：0
x //= 2  # 相當於 x = x // 2
print(x)  # 輸出：0

位元運運算元

位元運運算元是用來進行位元運算的。以下是Python中的一些常見位元運運算元：

運運算元名稱說明
&位元AND對兩個運算元進行位元AND運算
``位元OR
^位元XOR對兩個運算元進行位元XOR運算
~位元NOT對一個運算元進行位元NOT運算
<<位元左移將一個運算元進行位元左移運算
>>位元右移將一個運算元進行位元右移運算

例如：

x = 5  # 00000101
y = 3  # 00000011
print(x & y)  # 輸出：1  # 00000001
print(x | y)  # 輸出：7  # 00000111
print(x ^ y)  # 輸出：6  # 00000110
print(~x)  # 輸出：-6  # 11111010
print(x << 2)  # 輸出：20  # 00010100
print(x >> 2)  # 輸出：1  # 00000001

內容解密：

以上的程式碼示範了Python中各種運運算元的使用方法，包括算術運運算元、比較運運算元、指派運運算元、位元運運算元等。每個運運算元都有其特定的功能和使用方法，需要根據具體的情況選擇適合的運運算元。同時，程式碼中也使用了變數和常數，展示瞭如何使用運運算元進行計算和操作。

Python 程式設計概覽

Python 是一種高階程式設計語言，具有簡潔的語法和豐富的功能。以下是 Python 的一些基本運算子和資料型別。

位元運算子

Python 支援以下位元運算子：

  • & (位元 AND)：將兩個運算元的對應位元進行 AND 運算。
  • | (位元 OR)：將兩個運算元的對應位元進行 OR 運算。
  • ^ (位元 XOR)：將兩個運算元的對應位元進行 XOR 運算。
  • ~ (位元補數)：將運算元的所有位元進行補數運算。
  • << (位元左移)：將運算元的所有位元左移指定的位數。
  • >> (位元右移)：將運算元的所有位元右移指定的位數。

邏輯運算子

Python 支援以下邏輯運算子：

  • and (邏輯 AND)：如果兩個運算元都為真，則結果為真。
  • or (邏輯 OR)：如果至少有一個運算元為真，則結果為真。
  • not (邏輯 NOT)：將運算元的邏輯值進行反轉。

成員運算子

Python 支援以下成員運算子：

  • in (成員運算子)：檢查運算元是否為序列（如列表、元組或字串）的成員。
  • not in (非成員運算子)：檢查運算元是否不為序列的成員。

身分運算子

Python 支援以下身分運算子：

  • is (身分運算子)：檢查兩個運算元是否指向相同的物件。
  • is not (非身分運算子)：檢查兩個運算元是否不指向相同的物件。

以下是示例程式碼：

a = 'Albert'
print('A' in a)  # 結果為 True
print('s' not in a)  # 結果為 True

b = 5
c = 5
print(b is c)  # 結果為 True
print(b is not c)  # 結果為 False

內容解密：

上述程式碼示範了 Python 的基本運算子和資料型別。位元運算子用於進行位元層面的運算，邏輯運算子用於進行邏輯判斷，成員運算子用於檢查運算元是否為序列的成員，身分運算子用於檢查兩個運算元是否指向相同的物件。

圖表翻譯：

  flowchart TD
    A[運算元] --> B[位元運算子]
    B --> C[邏輯運算子]
    C --> D[成員運算子]
    D --> E[身分運算子]
    E --> F[結果]

上述圖表示範了 Python 的運算子之間的關係。運算元可以進行位元運算、邏輯運算、成員運算和身分運算，最終得到結果。

Python邏輯運運算元和運運算元優先順序

Python是一種強大的程式設計語言，支援多種運運算元，包括邏輯運運算元、算術運運算元、比較運運算元等。在本文中，我們將介紹Python的邏輯運運算元和運運算元優先順序。

邏輯運運算元

Python的邏輯運運算元包括and、or和not。這些運運算元用於組合條件語句，實作邏輯判斷。

  • and（邏輯與）：只有當兩個條件都為真時，才傳回真。
  • or（邏輯或）：只要有一個條件為真，就傳回真。
  • not（邏輯非）：對一個條件進行否定，如果條件為真，則傳回假；如果條件為假，則傳回真。

以下是Python邏輯運運算元的示例：

a = 10
b = 0

# 邏輯與
print(a and b)  # False

# 邏輯或
print(a or b)  # True

# 邏輯非
print(not (a and b))  # True

身份運運算元

Python的身份運運算元包括is和is not。這些運運算元用於比較兩個物件是否為同一個物件。

  • is：如果兩個物件是同一個物件，則傳回真。
  • is not：如果兩個物件不是同一個物件，則傳回真。

以下是Python身份運運算元的示例：

x = 'Albert'
y = 'Albert'

print(x is y)  # True

a = 10
b = 10

print(a is not b)  # False

運運算元優先順序

Python的運運算元優先順序是指當多個運運算元出現在一個表示式中時，哪個運運算元先被執行。以下是Python運運算元的優先順序表：

運運算元描述
**指數運運算元
~、+、-位元運運算元
*、/、%、//算術運運算元
+、-算術運運算元
<<、>>位元運運算元
&位元運運算元
^位元運運算元
``
==、!=、>、<、>=、<=比較運運算元
is、is not身份運運算元
in、not in成員運運算元
not邏輯運運算元
and邏輯運運算元
or邏輯運運算元
=、+=、-=、*=、/=、//=、%=、**=指派運運算元

當多個運運算元出現在一個表示式中時，Python會按照運運算元的優先順序執行運運算元。以下是Python運運算元優先順序的示例：

a = 10
b = 3

print(a + b * 2)  # 16

在這個示例中，*運運算元的優先順序高於+運運算元，所以b * 2先被執行，然後才執行a +運運算元。

圖表翻譯：

  graph LR
    A[運運算元優先順序] --> B[指數運運算元]
    B --> C[位元運運算元]
    C --> D[算術運運算元]
    D --> E[比較運運算元]
    E --> F[身份運運算元]
    F --> G[邏輯運運算元]
    G --> H[指派運運算元]

在這個圖表中，我們可以看到Python運運算元的優先順序。指數運運算元優先順序最高，指派運運算元優先順序最低。

運運算元與表示式

在程式設計中，運運算元（operator）是用來進行特定操作的符號，例如加法、減法、乘法、除法等。運運算元可以用來操作變數、常數或其他運算式，從而得到新的值。

指數運算

指數運算是用來計算一個數字的指數的。例如，2**3 代表 2 的 3 次方，等於 8。

位元運算

位元運算是用來操作二進位制數字的個別位元。常見的位元運算包括：

  • 位元與（&）：兩個位元都為 1 時，結果為 1。
  • 位元或（|）：兩個位元至少有一個為 1 時，結果為 1。
  • 位元異或（^）：兩個位元不同時，結果為 1。
  • 位元左移（<<）：將位元向左移動指定的位數。
  • 位元右移（>>）：將位元向右移動指定的位數。

比較運算

比較運算是用來比較兩個值的大小或相等性。常見的比較運算包括：

  • 小於（<）
  • 小於或等於（<=）
  • 大於（>）
  • 大於或等於（>=）
  • 等於（==）
  • 不等於（!=）

指定運算

指定運算是用來將一個值指定給變數。常見的指定運算包括：

  • 指定（=）
  • 加法指定（+=）
  • 減法指定（-=）
  • 乘法指定（*=）
  • 除法指定（/=）
  • 指數指定（**=）

身分運算

身分運算是用來比較兩個物件的身分。常見的身分運算包括：

  • 是（is）
  • 不是（is not）

成員運算

成員運算是用來檢查一個值是否在集合中。常見的成員運算包括：

  • 在（in）
  • 不在（not in）
# 位元與運算
a = 5   # 101
b = 3   # 011
result = a & b  # 001
print(result)  # 1

# 位元或運算
a = 5   # 101
b = 3   # 011
result = a | b  # 111
print(result)  # 7

# 位元左移運算
a = 5   # 101
result = a << 1  # 1010
print(result)  # 10

# 位元右移運算
a = 10  # 1010
result = a >> 1  # 101
print(result)  # 5

# 比較運算
a = 5
b = 3
print(a < b)  # False
print(a <= b)  # False
print(a > b)  # True
print(a >= b)  # True
print(a == b)  # False
print(a != b)  # True

# 指定運算
a = 5
a += 3
print(a)  # 8

# 身分運算
a = [1, 2, 3]
b = [1, 2, 3]
print(a is b)  # False
print(a is not b)  # True

# 成員運算
a = [1, 2, 3]
print(1 in a)  # True
print(4 in a)  # False
print(1 not in a)  # False
print(4 not in a)  # True

圖表翻譯：

  flowchart TD
    A[運運算元] --> B[指數運算]
    A --> C[位元運算]
    A --> D[比較運算]
    A --> E[指定運算]
    A --> F[身分運算]
    A --> G[成員運算]
    B --> H[計算指數]
    C --> I[位元與]
    C --> J[位元或]
    C --> K[位元左移]
    C --> L[位元右移]
    D --> M[比較大小]
    D --> N[比較相等]
    E --> O[指定值]
    E --> P[加法指定]
    E --> Q[減法指定]
    F --> R[比較身分]
    G --> S[檢查成員]

程式設計中的決策

在程式設計中，決策是透過評估表示式並產生真（TRUE）或假（FALSE）結果來實作的。根據結果，程式會執行不同的動作。這種決策結構在大多數程式設計語言中都存在，包括Python。

Python中的決策結構

Python提供了多種決策結構，包括if語句、if...else語句和if...elif...else語句。if語句由一個布林表示式和一組動作組成。如果布林表示式為真，則執行動作。if...else語句在if語句的基礎上增加了一個else子句，如果布林表示式為假，則執行else子句中的動作。

範例程式

以下是一個示範Python決策結構的程式：

a = 50

if a == 50:
    print("值為50")

if a == 50:
    print("值為50")
else:
    print("值不為50")

a = 10

if a == 50:
    print("值為50")
elif a > 50:
    print("值大於50")
else:
    print("值小於50")

迴圈

在程式設計中，語句通常按順序執行。但有時，程式設計師需要重複執行一段程式碼。Python提供了多種控制結構來實作這種需求，包括迴圈。迴圈是一種控制結構，允許程式重複執行一段程式碼。

Python中的迴圈

Python提供了多種迴圈結構，包括for迴圈和while迴圈。for迴圈用於迭代序列（如列表或字串），而while迴圈用於重複執行一段程式碼，直到某個條件為真。

內容解密：

在上述程式中，if語句和if...else語句用於決策，而elif語句用於檢查多個條件。如果所有條件都為假，則執行else子句中的動作。迴圈結構（如for和while）用於重複執行一段程式碼。

圖表翻譯：

  flowchart TD
    A[開始] --> B[決策]
    B --> C[執行動作]
    C --> D[迴圈]
    D --> E[重複執行]
    E --> F[結束]

在這個流程圖中，程式從開始（A）開始，然後進行決策（B）。如果決策結果為真，則執行動作（C）。如果需要重複執行一段程式碼，則使用迴圈（D）和重複執行（E）。最後，程式結束（F）。

迴圈控制

迴圈是一種程式設計的基本結構，允許程式重複執行某段程式碼。Python 中有兩種主要的迴圈：while 迴圈和 for 迴圈。

從程式語言核心要素的視角來看，Python 的列表、元組和集合，以及運運算元與表示式、決策和迴圈控制結構，構成了程式設計的基本。列表和元組作為序列型別，在資料儲存和操作方面扮演著重要角色，而集合則提供了高效的元素去重和運算功能。它們之間的差異，特別是可變性與不可變性的區別，是技術選型的關鍵考量。Python豐富的運運算元，涵蓋算術、比較、位元、邏輯等多個層面，結合表示式和運運算元優先順序，賦予了程式強大的運算和邏輯判斷能力。然而，不同運運算元之間的優先順序和結合性，以及位元運算的底層邏輯，對開發者理解程式行為至關重要，也可能成為程式錯誤的潛在來源。決策結構和迴圈控制，則賦予了程式根據不同條件執行不同程式碼塊，以及重複執行特定程式碼塊的能力，是程式流程控制的核心。對於追求程式碼簡潔性和可讀性的開發者而言，深入理解並善用 Python 的這些核心要素，才能寫出高效且易於維護的程式碼。展望未來，隨著 Python 語言的持續發展，預計這些核心要素將持續最佳化，並與新的程式設計正規化和技術趨勢深度融合，例如非同步程式設計和資料科學領域的應用，進一步提升 Python 的表現力和開發效率。對於臺灣的開發者社群，持續關注並學習這些新技術趨勢，將有助於提升自身技術水平，並在全球軟體開發領域保持競爭力。玄貓認為，掌握這些 Python 的核心要素，是每位 Python 開發者的必經之路。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。