1 __main__

1.1 name 變量

__name__ 是 Python 的一個內置變量，用于表示當前模塊的名稱。其值會根據模塊的使用方式而變化：

1.1.1 當模塊作為主程序直接運行時

此時 __name__ 的值被自動設置為 "__main__"。

示例：創建一個 module.py 文件，內容如下：

print(f"模塊的 __name__ 值: {__name__}")

直接運行該文件（python module.py），輸出結果為：

模塊的 __name__ 值: __main__

1.1.2 當模塊被其他模塊導入時

此時 __name__ 的值被設置為該模塊的文件名（不包含 .py 擴展名）。

示例：創建另一個文件 import_module.py，內容如下：

import module  # 導入上面創建的 module.py

運行 import_module.py，輸出結果為：

模塊的 __name__ 值: module

1.2 __main__ 的含義

__main__ 是一個特殊的字符串常量，用于表示當前模塊是作為主程序運行的。

它通常不單獨使用，而是與 __name__ 結合，用于判斷模塊的運行狀態：

• 當 __name__ == "__main__" 時，表明模塊是直接運行的
• 當 __name__ != "__main__" 時，表明模塊是被導入的

1.3 if __name__ == __main__

這是 Python 中一種非常常見的代碼模式，用于控制代碼在不同場景下的執行行為。

• 當模塊作為獨立腳本運行時，執行 if 塊內的代碼
• 當模塊被其他模塊導入時，不執行 if 塊內的代碼

步驟 1：創建 example.py 文件：

def greet():print("來自 example 模塊的問候！")# 根據模塊運行方式執行不同代碼
if __name__ == "__main__":print("該腳本正在直接運行。")greet()  # 直接運行時調用函數
else:print("該腳本作為模塊被導入。")

步驟 2：直接運行 example.py：

python example.py

輸出結果：

該腳本正在直接運行。
來自 example 模塊的問候！

步驟 3：創建 another_script.py 并導入 example：

import example  # 導入模塊example.greet()  # 調用模塊中的函數

運行 another_script.py：

python another_script.py

輸出結果：

該腳本作為模塊被導入。
來自 example 模塊的問候！

1.5 小結

1. __name__ 是內置變量，表示當前模塊的名稱
   • 直接運行模塊時，__name__ = "__main__"
   • 模塊被導入時，__name__ = 模塊文件名（不含 .py）
2. if __name__ == "__main__": 是 Python 的常用模式
   • 用于區分模塊的兩種使用方式：直接運行 vs 被導入
   • 使模塊既可以作為獨立程序運行，又可以作為庫被其他模塊導入

2 lambda表達式

2.1 基本概念

lambda 函數是 Python 中一種特殊的函數形式，也被稱為匿名函數，即沒有正式名稱的函數。它旨在快速創建簡單的、單行的函數，尤其適合需要臨時使用的短小功能。

與常規函數（使用 def 定義）相比，lambda 函數的特點：

• 匿名性：沒有函數名稱，只能通過賦值或作為參數傳遞使用
• 簡潔性：通常只包含一行代碼和一個表達式
• 臨時性：適用于短期使用的簡單功能

2.2 lambda 函數語法

lambda arguments: expression

• lambda：Python 關鍵字，用于定義 lambda 函數
• arguments：參數列表，可以包含 0 個或多個參數（用逗號分隔）
• expression：一個表達式，用于計算并返回結果（lambda 函數的返回值）

注意：lambda 函數只能包含一個表達式，不能包含復雜的代碼塊（如循環、條件語句的多行形式等）

2.3 使用示例

無參數的 lambda 函數

# 定義無參數的 lambda 函數
f = lambda: "Hello, world!"# 調用函數
print(f())  # 輸出: Hello, world!

單個參數的 lambda 函數

# 定義接收一個參數的 lambda 函數（計算參數加 10）
x = lambda a: a + 10# 調用函數
print(x(5))  # 輸出: 15
print(x(10))  # 輸出: 20

多個參數的 lambda 函數

# 兩個參數：計算 a 乘以 b
multiply = lambda a, b: a * b
print(multiply(5, 6))  # 輸出: 30# 三個參數：計算 a + b + c
add_three = lambda a, b, c: a + b + c
print(add_three(5, 6, 2))  # 輸出: 13

帶默認參數的 lambda 函數

# 帶默認值的參數
greet = lambda name, greeting="Hello": f"{greeting}, {name}!"
print(greet("Alice"))  # 輸出: Hello, Alice!
print(greet("Bob", "Hi"))  # 輸出: Hi, Bob!

2.4 與高階函數結合使用

lambda 函數最常見的用途是作為參數傳遞給高階函數（接收函數作為參數的函數），如 map()、filter()、reduce() 等。

2.4.1 與 map () 結合

map(func, iterable) 會將函數應用于可迭代對象的每個元素，返回一個迭代器。

# 計算列表中每個元素的平方
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # 輸出: [1, 4, 9, 16, 25]# 處理多個可迭代對象
a = [1, 2, 3]
b = [4, 5, 6]
sum_list = list(map(lambda x, y: x + y, a, b))
print(sum_list)  # 輸出: [5, 7, 9]

2.4.2 與 filter () 結合

filter(func, iterable) 用于篩選可迭代對象中滿足函數條件的元素，返回一個迭代器。

# 篩選列表中的偶數
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 輸出: [2, 4, 6, 8]# 篩選長度大于 3 的字符串
words = ["apple", "cat", "banana", "dog", "grape"]
long_words = list(filter(lambda s: len(s) > 3, words))
print(long_words)  # 輸出: ['apple', 'banana', 'grape']

2.4.3 與 reduce () 結合

reduce(func, iterable) 用于對可迭代對象中的元素進行累積計算（需從 functools 導入）。

from functools import reduce# 計算列表元素的累積乘積
numbers = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, numbers)
print(product)  # 輸出: 120（1*2*3*4*5的結果）# 計算列表元素的累積和
sum_total = reduce(lambda x, y: x + y, numbers)
print(sum_total)  # 輸出: 15（1+2+3+4+5的結果）

2.5 lambda 函數 vs 常規函數（def）

特性	lambda 函數	常規函數（def）
名稱	匿名，無名稱	有函數名
定義	使用 lambda 關鍵字	使用 def 關鍵字
表達式	只能有一個表達式	可以包含多個語句和代碼塊
返回值	自動返回表達式結果	需要顯式使用 return 語句
文檔字符串	不支持	支持（可通過 doc 訪問）
適用場景	簡單的單行功能，臨時使用	復雜功能，需要復用的函數

示例對比：

# 使用 lambda 定義
add_lambda = lambda a, b: a + b# 使用 def 定義
def add_def(a, b):return a + b# 功能相同
print(add_lambda(2, 3))  # 輸出: 5
print(add_def(2, 3))     # 輸出: 5