# 重複結構（repetition structure）
by : R緯
### 在 Python 中，迴圈、迭代、遍歷和遞迴是四個重要的「重複」概念。
## 1. 迴圈 (Loop)

- **定義**：迴圈是一種控制結構，允許你重複執行一段程式碼。Python 中最常見的迴圈有 `for` 迴圈和 `while` 迴圈。
- **用途**：用於重複執行某些操作，直到滿足特定條件。
- **示例**：

  for i in range(5):  # 使用 for 迴圈
      print(i)  # 輸出 0 到 4

## 2. 迭代 (Iteration)
Python 中，迭代是一種對序列中的元素進行訪問和處理的過程。每次訪問一個元素，稱為一次迭代。迭代可以使用 for 迴圈、while 迴圈等方式實現。

**迭代的語法**

for 變數 in 序列:
    # 處理元素的程式碼

在這個語法中，`變數` 是用來存放每個元素的變數，`序列` 是要迭代的序列。

**迭代的例子**

水果 = ['蘋果', '香蕉', '櫻桃']
for 水果名稱 in 水果:
    print(水果名稱)

在這個例子中，我們對水果列表進行迭代，訪問每個元素並將它印出。

**迭代的優點**

* 可以對序列中的元素進行訪問和處理。
* 可以使用 for 迴圈、while 迴圈等方式實現。
* 可以對大型序列進行迭代。

**迭代的應用**

* 對列表、元組、字串等序列中的元素進行訪問和處理。
* 對數據庫中的資料進行訪問和處理。
* 對文件中的資料進行訪問和處理。

## 3. 遍歷 (Traversal)

**遍歷的基本概念**

在 Python 中，遍歷是一種對數據結構中的元素進行訪問和處理的過程。每次訪問一個元素，稱為一次遍歷。遍歷可以是深度優先（depth-first）或廣度優先（breadth-first）的。

**遍歷的語法**

def 遍歷函數(數據結構, 節點):
    # 處理節點的程式碼
    for 子節點 in 數據結構[節點]:
        遍歷函數(數據結構, 子節點)

在這個語法中，`遍歷函數` 是用來遍歷數據結構的函數，`數據結構` 是要遍歷的數據結構，`節點` 是要訪問的節點。

**遍歷的例子**

樹 = {
    'A': ['B', 'C'],
    'B': ['D', 'E'],
    'C': ['F'],
    'D': [],
    'E': ['F'],
    'F': []
}

def 遍歷樹(樹, 節點):
    print(節點)
    for 子節點 in 樹[節點]:
        遍歷樹(樹, 子節點)

遍歷樹(樹, 'A')

在這個例子中，我們對樹進行遍歷，訪問每個節點並將它印出。

**遍歷的優點**

* 可以對數據結構中的元素進行訪問和處理。
* 可以使用遞迴函數或堆疊實現。
* 可以對大型數據結構進行遍歷。

**遍歷的應用**

* 對樹、圖等數據結構中的元素進行訪問和處理。
* 對文件系統中的檔案進行訪問和處理。
* 對網路中的節點進行訪問和處理。

**深度優先遍歷**

深度優先遍歷是一種遍歷方式，先訪問節點的子節點，然後再訪問節點本身。

**廣度優先遍歷**

廣度優先遍歷是一種遍歷方式，先訪問節點本身，然後再訪問節點的子節點。

**遍歷的實現**

遍歷可以使用遞迴函數或堆疊實現。遞迴函數是一種函數，呼叫自己來實現遍歷。堆疊是一種資料結構，使用堆疊來實現遍歷。

## 4. 遞迴 (Recursion)

- **定義**：遞迴是一種函數調用自身的技術。當函數需要解決一個問題時，它可以將問題分解為更小的子問題，然後調用自身來解決這些子問題。
- **用途**：用於解決可以被分解為相似子問題的問題，如計算階乘、斐波那契數列等。
- **示例**：

  def factorial(n):
      if n == 0:  # 基本情況
          return 1
      else:
          return n * factorial(n - 1)  # 遞迴調用

  print(factorial(5))  # 輸出 120

# 迭代器(Iterator)

Python 迭代器是一個用於遍歷可迭代物件（如列表、元組、字典等）的工具。它允許你一次訪問一個元素，而不需要知道物件的結構或索引。

在 Python 中，任何實現了 `__iter__()` 和 `__next__()` 方法的物件都可以被視為一個迭代器。`__iter__()` 方法返回迭代器物件本身，而 `__next__()` 方法返回下一個元素，如果沒有更多元素，則引發 `StopIteration` 例外。

以下是一個簡單的例子：

my_list = [1, 2, 3, 4, 5]
my_iter = iter(my_list)

print(next(my_iter))  # 輸出: 1
print(next(my_iter))  # 輸出: 2
print(next(my_iter))  # 輸出: 3
print(next(my_iter))  # 輸出: 4
print(next(my_iter))  # 輸出: 5

在這個例子中，`my_list` 是一個可迭代物件，`my_iter` 是一個迭代器物件。通過 `next()` 函數，可以訪問 `my_list` 中的每個元素。

Python 迭代器的優點包括：

* 可以節省內存：迭代器只需要存儲當前元素的索引，而不需要存儲所有元素。
* 可以提高效率：迭代器可以避免不必要的計算和訪問。
* 可以實現懶加載：迭代器可以在需要時才計算下一個元素。

Python 迭代器的應用包括：

* 遍歷列表、元組、字典等可迭代物件。
* 實現生成器和協程。
* 實現懶加載和延遲計算。

以下是一個使用迭代器的實際例子：

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci(10):
    print(num)

在這個例子中，`fibonacci()` 函數是一個生成器，它使用迭代器返回斐波那契數列的前 10 個元素。

## 補充：迭代協議（Iterator Protocol）
迭代協議是一個規範，定義了如何實現迭代器和可迭代物件。

迭代協議由兩個部分組成：

1. `__iter__()`: 這個方法返回迭代器物件本身。它被用於初始化迭代過程。
2. `__next__()`: 這個方法返回下一個元素。如果沒有更多元素，則引發 `StopIteration` 例外。

任何實現了這兩個方法的物件都可以被視為一個迭代器。

以下是一個簡單的例子：

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

my_iter = MyIterator([1, 2, 3, 4, 5])
for num in my_iter:
    print(num)

在這個例子中，`MyIterator` 類實現了迭代協議。它有 `__iter__()` 和 `__next__()` 方法，分別返回迭代器物件本身和下一個元素。

Python 的可迭代物件（如列表、元組、字典等）也實現了迭代協議。這使得你可以使用迭代器遍歷這些物件。

以下是一個簡單的例子：

my_list = [1, 2, 3, 4, 5]
my_iter = iter(my_list)
for num in my_iter:
    print(num)

在這個例子中，`my_list` 是一個可迭代物件，`my_iter` 是一個迭代器物件。通過 `iter()` 函數，可以返回 `my_list` 的迭代器物件。然後，可以使用迭代器遍歷 `my_list` 中的元素。

# `map()`函式
### 語法

map(function, iterable, ...)

- **function**：要應用於每個元素的函數。
- **iterable**：一個或多個可迭代對象（如列表、元組等）。如果有多個可迭代對象，則函數必須接受相同數量的參數。

### 返回值

`map()` 返回一個迭代器，你可以使用 `list()` 或 `tuple()` 等函數將其轉換為列表或元組。

### 使用示例

**多個可迭代對象**：

如果你有多個可迭代對象，可以將它們一起傳遞給 `map()`，函數的參數數量必須與可迭代對象的數量相同：

def add(x, y):
    return x + y

numbers1 = [1, 2, 3]
numbers2 = [4, 5, 6]
result = map(add, numbers1, numbers2)

# 將結果轉換為列表
result_list = list(result)
print(result_list)  # 輸出: [5, 7, 9]

### 總結

- `map()` 函數可以讓你方便地對可迭代對象中的每個元素應用一個函數，並返回一個新的迭代器。