# 主題
* function
* recurrence
* class
# 責編的話
* 內容先以補充為主，之後再濃縮
* 主要是介紹，可參考reference
[TOC]
# function
- [x] 學習目標
* 函式的基礎概念
* 提升程式的可讀性與可維護性。
- [x] 知識點
1.什麼是函式？為什麼要使用函式？
* 函式與程式模組化的關係。
* 使用 def 關鍵字定義函式。
* 函式名稱與命名規範，程式碼縮排規則(`空4格`)，參數
```python=
def 函式名稱(參數)
程式碼
```
3.位置參數與關鍵字參數的區別。
* 預設參數值 (default arguments)。
```python=
# 預設參數值
def greet(name, message="Hello"):
return f"{message}, {name}!"
# 呼叫函式
print(greet("Alice"))
print(greet("Bob", message="Hi"))
```
* 可變參數 (`*args`, `**kwargs`)。(可用表格提取關鍵字比較)
* `*args`：這個語法允許將不確定數量的**無定義字參數**傳遞給函式。`*args` 在函式內部被視為一個包含所有非關鍵字參數的元組。
* `**kwargs`：這個語法允許將不確定數量的**定義參數**傳遞給函式。`**kwargs` 在函式內部被視為一個包含所有關鍵字參數的字典。
```python=
# 使用 *args 處理任意數量的參數
def sum_all(*args):
return sum(args)
print(sum_all(1, 2, 3, 4)) # 10
# 使用 **kwargs 接收關鍵字變數
def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
print_info(name="Alice", age=25, country="USA")
```
* 這種方式對於定義不確定數量的參數很有用，特別是在寫通用的函式時，或者當你不確定有多少參數需要傳遞給函式時。需要注意的是，`*args` 和 `**kwargs` 是約定俗成的命名方式，你可以使用其他名稱，但一般來說，使用這兩個名稱可以讓你的程式碼更易讀。 (撰寫具參數化的通用函式。)
4. 使用 return 關鍵字返回值。
```python
def f(x):
return x**2 - math.cos(x)
```
5. 區分局部變數 (local variables) 與全域變數 (global variables)。(表格部分寫得有點細選擇重要部分說明即可)
* 變數的作用域與生命週期
* 全域變數 (Global Variables) vs 區域變數 (Local Variables)
| 特性 | 全域變數 (Global Variables) | 區域變數 (Local Variables) |
|------------------|--------------------------------------------------|---------------------------------------------|
| **定義範圍** | 程式全域內皆可存取 | 只在函式或區塊內有效 |
| **存取範圍** | 可被任何函式存取與修改 | 只能在定義的函式或區塊內存取 |
| **作用時間** | 自程式執行開始至結束 | 隨函式或區塊執行結束而釋放 |
| **記憶體使用**| 常駐於記憶體，可能耗費較多資源| 僅在函式或區塊執行時分配記憶體 |
| **影響範圍** | 可能導致整個程式的不預期行為（如意外覆蓋變數）| 影響範圍較小，易於維護 |
| **適用場景** | 常用於需共享資料的全域設定（如配置、常數等）| 適用於僅需暫時存取或操作資料的情境 |
| **可讀性** | 可能導致程式較難理解（若過多使用） | 增加可讀性，函式封裝使變數更易追蹤 |
| **修改風險** | 高：任何函式都可能意外更改| 低：僅限定義的函式或區塊能修改 |
6.如何撰寫清晰、簡單且高效的函式。 (選用)
* 函式的測試與除錯技巧。
* 設置中斷點（break point）
* 將變數print出
7.使用 lambda 關鍵字定義匿名函式。
```python=
# 使用 lambda 簡化函式
square = lambda x: x ** 2
print(square(4)) # 16
# 與高階函式結合
numbers = [1, 2, 3, 4]
squared_numbers = list(map(lambda x: x ** 2, numbers))
print(squared_numbers) # [1, 4, 9, 16]
```
* 適合使用匿名函式的場景。
* 快速創建一個小型、臨時性的函數，並且不想為其命名以節省整個記憶體空間時
8.學習 Python 提供的常用內建函式，例如 `len()`、`max()` 等。
```python=
my_string = "Hello World!"
length = len(my_string)
print(length)
```
```python=
print(max(4, 6))
print(max(11, 7))
print(max(16.6, 18.1))
```
9.函式作為參數傳遞給其他函式。
* 使用進階函式，例如 map()、filter() 和 reduce()。
```python=
# 函式作為參數傳遞
def apply_operation(a, b, operation):
return operation(a, b)
# 定義一些操作函式
def multiply(x, y):
return x * y
def subtract(x, y):
return x - y
# 呼叫函式
print(apply_operation(10, 5, multiply)) # 50
print(apply_operation(10, 5, subtract)) # 5
```
# recursion
- [x] 學習目標
* 熟悉 Python 中遞迴 (recursion) 的概念與應用，能夠有效地設計並實現遞迴演算法來解決分治與重複結構的問題
- [ ] 知識點
1.遞迴的基本概念
* 什麼是遞迴？
* 一種通過重複將問題分解為同類的子問題而解決問題的方法
* 遞迴與迴圈的異同。
* 迴圈是大範圍同時執行(跑)，而事先就給了範圍。但遞迴把要做的方法分成一個個小部分，而沒給範圍
* 遞迴的適用場景，例如分治法divide and conquer(分而治之，問題分解成小問題以便解決) 和數學歸納結構(一種數學證明方法，通常被用於證明某個給定命題在整個或者局部自然數範圍內成立。)的問題。
2.遞迴函式的結構
* 基底情況 (base case)：有初始項，避免無限遞迴。
* 遞迴情況 (recursive case)：問題的分解與遞迴的邏輯。
* 遞迴的特性:記憶體消耗與堆疊 (call stack)。
* 最大遞迴深度與 Python 的 RecursionError。
* 遞迴的典型應用:
* (1)數學問題：如階乘 (factorial)、斐波那契數列 (Fibonacci sequence)。
* 階乘函數(factorial)
```python=
def factorial(n):
if n == 0 or n == 1:#基底情況 0! = 1 , 1! = 1
return 1
else:
return n * factorial(n-1)#不是0 or 1呼叫函式自身
i = 5
print(i,"!=", factorial(i)#印出 0!
j = 0
print(j,"!=", factorial(j))#印出 1!
```
* 斐波那契數列 (Fibonacci sequence)
```python=
def fib(n):
if n > 1:
return fib(n-1) + fib(n-2) #呼叫函式本身
return n # 基底條件0、1回傳本身
for i in range(20):
print(fib(i), end = ',') #印到第20項
```
* (2)資料結構問題：如樹的遍歷 (tree traversal)、最大深度計算等。
字串與陣列操作：如反轉字串、搜尋與分割問題。
* (3)分治法應用：如快速排序 (quick sort)、合併排序 (merge sort)。
* quick sort
* merge sort
3.何時應將遞迴轉為迴圈以提升效能與穩定性。
* 使用堆疊模擬遞迴過程。
# class
- [x] 學習目標
* 掌握 Python 中class (類別) 的概念與應用，理解其核心原則之一（繼承），並將其應用於解決實際問題。
- [ ] 知識點
1.類別與物件的基本概念
* 什麼是類別 (class) 和物件 (object)？
* 類別算是一個藍圖、一個範本、一個可參考的文件，他沒有實體(Instance) 的概念，屬靜態的。 物件是一個看的到、摸的到的實體，屬於動態的，狀態會隨時改變，但架構與行為不會改變
| **Aspect** | **Class** | **Object** |
|----------------------|---------------------------------------------------------------------------|----------------------------------------------------------------------|
| **定義 (Definition)** | 類別是一個藍圖或模板，用來定義物件的屬性和行為。 | 物件是類別的實例，表示特定的資料和行為。 |
| **概念 (Concept)** | 類別是抽象的，不消耗記憶體。 | 物件是具體的，消耗記憶體來儲存資料。 |
| **用途 (Purpose)** | 提供一個統一的結構，讓程式具備可重用性與可擴展性。 | 實現類別定義的行為，處理具體資料和任務。 |
| **關係 (Relationship)** | 是物件的模板 (Blueprint)。 | 是類別的實例 (Instance)。 |
| **屬性與模式 (Attributes & Methods)** | 包含定義屬性與方法的程式碼，但不直接執行或儲存特定值。 | 擁有實際的屬性值與行為，可透過方法互動。 |
| **範例 (Example)** | `class Car:` <br>` def __init__(self, brand):` <br>` self.brand = brand` | `my_car = Car("Toyota")` <br> `print(my_car.brand)` (輸出 `Toyota`) |
| **存在性 (Existence)**| 定義時存在於程式碼中。 | 必須通過類別實例化，才能存在於記憶體中並被操作。 | |
* **為什麼使用class來組織程式碼**
* 清晰地表達資料和行為之間的關係。
* 減少程式碼重複，提升效率。
* 提高程式碼的可讀性、可維護性和可擴展性。
* 模擬現實中的概念，使程式設計更貼近現實。
2.定義與實例化類別
* 使用 `class` 關鍵字定義類別。
* 建立類別實例 (物件)。
* `__init__` 方法：初始化屬性，讓物件有自己的資料。
```python
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print(self.name + "正在叫！")
def describe(self):
print(self.name + "的年齡是" + str(self.age) + "歲。")
# 創建 Dog 類別的物件
dog1 = Dog("旺財", 3)
dog2 = Dog("小黑", 2)
# 使用物件的方法
dog1.bark() # 旺財正在叫！
dog2.describe() # 小黑 的年齡是 2 歲。
```
3.類別的屬性與方法
* 定義和使用實例屬性（如物件的特性）。
* 定義和呼叫實例方法（如物件的行為）。
* self 的作用和用法(self代表物件自身)。
```python
class Calculator:
def __init__(self):
pass # 此處無需初始化屬性
def add(self, a, b):
return a + b
def subtract(self, a, b):
return a - b
# 使用類別創建物件並呼叫方法
calc = Calculator()
print(calc.add(10, 5)) # 15
print(calc.subtract(10, 5)) # 5
```
4. class 權限
* 類別成員 x 可以宣告為具有下列其中一個權限:
* public : x 可在任何地方使用，不受專用或受保護所定義的存取限制。
* private : x 只能由類別 A 的成員使用。
* protected : x 只能由類別 A 的成員，以及衍生自類別 A 的類別成員使用
5. 繼承的基本語法與使用方法。
* 子類別 (subclass) 與父類別 (superclass) 的關係。
`super()` 函式的使用。
| **項目** | **父類別 (Superclass)** | **子類別 (Subclass)** |
|--------------------|---------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------|
| **定義** | 提供基礎功能和屬性，是其他類別繼承的來源。| 繼承父類別的功能，可以新增或覆寫部分功能。 |
| **功能重點** | 定義通用的屬性與方法，適用於多個相關類別。 | 擴展或自訂父類別的功能，實現更具體的需求。 |
| **繼承關係** | 不需要繼承其他類別，但可以被其他類別繼承。 | 繼承自父類別，並獲得父類別的所有屬性與方法（除私有屬性外）。 |
| **方法覆寫** | 不會覆寫方法，因為它是功能的來源類別。| 可以覆寫父類別的方法，以實現新的或特定的行為。|
| **關鍵詞** | 常用於建立具有廣泛用途的基底類別 (Base Class)。 | 常用於實現專門化功能，與父類別共享接口 (Interface)。 |
| **注意事項** | 若修改父類別，會影響所有繼承該類別的子類別。 | 子類別應遵循父類別的基本結構，否則可能導致程式出現不一致性問題。|
| **範例** | `class Animal: ` <br>`def speak(self):` <br>` return "This animal makes a sound." ` | `class Dog(Animal):` <br> `def speak(self):` <br> `return "Woof!"` |
* **方法覆寫 (method overriding)**：子類別 (subclass) 重新定義父類別 (superclass) 中已經存在的方法的一種技術。
覆寫的方法在子類別中擁有與父類別相同的名稱和參數，但實現的功能可能不同。這使子類別能根據需求修改或擴展父類別的行為。
```python
# 父類別
class Vehicle:
def __init__(self, brand, speed):
self.brand = brand
self.speed = speed
def move(self):
return f"The {self.brand} moves at {self.speed} km/h."
# 子類別
class Car(Vehicle):
def __init__(self, brand, speed, seats):
super().__init__(brand, speed) # 呼叫父類別初始化
self.seats = seats
def move(self): # 覆寫方法
return f"The {self.brand} car drives at {self.speed} km/h with {self.seats} seats."
# 使用繼承
car = Car("Toyota", 120, 5)
print(car.move())
```
---
# 額外內容
* json
* datatime
* csv
* decimal
* math
* os
# 工作
- [ ] 把內容潤飾
# reference
* 2022資訊之芽 py 語法班
[https://sprout.tw/py2022/slides](https://)
* 為你自己學 PYTHON
https://pythonbook.cc/chapters/basic/variable
* Python 3.13.0 Documentation
https://docs.python.org/3/
* PEP-8 Style Guide
https://peps.python.org/pep-0008/
* Python 基礎筆記：可變動的(mutable)與不可變動的(immutable)
https://medium.com/@oange6214/python-%E5%9F%BA%E7%A4%8E%E7%AD%86%E8%A8%98-%E5%8F%AF%E8%AE%8A%E5%8B%95%E7%9A%84-mutable-%E8%88%87%E4%B8%8D%E5%8F%AF%E8%AE%8A%E5%8B%95%E7%9A%84-immutble-54f1b7a6899
# 圖文編輯寫作要訣
[https://hackmd.io/@robylin/rkgXO18mJx/edit]
Google Drive
Gist
Clipboard
Sign in with Wallet
