[Python基礎]for迴圈運用zip，enumerate函式

在使用for迴圈時，都想著如何把列表的索引也跟著取出來標記檔案編號，是不是也有一種函式可以辦得到呢?~ 有那就是enumerate。

有時候也想一次做兩件事情，同時左手拿肉吃，右手拿酒喝，在Python中也有類似的作法就是for迴圈應用zip的方法，就能一次處理兩個列表。

語法說明

enumerate 函數：

enumerate(iterable, start=0)

• iterable: 要迭代的可迭代對象，如列表、元組、字典等。
• start（可選）: 起始索引值，預設為 0。

enumerate 函數同樣用於遍歷可迭代對象，但它同時提供了元素的索引。

它返回一個產生元組的迭代器，其中每個元組的第一個元素是索引，第二個元素是原始可迭代對象的值。

程式範例

用於List的索引與元素：

names = ['Alice', 'Bob', 'Charlie']

# 使用 enumerate 遍歷列表並獲取索引和元素
for index, name in enumerate(names):
    print(f"Index: {index}, Name: {name}")
# 輸出:
# Index: 0, Name: Alice
# Index: 1, Name: Bob
# Index: 2, Name: Charlie

用於dit字典：

grades = {'Alice': 90, 'Bob': 75, 'Charlie': 88}

# 使用 enumerate 遍歷字典並獲取鍵和值
for index, (name, score) in enumerate(grades.items()):
    print(f"Index: {index}, Name: {name}, Score: {score}")
# 輸出:
# Index: 0, Name: Alice, Score: 90
# Index: 1, Name: Bob, Score: 75
# Index: 2, Name: Charlie, Score: 88

enumerate 是在迭代中獲取索引和元素值時的一個實用工具，尤其是當你需要追蹤元素的位置時。

zip 函數：

zip 函數接受一個或多個可迭代對象（如列表、元組等），將對應的元素打包成元組的序列。這可以用於同時遍歷多個可迭代對象。

語法：

zip(iterable1, iterable2, ...)

iterable1, iterable2, ...：要打包的可迭代對象，可以是多個。

在這個例子中，zip 將 names 和 ages 兩個可迭代對象的對應元素打包成元組的序列。

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]

# 使用 zip 將兩個可迭代對象打包
zipped_data = zip(names, ages)  

# 將結果轉換為列表
result_list = list(zipped_data)

print(result_list)
# 輸出: [('Alice', 25), ('Bob', 30), ('Charlie', 35)]

範例（創建字典）：

keys = ['name', 'age', 'city']
values = ['Alice', 25, 'New York']

# 使用 zip 創建字典
person_dict = dict(zip(keys, values))

print(person_dict)
# 輸出: {'name': 'Alice', 'age': 25, 'city': 'New York'}

使用 for 迴圈搭配 zip 有以下好處：

1. 同時迭代多個可迭代對象： zip 允許你同時迭代多個可迭代對象，這樣你可以在同一個迴圈中訪問相應位置的元素，使得程式碼更簡潔。
2. 可讀性： 使用 zip 可以提高程式碼的可讀性，因為它明確地表示你正在處理多個對應的元素，而不需要使用索引值。
3. 避免使用索引： 不使用索引值可以減少錯誤的可能性，因為你不需要擔心迭代的範圍或確保兩個可迭代對象具有相同的長度。
4. 應對不同長度的可迭代對象： 如果 zip 的可迭代對象長度不同，它將以最短的長度為基準。這使得在處理不同數據結構時更靈活。

程式範例

同時迭代多個列表：

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
scores = [90, 85, 88]

# 使用 zip 遍歷三個可迭代對象
for name, age, score in zip(names, ages, scores):
    print(f"Name: {name}, Age: {age}, Score: {score}")
# 輸出:
# Name: Alice, Age: 25, Score: 90
# Name: Bob, Age: 30, Score: 85
# Name: Charlie, Age: 35, Score: 88

同時迭代多個字典：

person1 = {'name': 'Alice', 'age': 25, 'city': 'New York'}
person2 = {'name': 'Bob', 'age': 30, 'city': 'San Francisco'}

# 使用 zip 同時迭代多個字典的鍵和值
for (key1, value1), (key2, value2) in zip(person1.items(), person2.items()):
    print(f"Person 1 - {key1}: {value1}, Person 2 - {key2}: {value2}")
# 輸出:
# Person 1 - name: Alice, Person 2 - name: Bob
# Person 1 - age: 25, Person 2 - age: 30
# Person 1 - city: New York, Person 2 - city: San Francisco

zip 還可以應用在不同情境中，包括交換矩陣的行與列、字典的鍵值對調等

交換矩陣的行與列：

zip(*matrix) 將矩陣的行與列交換，然後使用列表解析將其轉換為新的矩陣。

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 使用 zip(*matrix) 交換矩陣的行與列
transposed_matrix = [list(row) for row in zip(*matrix)]

for row in transposed_matrix:
    print(row)
# 輸出:
# [1, 4, 7]
# [2, 5, 8]
# [3, 6, 9]

這裡的 zip(*matrix) 實際上就是zip(matrix[0], matrix[1], matrix[2])，將矩陣中的每一行當作參數傳給zip函式。

zip 函數將每一行的對應位置的元素打包成一個元組。接著，使用列表生成式 [list(row) for row in ...] 將這些元組轉換為列表，最終得到轉置後的矩陣 transposed_matrix。

字典的鍵值對調：

在這個例子中，zip(original_dict.values(), original_dict.keys()) 將字典的鍵和值打包成元組，然後使用 dict() 創建新的字典。

original_dict = {'a': 1, 'b': 2, 'c': 3}

# 使用 zip 將字典的鍵和值對調
swapped_dict = dict(zip(original_dict.values(), original_dict.keys()))

print(swapped_dict)
# 輸出: {1: 'a', 2: 'b', 3: 'c'}

謝謝大家觀看~ 希望大家會喜歡，喜歡的話可以給愛心~追蹤一下，不會漏掉之後的文章喔~