2025年10月13日 星期一

[水井USR創新教材]Python一下用水井三寶來看字串正規表示式的用法



以下是用Grok AI生成。 

以「水井三寶」(烏龜、白馬、姻緣花)為主題,設計一個 Python 小範例,展示如何使用隨機密碼生成器來產生與水井三寶相關的密碼。這個範例會結合物件導向程式設計(OOP)和 Python 的 random 模組,生成帶有三寶特色的密碼(例如包含「烏龜」、「白馬」、「姻緣花」的主題詞,並混雜隨機字元)。我們會使用封裝來管理密碼生成邏輯,並透過繼承讓每個寶物有獨特的密碼風格。

情境設定

假設我們要為水井三寶的每種寶物生成專屬密碼:

  • 烏龜:密碼強調「長壽」,包含數字(年份)並較長。
  • 白馬:密碼強調「迅捷」,包含特殊字元(象徵速度)並中等長度。
  • 姻緣花:密碼強調「浪漫」,包含字母和愛心符號,較短但優雅。

每個密碼會結合寶物名稱、隨機字元(字母、數字、特殊符號),並確保安全性和隨機性。

範例程式碼

以下是一個完整的 Python 程式,展示如何用 OOP 和隨機模組生成水井三寶主題的密碼。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
import random
import string

class Treasure:
    """基類:定義水井三寶密碼生成器的共同行為"""
    def __init__(self, name):
        self.name = name
        self._charset = string.ascii_letters + string.digits + string.punctuation  # 基本字元集

    def generate_password(self, length=8):
        """生成隨機密碼,包含寶物名稱"""
        random_part = ''.join(random.choice(self._charset) for _ in range(length - len(self.name)))
        password = self.name + random_part
        # 打亂密碼字元
        password = ''.join(random.sample(password, len(password)))
        return password

class Turtle(Treasure):
    """烏龜:生成長壽主題的長密碼,強調數字"""
    def __init__(self):
        super().__init__("烏龜")
        self._charset = string.digits  # 烏龜密碼以數字為主

    def generate_password(self, length=12):
        """覆寫:生成12位密碼,包含至少4個數字"""
        random_part = ''.join(random.choice(self._charset) for _ in range(4))  # 4個數字
        extra_part = ''.join(random.choice(string.ascii_letters) for _ in range(length - 4 - len(self.name)))
        password = self.name + random_part + extra_part
        return ''.join(random.sample(password, len(password)))

class WhiteHorse(Treasure):
    """白馬:生成迅捷主題的密碼,包含特殊字元"""
    def __init__(self):
        super().__init__("白馬")
        self._charset = string.punctuation  # 白馬密碼以特殊字元為主

    def generate_password(self, length=10):
        """覆寫:生成10位密碼,包含至少3個特殊字元"""
        random_part = ''.join(random.choice(self._charset) for _ in range(3))  # 3個特殊字元
        extra_part = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(length - 3 - len(self.name)))
        password = self.name + random_part + extra_part
        return ''.join(random.sample(password, len(password)))

class MarriageFlower(Treasure):
    """姻緣花:生成浪漫主題的短密碼,包含愛心符號"""
    def __init__(self):
        super().__init__("姻緣花")
        self._charset = string.ascii_letters + "♥"  # 包含愛心符號

    def generate_password(self, length=8):
        """覆寫:生成8位密碼,包含至少1個愛心符號"""
        random_part = random.choice("♥")  # 至少1個愛心
        extra_part = ''.join(random.choice(string.ascii_letters) for _ in range(length - 1 - len(self.name)))
        password = self.name + random_part + extra_part
        return ''.join(random.sample(password, len(password)))

# 測試範例
if __name__ == "__main__":
    # 創建水井三寶實例
    turtle = Turtle()
    horse = WhiteHorse()
    flower = MarriageFlower()

    # 生成並展示密碼
    treasures = [turtle, horse, flower]
    for treasure in treasures:
        print(f"{treasure.name} 的密碼:{treasure.generate_password()}")

執行結果:
烏龜 的密碼:uY4龜8烏VcwU48
白馬 的密碼:v馬Gn白[X+'T
姻緣花 的密碼:a姻♥花Gqt緣

程式碼解析

  1. 正規表示式相關性
    • 雖然本題聚焦密碼生成,但可以延伸到正規表示式。例如,生成的密碼可透過 regex 驗證是否包含特定字元(例如 \d+ 檢查數字、[!@#$%^&*] 檢查特殊字元)。
    • 範例中未直接使用 regex,但可添加驗證(見下方擴展建議)。
  2. OOP 技術應用
    • 繼承:Turtle、WhiteHorse 和 MarriageFlower 繼承 Treasure,共享基本密碼生成邏輯。
    • 多型:每個子類別覆寫 generate_password,生成符合自身主題的密碼。
    • 封裝:_charset 是保護屬性,控制可用的字元集。
    • 類與實例屬性:name 是實例屬性,確保每個寶物有獨特名稱;_charset 在子類別中自訂。
  3. 隨機密碼生成
    • 使用 random.choice 從字元集中選取字元。
    • 使用 random.sample 打亂密碼字元,增加隨機性。
    • 每個寶物有不同長度和字元偏好:
      • 烏龜:12位,強調數字。
      • 白馬:10位,包含特殊字元。
      • 姻緣花:8位,包含愛心符號 ♥。
  4. 安全考量
    • 密碼包含寶物名稱和隨機字元,並透過 random.sample 打亂,避免可預測性。
    • 真實應用中應使用 secrets 模組(更安全),但為簡單起見這裡用 random。

[水井USR創新教材]Python一下用水井三寶來看字串正規表示式的用法

圖:2025/10/13 在竹山鎮小鎮文創的協助下,尚虎雲在台西客運中展出作品,水井三寶是其中一件作品。

以下是採Grok AI生成的。 

以「水井三寶」(烏龜、白馬、姻緣花)為主題,設計一個 Python 小範例來展示正規表示式(Regular Expression, regex)的應用。這個範例會結合物件導向程式設計(OOP)和正規表示式,聚焦於如何使用 re 模組來處理與水井三寶相關的文字資料。每個寶物會有一個專屬的正規表示式模式,用於解析特定格式的吉祥訊息,並展示 OOP 的封裝特性來管理正規表示式邏輯。

情境設定

假設我們有一段文字,包含水井三寶的吉祥訊息,例如:

  • 「烏龜祝福:長壽100年」
  • 「白馬祝福:奔馳500公里」
  • 「姻緣花祝福:愛情99朵」 我們希望用正規表示式提取每個寶物的名稱和數值(例如年數、公里數、朵數),並透過類來管理這些模式和處理邏輯。

範例程式碼

以下是一個完整的 Python 範例,結合正規表示式和 OOP,並使用「水井三寶」來解析吉祥訊息。程式碼使用封裝來管理正規表示式,並提供簡單的處理方法。


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import re

class Treasure:
    """基類:定義水井三寶的共同行為"""
    def __init__(self, name):
        self.name = name
        self._pattern = None  # 保護屬性:正規表示式模式

    def extract_value(self, message):
        """提取訊息中的數值,使用正規表示式"""
        if not self._pattern:
            return f"{self.name} 尚未定義正規表示式!"
        match = re.match(self._pattern, message)
        if match:
            return f"{self.name} 提取到:{match.group(1)}"
        return f"{self.name} 無法解析訊息:{message}"

class Turtle(Treasure):
    """烏龜:解析 '長壽X年' 的訊息"""
    def __init__(self):
        super().__init__("烏龜")
        # 正規表示式:匹配 "烏龜祝福:長壽數字年"
        self._pattern = r"烏龜祝福:長壽(\d+)年"

class WhiteHorse(Treasure):
    """白馬:解析 '奔馳X公里' 的訊息"""
    def __init__(self):
        super().__init__("白馬")
        # 正規表示式:匹配 "白馬祝福:奔馳數字公里"
        self._pattern = r"白馬祝福:奔馳(\d+)公里"

class MarriageFlower(Treasure):
    """姻緣花:解析 '愛情X朵' 的訊息"""
    def __init__(self):
        super().__init__("姻緣花")
        # 正規表示式:匹配 "姻緣花祝福:愛情數字朵"
        self._pattern = r"姻緣花祝福:愛情(\d+)朵"

# 測試範例
if __name__ == "__main__":
    # 創建水井三寶實例
    turtle = Turtle()
    horse = WhiteHorse()
    flower = MarriageFlower()

    # 測試訊息
    messages = [
        "烏龜祝福:長壽100年",
        "白馬祝福:奔馳500公里",
        "姻緣花祝福:愛情99朵",
        "烏龜祝福:無效訊息",
    ]

    # 遍歷寶物和訊息,展示正規表示式提取
    treasures = [turtle, horse, flower]
    for treasure in treasures:
        print(f"\n測試 {treasure.name}:")
        for msg in messages:
            print(treasure.extract_value(msg))

執行結果:
測試 烏龜:
烏龜 提取到:100
烏龜 無法解析訊息:白馬祝福:奔馳500公里
烏龜 無法解析訊息:姻緣花祝福:愛情99朵
烏龜 無法解析訊息:烏龜祝福:無效訊息

測試 白馬:
白馬 無法解析訊息:烏龜祝福:長壽100年
白馬 提取到:500
白馬 無法解析訊息:姻緣花祝福:愛情99朵
白馬 無法解析訊息:烏龜祝福:無效訊息

測試 姻緣花:
姻緣花 無法解析訊息:烏龜祝福:長壽100年
姻緣花 無法解析訊息:白馬祝福:奔馳500公里
姻緣花 提取到:99
姻緣花 無法解析訊息:烏龜祝福:無效訊息

程式碼解析

  1. 正規表示式(Regex)應用
    • 每個子類定義專屬的正規表示式模式,儲存在 _pattern 中:
      • 烏龜:r"烏龜祝福:長壽(\d+)年" 提取年數(例如 "100")。
      • 白馬:r"白馬祝福:奔馳(\d+)公里" 提取公里數(例如 "500")。
      • 姻緣花:r"姻緣花祝福:愛情(\d+)朵" 提取朵數(例如 "99")。
    • 使用 re.match 檢查訊息是否符合模式,並提取括號 (\d+) 中的數字。
  2. 封裝(Encapsulation)
    • _pattern 是保護屬性,儲存每個寶物的正規表示式模式,外部無法直接修改。
    • extract_value 方法封裝了正規表示式的處理邏輯,提供統一的介面。
  3. 繼承(Inheritance)
    • Treasure 是基礎類別,定義了共用的 name 和 extract_value 方法。
    • Turtle、WhiteHorse 和 MarriageFlower 繼承 Treasure,並在 __init__ 中設定各自的正規表示式模式。
  4. 正規表示式的簡單說明
    • \d+:匹配一個或多個數字。
    • ():捕獲括號內的內容,供 match.group(1) 提取。
    • re.match:從字串開頭匹配,確保訊息格式正確。

技術亮點

  • 正規表示式與 OOP 的結合:每個寶物類負責自己的正規表示式模式,符合單一職責原則。
  • 封裝:正規表示式模式和提取邏輯被封裝在類內,外部只需呼叫 extract_value。
  • 可擴展性:可以輕鬆新增其他寶物類,只需定義新的正規表示式模式。

2025年10月6日 星期一

[水井USR創新教材]Python一下用水井三寶來設計例外的範例

 


範例一:烏龜(Turtle) - 風水能量過載例外

文化背景:烏龜代表穩定的風水能量,但能量過高可能「破壞平衡」,就像風水過旺不利環境穩定。

情境:烏龜的能量(energy)有限制,超過 1000 會引發自訂例外,模擬風水能量過載。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class TurtleEnergyOverloadError(Exception):
    """自訂例外:烏龜能量過載"""
    pass

class Turtle:
    def __init__(self, energy=100):
        self.__energy = energy

    def recharge(self, amount):
        try:
            if amount < 0:
                raise ValueError("能量增量不能為負!")
            new_energy = self.__energy + amount
            if new_energy > 1000:
                raise TurtleEnergyOverloadError("烏龜能量過載,風水失衡!")
            self.__energy = new_energy
            return f"烏龜能量充滿:{self.__energy}"
        except TurtleEnergyOverloadError as e:
            return f"錯誤:{e}"
        except ValueError as e:
            return f"錯誤:{e}"

    def get_energy(self):
        return self.__energy

turtle = Turtle(energy=900)
print(turtle.recharge(50))   # 成功:烏龜能量充滿:950
print(turtle.recharge(100))  # 錯誤:烏龜能量過載,風水失衡!
print(turtle.recharge(-10))  # 錯誤:能量增量不能為負!

執行結果:
烏龜能量充滿:950
錯誤:烏龜能量過載,風水失衡!
錯誤:能量增量不能為負!

例外特性

  • 自訂例外:TurtleEnergyOverloadError 是自訂的例外類,模擬風水能量過載。
  • 多重例外處理:捕捉 ValueError(負值輸入)和自訂的 TurtleEnergyOverloadError,展示如何處理不同類型的錯誤。
  • 文化連結:烏龜的能量限制反映風水需要平衡的理念,過高能量會引發「失衡」。

範例二:白馬(WhiteHorse) - 好運耗盡例外
文化背景:白馬是李府千歲的座騎,象徵好運,但好運可能會因過度使用而「耗盡」。 情境:白馬有「好運點數」(luck_points),每次祈福(bless)消耗 10 點,若點數低於 0,則拋出例外。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class LuckExhaustedError(Exception):
    """自訂例外:白馬好運耗盡"""
    pass

class Treasure:
    def bless(self):
        return "寶物帶來吉祥!"

class WhiteHorse(Treasure):
    def __init__(self, luck_points=100):
        self.luck_points = luck_points

    def bless(self):
        try:
            if self.luck_points <= 0:
                raise LuckExhaustedError("白馬好運已耗盡,請稍後再試!")
            self.luck_points -= 10
            return super().bless() + f" 白馬帶來好運!剩餘好運點數:{self.luck_points}"
        except LuckExhaustedError as e:
            return f"錯誤:{e}"

    def ride(self):
        return "白馬奔馳,風水順暢!"

horse = WhiteHorse(luck_points=20)
print(horse.bless())  # 成功:寶物帶來吉祥! 白馬帶來好運!剩餘好運點數:10
print(horse.bless())  # 成功:寶物帶來吉祥! 白馬帶來好運!剩餘好運點數:0
print(horse.bless())  # 錯誤:白馬好運已耗盡,請稍後再試!

執行結果:
寶物帶來吉祥! 白馬帶來好運!剩餘好運點數:10
寶物帶來吉祥! 白馬帶來好運!剩餘好運點數:0
錯誤:白馬好運已耗盡,請稍後再試!

例外特性:

自訂例外:LuckExhaustedError 表示白馬好運耗盡,模擬資源有限的情境。
繼承與例外:白馬繼承自 Treasure,並在 bless 方法中加入例外處理,展示 OOP 與例外的結合。
文化連結:好運點數耗盡反映白馬塑像消失的傳說,提醒好運需珍惜。

範例三:姻緣花(MarriageFlower) - 無效祈求者例外
文化背景:姻緣花(百年雞蛋花樹)象徵好姻緣,村裡女性常祈求好姻緣,但若祈求者不符合條件(例如名字無效),祈求失敗。
情境:姻緣花的 pray 方法要求祈求者名字為非空字串,否則拋出例外。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
class InvalidPrayError(Exception):
    """自訂例外:無效的祈求者"""
    pass

class MarriageFlower:
    def bloom(self):
        return "姻緣花開,庄內好姻緣!"

    def pray(self, person):
        try:
            if not person or not isinstance(person, str):
                raise InvalidPrayError("祈求者名字無效,需為非空字串!")
            return f"{person} 向姻緣花祈求,好姻緣即將到來!"
        except InvalidPrayError as e:
            return f"錯誤:{e}"

flower = MarriageFlower()
print(flower.pray("小明"))  # 成功:小明 向姻緣花祈求,好姻緣即將到來!
print(flower.pray(""))      # 錯誤:祈求者名字無效,需為非空字串!
print(flower.pray(123))     # 錯誤:祈求者名字無效,需為非空字串!

執行結果:
小明 向姻緣花祈求,好姻緣即將到來!
錯誤:祈求者名字無效,需為非空字串!
錯誤:祈求者名字無效,需為非空字串!

例外特性

  • 自訂例外:InvalidPrayError 用於檢查無效輸入,模擬姻緣祈求的條件限制。
  • 輸入驗證:檢查 person 是否為非空字串,展示如何在例外處理中進行輸入驗證。
  • 文化連結:姻緣花祈求需「真誠」(有效名字),反映文化中對姻緣的尊重。

2025年10月5日 星期日

[水井USR創新教材]Python一下用水井三寶來說明模組的用法

 


範例一:水井三寶猜猜看

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import random

def water_well_guess():
    # 水井三寶
    treasures = ["烏龜", "白馬", "姻緣花"]
    # 使用亂數選擇一個寶物
    selected_treasure = random.choice(treasures)
    return selected_treasure

# 測試函數
for _ in range(5):  # 模擬抽取 5 次
    result = water_well_guess()
    print(f"你從水井三寶中抽到:{result}")

執行結果:
你從水井三寶中抽到:白馬
你從水井三寶中抽到:姻緣花
你從水井三寶中抽到:白馬
你從水井三寶中抽到:白馬
你從水井三寶中抽到:白馬

範例二:水井三寶模 匯入整個模組
模組:guess.py
1
2
3
4
5
6
7
8
import random

def water_well_guess():
    # 水井三寶
    treasures = ["烏龜", "白馬", "姻緣花"]
    # 使用亂數選擇一個寶物
    selected_treasure = random.choice(treasures)
    return selected_treasure

測試:test.py
1
2
3
4
5
6
import guess 

# 測試函數
for _ in range(5):  # 模擬抽取 5 次
    result = guess.water_well_guess()
    print(f"你從水井三寶中抽到:{result}")

執行結果:
你從水井三寶中抽到:烏龜
你從水井三寶中抽到:姻緣花
你從水井三寶中抽到:烏龜
你從水井三寶中抽到:姻緣花
你從水井三寶中抽到:姻緣花

範例三:水井三寶模組 匯入想要的函式
模組程式請參考範例二
測試:test.py
1
2
3
4
5
6
from guess import water_well_guess 

# 測試函數
for _ in range(5):  # 模擬抽取 5 次
    result = water_well_guess()
    print(f"你從水井三寶中抽到:{result}")

執行結果:
你從水井三寶中抽到:姻緣花
你從水井三寶中抽到:烏龜
你從水井三寶中抽到:烏龜
你從水井三寶中抽到:烏龜
你從水井三寶中抽到:姻緣花

2025年10月3日 星期五

[水井USR創新教材]Python一下用水井三寶來說明類別的重要概念



本篇文章用「水井三寶」(烏龜、白馬、姻緣花)為主題,展示了 Python 類的七大核心技術:

  • 封裝:保護烏龜的能量值。
  • 繼承:白馬繼承寶物基類的吉祥能力。
  • 多型:烏龜和姻緣花用不同方式「說話」。
  • 類與實例屬性:共享「水井吉祥」,每個寶物有獨特名稱。
  • 特殊方法:姻緣花自訂顯示和加法。
  • 類方法與靜態方法:白馬的召喚和速度計算。
  • 屬性管理:控制烏龜年齡的存取。
以下程式是用Grok產生。

範例一:封裝(Encapsulation)

封裝保護物件內部資料,限制外部直接存取。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
class Turtle:
    def __init__(self, name):
        self.__energy = 100  # 私有屬性:能量值
        self.name = name

    def get_energy(self):  # 公開方法存取
        return self.__energy

    def use_energy(self, amount):
        if amount > 0:
            self.__energy -= amount
            return f"{self.name} 使用 {amount} 能量,剩餘 {self.__energy}"
        return "無效的能量消耗!"

# 測試
t = Turtle("烏龜")
print(t.get_energy())  # 輸出: 100
print(t.use_energy(20))  # 輸出: 烏龜 使用 20 能量,剩餘 80
# print(t.__energy)  # 錯誤!無法直接存取私有屬性

執行結果:

100 烏龜 使用 20 能量,剩餘 80

解釋:__energy 是私有屬性,外部無法直接存取,只能透過 get_energy 和 use_energy 方法控制,展現封裝保護資料的能力。

範例二:繼承(Inheritance)

繼承讓子類重用父類的屬性和方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
class Treasure:
    def __init__(self, name):
        self.name = name

    def bless(self):
        return f"{self.name} 帶來吉祥!"

class WhiteHorse(Treasure):  # 繼承 Treasure
    def gallop(self):  # 子類專屬方法
        return f"{self.name} 飛馳千里!"

# 測試
horse = WhiteHorse("白馬")
print(horse.bless())  # 輸出: 白馬 帶來吉祥!(來自父類)
print(horse.gallop())  # 輸出: 白馬 飛馳千里!(子類專有)

執行結果:
白馬 帶來吉祥!
白馬 飛馳千里!

解釋:WhiteHorse 繼承 Treasure,可直接使用父類的 bless 方法,並新增自己的 gallop 方法,展示程式碼重用。

範例三:多型(Polymorphism)
多型允許不同類的物件以統一方式處理不同行為。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
class Treasure:
    def speak(self):
        pass  # 抽象方法,子類需實現

class Turtle(Treasure):
    def speak(self):
        return "烏龜:穩重長壽!"

class MarriageFlower(Treasure):
    def speak(self):
        return "姻緣花:愛情綻放!"

# 測試
treasures = [Turtle(), MarriageFlower()]
for t in treasures:
    print(t.speak())  # 輸出: 烏龜:穩重長壽! 和 姻緣花:愛情綻放!

執行結果:
烏龜:穩重長壽!
姻緣花:愛情綻放!
解釋:Turtle 和 MarriageFlower 都實現了 speak 方法,但行為不同。透過統一的 speak() 呼叫展現多型。

範例四:類與實例屬性(Class and Instance Attributes)

類屬性共享於所有實例,實例屬性獨立於每個物件。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
class Treasure:
    shared_blessing = "水井吉祥"  # 類屬性

    def __init__(self, name):
        self.name = name  # 實例屬性

    def describe(self):
        return f"{self.name} 擁有 {Treasure.shared_blessing}"

# 測試
t1 = Treasure("烏龜")
t2 = Treasure("白馬")
print(t1.describe())  # 輸出: 烏龜 擁有 水井吉祥
print(t2.describe())  # 輸出: 白馬 擁有 水井吉祥
Treasure.shared_blessing = "三寶輝煌"  # 修改類屬性
print(t1.describe())  # 輸出: 烏龜 擁有 三寶輝煌

執行結果:

烏龜 擁有 水井吉祥 白馬 擁有 水井吉祥 烏龜 擁有 三寶輝煌

解釋:shared_blessing 是類屬性,所有實例共享,修改它會影響所有物件;name 是實例屬性,各物件獨立。

範例五:特殊方法(Magic/Dunder Methods)

特殊方法自訂物件行為,如字串表示或運算。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
class MarriageFlower:
    def __init__(self, beauty):
        self.beauty = beauty

    def __str__(self):  # 自訂字串表示
        return f"姻緣花 美麗值: {self.beauty}"

    def __add__(self, other):  # 自訂加法
        total_beauty = self.beauty + other.beauty
        return MarriageFlower(total_beauty)

# 測試
f1 = MarriageFlower(10)
f2 = MarriageFlower(20)
print(f1)  # 輸出: 姻緣花 美麗值: 10
combined = f1 + f2
print(combined)  # 輸出: 姻緣花 美麗值: 30

執行結果:

姻緣花 美麗值: 10 姻緣花 美麗值: 30

解釋:__str__ 自訂 print 輸出;__add__ 讓 + 運算符合併兩朵姻緣花的美麗值,展示特殊方法的靈活性。

範例六:類方法與靜態方法(Class Methods and Static Methods)

類方法操作類本身,靜態方法獨立於類和實例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
class WhiteHorse:
    @classmethod
    def summon(cls, name):  # 類方法
        return cls()

    @staticmethod
    def calculate_speed(distance, time):  # 靜態方法
        return f"白馬速度:{distance / time} 公里/小時"

    def __init__(self):
        self.name = "白馬"

# 測試
horse = WhiteHorse.summon("白馬")  # 類方法創建實例
print(WhiteHorse.calculate_speed(100, 2))  # 輸出: 白馬速度:50.0 公里/小時

執行結果:
白馬速度:50.0 公里/小時

解釋:@classmethod 的 summon 使用 cls 創建實例;@staticmethod 的 calculate_speed 獨立計算,無需實例。

範例七:屬性管理(Property Decorators)

屬性裝飾器將方法偽裝成屬性,控制存取。


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
class Turtle:
    def __init__(self, age):
        self._age = age  # 保護屬性

    @property
    def age(self):  # getter
        return self._age

    @age.setter
    def age(self, value):  # setter
        if value < 0:
            raise ValueError("烏龜年齡不能為負!")
        self._age = value

# 測試
t = Turtle(50)
print(t.age)  # 輸出: 50
t.age = 100  # 使用 setter 修改
print(t.age)  # 輸出: 100
# t.age = -10  # 會拋出錯誤

執行結果:

50 100

解釋:@property 讓 _age 像屬性一樣存取;@age.setter 控制賦值,確保年齡不為負數。

2025年9月30日 星期二

[水井USR創新教材]Python一下用魚菜共生模擬小例子來說明函式的進階概念

 


以下是由ChatGPT協助生成:

在 Python 裡,函式本身也是一種物件,可以:

  • 指派給變數

  • 放進資料結構(如 list)

  • 當作參數傳遞

範例一:函式視為物件(Function as Object)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
def carbon_calc(area):
    """計算單位面積月減碳量(假設固定係數)"""
    return round(area * 0.12, 2)

def water_calc(area):
    """計算單位面積月節水量"""
    return round(area * 0.08, 2)

# 函式指派給變數
c_func = carbon_calc
print("函式當變數使用:", c_func(10))

# 函式放入清單
calculators = [carbon_calc, water_calc]
for func in calculators:
    print(f"{func.__name__}{func(5)}")

# 函式當作參數傳遞
def apply_to_area(func, area):
    return func(area)

print("傳遞函式當參數:", apply_to_area(water_calc, 8))

執行結果:
函式當變數使用: 1.2
carbon_calc:0.6
water_calc:0.4
傳遞函式當參數: 0.64

📌 重點:

  • 函式本身可以像資料一樣被傳遞與儲存。

  • 為後面 closure 與 decorator 打基礎。


匿名函式適合用於小型、一次性邏輯,特別是排序、映射或高階函式中。
範例二:Lambda 函式(匿名函式)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# lambda 版本的碳排計算
carbon_lambda = lambda area: round(area * 0.15, 2)
print("lambda 計算碳排:", carbon_lambda(10))

# lambda 用於 list 遍歷
areas = [3.3, 5.5, 10]
results = list(map(lambda a: round(a * 0.1, 2), areas))
print("lambda map 結果:", results)

# lambda 與 sorted 搭配
ponds = [("A池", 5), ("B池", 10), ("C池", 3)]
sorted_ponds = sorted(ponds, key=lambda x: x[1], reverse=True)
print("依面積排序魚池:", sorted_ponds)

執行結果:
lambda 計算碳排: 1.5
lambda map 結果: [0.33, 0.55, 1.0]
依面積排序魚池: [('B池', 10), ('A池', 5), ('C池', 3)]

📌 重點:

  • lambda = 匿名函式,可快速撰寫簡單邏輯。

  • 適合與 map / filter / sorted 等搭配。

產生器是用 yield 逐步產生資料,適合處理每月模擬資料流👇
範例三:產生器(Generator)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import random

def aquaponics_generator(months, area=3.3058):
    """每次呼叫 yield 一個月份的模擬資料"""
    for month in range(1, months + 1):
        seasonal_factor = 1.2 if 6 <= (month % 12 or 12) <= 8 else 1.0
        carbon = area * 0.12 * seasonal_factor + random.uniform(-0.5, 0.5)
        water = area * 0.08 * seasonal_factor + random.uniform(-0.05, 0.05)
        yield month, round(carbon, 2), round(water, 2)

# 使用 generator
sim = aquaponics_generator(6)
for m, c, w in sim:
    print(f"第 {m} 月:減碳 {c} kg,節水 {w} m³")

執行結果:
第 1 月:減碳 0.73 kg,節水 0.24 m³
第 2 月:減碳 -0.07 kg,節水 0.3 m³
第 3 月:減碳 0.78 kg,節水 0.25 m³
第 4 月:減碳 -0.03 kg,節水 0.3 m³
第 5 月:減碳 0.88 kg,節水 0.24 m³
第 6 月:減碳 0.78 kg,節水 0.36 m³

📌 重點:

  • yield 會回傳一筆資料,但保留函式狀態。

  • 適合大量資料的逐筆處理。


內部函式就是在函式中再定義函式,可以封裝邏輯,避免汙染全域命名空間👇
範例四:內部函式(Inner Function)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def simulate_one_year(area):
    """外部函式:包一年模擬"""

    def simulate_month(m):
        """內部函式:只在一年模擬裡用"""
        factor = 1.2 if 6 <= (m % 12 or 12) <= 8 else 1.0
        return round(area * 0.1 * factor, 2)

    results = []
    for month in range(1, 13):
        results.append(simulate_month(month))
    return results

print("一年模擬結果:", simulate_one_year(5))

執行結果:
一年模擬結果: [0.5, 0.5, 0.5, 0.5, 0.5, 0.6, 0.6, 0.6, 0.5, 0.5, 0.5, 0.5]

📌 重點:

  • simulate_month 只存在 simulate_one_year 裡。

  • 有助於模組化程式與邏輯分層。

閉包的意思是要讓內部函式「記住」外部函式的變數,即使外部函式已經結束👇
範例五:Closure 函式(閉包)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def make_carbon_calculator(base_factor):
    """回傳一個記住 base_factor 的函式"""
    def calculator(area):
        return round(area * base_factor, 2)
    return calculator

# 建立兩種不同設定的計算器
summer_calc = make_carbon_calculator(0.15)  # 夏季
winter_calc = make_carbon_calculator(0.10)  # 冬季

print("夏季碳排:", summer_calc(10))
print("冬季碳排:", winter_calc(10))

執行結果:
夏季碳排: 1.5
冬季碳排: 1.0

📌 重點:

  • 閉包讓函式能夠「攜帶環境」。

  • 很適合製作客製化計算器或累積器。


裝飾器可用於增強函式,例如:

  • 日誌紀錄

  • 輸入檢查

  • 統計運行時間

範例六:Decorator(裝飾器)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
import functools

def log_simulation(func):
    """裝飾器:在模擬前後加上日誌"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("👉 開始模擬")
        result = func(*args, **kwargs)
        print("✅ 模擬完成")
        return result
    return wrapper

@log_simulation
def run_simulation(months):
    for m in range(1, months + 1):
        print(f"模擬第 {m} 月...")
    return "模擬結束"

print(run_simulation(3))

執行結果:
👉 開始模擬
模擬第 1 月...
模擬第 2 月...
模擬第 3 月...
✅ 模擬完成
模擬結束

📌 重點:

  • Decorator 是高階函式,輸入函式,回傳包裝過的函式。

  • @decorator_name 是語法糖,等同於 func = decorator(func)