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)。

張貼者： 於 沒有留言:
標籤： ,

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

 


以下是由ChatGPT協助生成：

範例一：全域變數與區域變數

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
# 全域變數
global_factor = 10

def multiply_by_global(x):
    # 函式內可以讀取全域變數
    result = x * global_factor
    print(f"在函式中，x={x}，global_factor={global_factor}，result={result}")

def use_local_variable():
    # 區域變數：只在這個函式裡有效
    local_factor = 5
    print(f"local_factor 只在這個函式內有效：{local_factor}")

multiply_by_global(3)
use_local_variable()

# print(local_factor)  # ❌ 會出錯，因為 local_factor 是區域變數

執行結果：
在函式中，x=3，global_factor=10，result=30
local_factor 只在這個函式內有效：5

📌 重點：

  • global_factor 是全域變數，整個程式都能用。

  • local_factor 是區域變數，函式外無法存取。


範例二：函式的定義、呼叫與回傳值
1
2
3
4
5
6
7
def square(x):
    """回傳 x 的平方"""
    return x * x

# 呼叫函式
result = square(5)
print(f"5 的平方是 {result}")

執行結果：
5 的平方是 25

📌 重點：

  • def 是定義函式的關鍵字。

  • 使用 return 回傳結果；呼叫函式時可接收該值


範例三：函式中「有預設值」的參數，一定要放在後面

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
# ❌ 錯誤寫法：有預設值的參數在前
# def greeting(message="Hello", name):
#     print(f"{message}, {name}")

# ✅ 正確寫法：無預設值的在前，有預設值的在後
def greeting(name, message="Hello"):
    print(f"{message}, {name}")

greeting("水井村")              # 使用預設值
greeting("歡迎光臨", "水井村")      # 覆寫預設值

執行結果：
Hello, 水井村
水井村, 歡迎光臨

📌 重點：

Python 函式定義時，預設值參數必須放在沒有預設值參數之後。

範例四：多個回傳值

1
2
3
4
5
6
7
def get_min_max(numbers):
    """回傳最小值與最大值（tuple）"""
    return min(numbers), max(numbers)

nums = [5, 2, 9, 1, 7]
minimum, maximum = get_min_max(nums)
print(f"最小值: {minimum}, 最大值: {maximum}")

執行結果：
最小值: 1, 最大值: 9

📌 重點：

  • 函式可以回傳多個值（實際是回傳 tuple）。

  • 可以同時接收多個變數來解包。


範例五：位置引數與關鍵字引數

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
def describe_pond(location, area, fish_type="吳郭魚"):
    print(f"地點：{location}，面積：{area} m²，魚種：{fish_type}")

# 位置引數（依順序）
describe_pond("水井村", 100)
def describe_pond(location, area, fish_type="吳郭魚"):
    print(f"地點：{location}，面積：{area} m²，魚種：{fish_type}")

# 位置引數（依順序）
describe_pond("水井村", 100)

# 關鍵字引數（不用依順序）
describe_pond(area=200, location="口湖鄉", fish_type="文蛤")

# 混用：位置引數要放前面
describe_pond("口湖鄉水井村", area=50)

執行結果：
地點：水井村，面積：100 m²，魚種：吳郭魚
地點：口湖鄉，面積：200 m²，魚種：文蛤
地點：口湖鄉水井村，面積：50 m²，魚種：吳郭魚

📌 重點：

  • 位置引數：按照順序傳入。

  • 關鍵字引數：用「參數名=值」指定。

  • 混用時，位置引數必須在關鍵字引數之前。

範例六：與「魚菜共生模擬」結合的小例子

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

# 全域變數
global_area = 3.3058

def single_month_simulation(month, area=global_area, base_emission=1.5):
    """模擬單月減碳量，示範回傳值與預設值參數"""
    seasonal_factor = 1.2 if 6 <= (month % 12 or 12) <= 8 else 1.0
    monthly_emission = base_emission / 12
    carbon = monthly_emission * area * seasonal_factor + random.uniform(-1, 1)
    return round(carbon, 2)  # 回傳單月減碳量

# 位置引數
print(single_month_simulation(1))

# 關鍵字引數
print(single_month_simulation(month=7, area=5))

# 使用全域變數（不傳 area）
print(single_month_simulation(3))

執行結果：
0.89
1.2
0.0

📌 重點：

  • 使用了預設值參數 + 關鍵字引數。

  • 示範全域變數作為預設參數。

  • 回傳單一計算值並列印。


張貼者： 於 沒有留言:
標籤： ,

[水井USR創新教材]Python一下智慧減碳節水三生一體-類別

 2025年9月28尚虎雲在雲林官邸兒童館發表尚虎雲產銷平台。



以下程式是由ChatGPT產生。

範例一：魚菜共生模擬器

 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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
import math
import random
import logging
import functools

# 設定日誌
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')

class AquaponicsSimulator:
    """
    魚菜共生系統模擬器：模擬每月減碳與節水量。
    """

    def __init__(self, months, area=3.3058, base_emission=1.5, base_water=0.5):
        """
        初始化模擬器。
        參數：
            months: 模擬月數
            area: 魚池面積（平方米）
            base_emission: 每平方米年排放量（kg CO₂e）
            base_water: 每平方米月用水量（m³）
        """
        self.months = months
        self.area = area
        self.base_emission = base_emission
        self.base_water = base_water
        self.tech_carbon_reduction = 0.95  # 魚菜共生減碳效果（減少 5%）
        self.tech_water_saving = 0.9       # 魚菜共生節水效果（減少 10%）
        self.results = []                  # 儲存每月模擬結果

    def _simulate_month(self, current_month):
        """
        模擬單一月份的減碳與節水量。
        """
        # 季節性波動：夏季（6-8 月）增加 20%
        seasonal_factor = 1.2 if 6 <= (current_month % 12 or 12) <= 8 else 1.0
        monthly_emission = self.base_emission / 12

        carbon = (monthly_emission * self.area * seasonal_factor * self.tech_carbon_reduction +
                  random.uniform(-5, 5))
        water = (self.base_water * self.area * seasonal_factor * self.tech_water_saving +
                 random.uniform(-0.05, 0.05))

        # 驗證非負
        carbon = max(0, round(carbon, 2))
        water = max(0, round(water, 2))

        # 記錄日誌
        logging.info(f"Month {current_month}: Carbon = {carbon} kg CO₂e, Water = {water} m³")

        return carbon, water

    def _recursive_simulation(self, current_month=1):
        """
        遞迴模擬每月資料。
        """
        if current_month > self.months:
            return

        # 計算當月數據
        carbon, water = self._simulate_month(current_month)
        self.results.append((carbon, water))

        # 遞迴下一月
        self._recursive_simulation(current_month + 1)

    def run(self):
        """
        執行模擬並返回所有月份的結果。
        """
        self.results.clear()  # 清空舊資料
        self._recursive_simulation(1)
        return self.results

# === 測試使用 ===
if __name__ == "__main__":
    simulator = AquaponicsSimulator(months=12)
    monthly_data = simulator.run()

    print("水井村魚菜共生每月減碳與節水數據：")
    for i, (carbon, water) in enumerate(monthly_data, 1):
        print(f"第 {i} 月 - 減碳量: {carbon} kg CO₂e, 節水量: {water} m³")


範例二：水井三寶

 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
# 定義一個基礎寶物類別
class Treasure:
    def __init__(self, name, meaning, age):
        self.name = name
        self.meaning = meaning
        self.age = age

    def describe(self):
        return f"{self.name}：象徵 {self.meaning}，已有 {self.age} 年歷史。"

    def __str__(self):
        return self.describe()

# 三寶：烏龜、白馬、番花

class Turtle(Treasure):
    def __init__(self):
        super().__init__("烏龜", "風水與守護", 300)

class WhiteHorse(Treasure):
    def __init__(self):
        super().__init__("白馬", "信仰與傳說", 150)

class Frangipani(Treasure):  # 雞蛋花的英文名稱
    def __init__(self):
        super().__init__("番花", "歷史與生命", 300)

# 建立物件
turtle = Turtle()
horse = WhiteHorse()
flower = Frangipani()

# 顯示介紹（透過 print(object) 直接呼叫 __str__）
print(turtle)
print(horse)
print(flower)

執行結果：
烏龜：象徵 風水與守護，已有 300 年歷史。
白馬：象徵 信仰與傳說，已有 150 年歷史。
番花：象徵 歷史與生命，已有 300 年歷史。

註：這些歷史時間只是ChatGPT對程式的預設值，需要再考證。
張貼者： 於 沒有留言:
標籤： , ,
訂閱： 文章 (Atom)