Python函式進階應用與設計模式

– 12 分鐘閱讀

Python 函式是程式碼組織和複用的根本。理解不同型別的函式，例如純函式和副作用函式，有助於編寫更易維護和測試的程式碼。靜態方法和類別方法則提供了更靈活的類別設計方式。裝飾器模式可以不修改原始碼的情況下增強函式功能，而閉包則可以儲存函式的狀態。這些進階技巧結合效能最佳化和安全考量，能有效提升 Python 程式碼的品質和效率。

Python函式進階應用：純函式、副作用函式與靜態方法

在Python程式設計中，函式是程式的基本組成單元。瞭解如何撰寫不同型別的函式對於寫出可維護、可測試的程式碼至關重要。本文將深入探討純函式（Pure Functions）、具有副作用的函式（Functions with Side Effects）、修改可變引數的函式，以及靜態方法（Static Methods）和類別方法（Class Methods）的使用。

撰寫純函式

純函式是指那些不依賴於外部狀態、不修改外部狀態、且給定相同輸入總是傳回相同輸出的函式。撰寫純函式的關鍵在於避免修改全域變數、輸入引數或依賴外部狀態。

def 計算圓面積(半徑):
 """計算圓的面積"""
 import math
 return math.pi * (半徑 ** 2)

# 使用範例
print(計算圓面積(5)) # 輸出：78.53981633974483

內容解密：

此函式計算圓面積接收一個引數半徑，並傳回圓的面積。它不依賴於任何外部狀態，且給定相同的半徑總是傳回相同的結果。這使得它成為一個純函式。

撰寫具有副作用的函式

具有副作用的函式是指那些會修改外部狀態或與外部系統互動的函式。雖然純函式在函式式程式設計中受到青睞，但在某些情況下，具有副作用的函式是實作特定功能所必需的。

使用全域變數需謹慎

計數 = 0 # 全域變數

def 增加計數():
 global 計數
 計數 += 1

增加計數()
print(計數) # 輸出：1

內容解密：

此範例中，增加計數函式修改了全域變數計數。使用全域變數需謹慎，因為它可能導致程式行為難以預測。

使用方法修改物件狀態

class 銀行帳戶:
 def __init__(self, 餘額):
 self.餘額 = 餘額

 def 存款(self, 金額):
 self.餘額 += 金額

 def 提款(self, 金額):
 self.餘額 -= 金額

帳戶 = 銀行帳戶(100)
帳戶.存款(50)
print(帳戶.餘額) # 輸出：150

內容解密：

此範例展示瞭如何使用物件導向程式設計來封裝物件狀態，並透過方法來修改它。這種方式比直接操作全域變數更易於維護。

與外部系統互動

import requests

def 擷取資料(url):
 回應 = requests.get(url)
 return 回應.content

# 使用範例
資料 = 擷取資料("https://example.com")
print(資料)

內容解密：

此函式使用requests函式庫與外部系統（一個URL）互動，取得資料。這種與外部系統的互動是具有副作用的，因為它依賴於外部狀態（URL的內容）。

撰寫修改可變引數的函式

在Python中，可變引數（如列表、字典和集合）可以在函式內被修改，並且這些修改會持續存在於函式的作用域之外。

直接修改引數

def 新增元素至列表(元素, 列表):
 列表.append(元素)

我的列表 = [1, 2, 3]
新增元素至列表(4, 我的列表)
print(我的列表) # 輸出：[1, 2, 3, 4]

內容解密：

此函式直接修改了傳入的列表，增加了一個新元素。

傳回新物件

def 反轉列表(列表):
 return 列表[::-1]

我的列表 = [1, 2, 3]
反轉後的列表 = 反轉列表(我的列表)
print(我的列表) # 輸出：[1, 2, 3]
print(反轉後的列表) # 輸出：[3, 2, 1]

內容解密：

此函式傳回了一個新的列表，是原始列表的反轉。這種方式保留了原始列表不變。

使用@staticmethod和@classmethod修飾器

Python提供了@staticmethod和@classmethod兩個內建修飾器，分別用於建立靜態方法和類別方法。

靜態方法

class 數學:
 @staticmethod
 def 階乘(n):
 """計算數字的階乘"""
 if n == 0:
 return 1
 else:
 return n * 數學.階乘(n-1)

# 使用範例
結果 = 數學.階乘(5)
print(結果) # 輸出：120

內容解密：

靜態方法屬於類別本身，而不是類別的例項。它們對於建立不需要存取例項或類別變數的工具函式非常有用。

類別方法

from datetime import date

class 人物:
 def __init__(self, 姓名, 年齡):
 self.姓名 = 姓名
 self.年齡 = 年齡

 @classmethod
 def 從出生年份(cls, 姓名, 出生年份):
 """根據出生年份建立人物例項"""
 年齡 = date.today().year - 出生年份
 return cls(姓名, 年齡)

人物例項 = 人物.從出生年份('愛麗絲', 1990)
print(人物例項.年齡) # 輸出：33

內容解密：

此範例展示瞭如何使用@classmethod裝飾器定義一個類別方法。類別方法可以用於建立工廠方法，用於建立具有特定屬性的類別例項。

  flowchart TD
 A[開始] --> B{檢查引數}
 B -->|引數有效| C[執行函式]
 B -->|引數無效| D[回報錯誤]
 C --> E[傳回結果]
 D --> E

圖表翻譯：

此圖表展示了一個函式執行的基本流程。首先檢查輸入引數的有效性，如果引數有效，則執行函式並傳回結果；如果引數無效，則回報錯誤並結束流程。此圖清晰地說明瞭函式執行過程中的條件分支邏輯。

Python 裝飾器深度解析

Python 的裝飾器（Decorator）是一種強大的功能，能夠在不修改原始函式或類別程式碼的情況下，增強或修改其行為。裝飾器本質上是一個函式或類別，接受另一個函式或類別作為引數，並傳回一個修改後的版本。

函式裝飾器

函式裝飾器用於修改或增強函式的行為。以下是一個簡單的例子，展示如何使用裝飾器重複呼叫一個函式：

def 重複(num):
 def 裝飾器(func):
 def 包裝器(*args, **kwargs):
 for _ in range(num):
 func(*args, **kwargs)
 return 包裝器
 return 裝飾器

@重複(3)
def 說你好(姓名):
 print(f"你好，{姓名}!")

說你好("約翰")

內容解密：

此範例定義了一個名為 重複 的裝飾器函式，它接受一個引數 num，並傳回一個裝飾器。該裝飾器用於重複呼叫被裝飾的函式 num 次。在這個例子中，說你好 函式被裝飾器 @重複(3) 修飾，因此當呼叫 說你好("約翰") 時，會輸出 “你好，約翰！” 三次。

多重灌飾器

我們也可以使用多個裝飾器來修改一個函式。裝飾器的應用順序是從下到上。

def 粗體裝飾器(func):
 def 包裝器(*args, **kwargs):
 return f"<b>{func(*args, **kwargs)}</b>"
 return 包裝器

def 斜體裝飾器(func):
 def 包裝器(*args, **kwargs):
 return f"<i>{func(*args, **kwargs)}</i>"
 return 包裝器

@粗體裝飾器
@斜體裝飾器
def 說你好():
 return "你好！"

print(說你好())

內容解密：

此範例定義了兩個裝飾器：粗體裝飾器 和 斜體裝飾器。說你好 函式被這兩個裝飾器修飾。首先，斜體裝飾器 被應用，將輸出包裹在 <i> 標籤中；然後，粗體裝飾器 被應用，將結果再包裹在 <b> 標籤中。因此，輸出結果為 <b><i>你好！</i></b>。

帶引數的裝飾器

有時，我們希望裝飾器能夠接受引數。這需要定義一個函式，該函式接受引數並傳回一個裝飾器。

def 問候裝飾器(問候語):
 def 裝飾器(func):
 def 包裝器(*args, **kwargs):
 print(問候語)
 func(*args, **kwargs)
 return 包裝器
 return 裝飾器

@問候裝飾器("歡迎！")
def 說你好(姓名):
 print(f"你好，{姓名}!")

說你好("約翰")

內容解密：

此範例定義了一個名為 問候裝飾器 的裝飾器工廠函式，它接受一個問候語作為引數，並傳回一個裝飾器。該裝飾器在呼叫被裝飾函式之前列印出指定的問候語。在這個例子中，說你好 函式被 @問候裝飾器("歡迎！") 修飾，因此在呼叫 說你好("約翰") 時，會先輸出 “歡迎！"，然後輸出 “你好，約翰！"。

類別裝飾器

類別裝飾器與函式裝飾器類別似，但它們用於修改或增強類別的行為。

def 新增版本(cls):
 cls.版本 = "1.0"
 return cls

@新增版本
class 我的類別:
 pass

print(我的類別.版本) # 輸出：1.0

內容解密：

此範例展示瞭如何使用類別裝飾器為類別新增一個屬性。在這個例子中，新增版本 裝飾器為 我的類別 新增了一個名為 版本 的屬性，並指定為 “1.0”。

進階函式應用

使用偏函式

偏函式（partial function）是一種固定函式部分引數，建立新函式的方法。這在處理具有多個引數的函式時特別有用。

from functools import partial

def 乘法(x, y):
 """計算兩個數字的乘積"""
 return x * y

雙倍 = partial(乘法, 2)
print(雙倍(5)) # 輸出：10

內容解密：

此範例展示瞭如何使用 partial() 函式建立一個偏函式 雙倍。該偏函式固定了 乘法() 函式的 x 引數為2，使得 雙倍 函式只需一個引數即可計算輸入值的兩倍。

函式閉包

函式閉包是指一個函式可以記住其外部作用域中的變數，即使該函式在其他地方被呼叫。

def 外部函式(訊息):
 def 內部函式():
 print(訊息)
 return 內部函式

我的函式 = 外部函式("你好！")
我的函式() # 輸出：你好！

內容解密：

此範例展示瞭如何建立一個函式閉包。外部函式 傳回 內部函式，而 內部函式 可以存取 外部函式 的變數 訊息。即使 外部函式 已經執行完畢，內部函式 仍然可以記住 訊息 的值。

參考資料

附錄

常見問題

  1. 什麼是純函式？
    • 純函式是指那些不依賴於外部狀態、不修改外部狀態、且給定相同輸入總是傳回相同輸出的函式。
  2. 具有副作用的函式有什麼特點？
    • 具有副作用的函式會修改外部狀態或與外部系統互動。
  3. 靜態方法和類別方法有什麼區別？
    • 靜態方法屬於類別本身，不依賴於類別或例項的狀態。類別方法則可以用於建立工廠方法，用於建立具有特定屬性的類別例項。

進一步閱讀

  • Python 裝飾器的進階應用
  • 函式式程式設計在 Python 中的實踐
  • 物件導向程式設計在 Python 中的最佳實踐

技術術語表

  • 純函式 (Pure Function)：不依賴於外部狀態、不修改外部狀態、且給定相同輸入總是傳回相同輸出的函式。
  • 具有副作用的函式 (Function with Side Effects)：會修改外部狀態或與外部系統互動的函式。
  • 靜態方法 (Static Method)：屬於類別本身，不依賴於類別或例項狀態的方法。
  • 類別方法 (Class Method)：可以用於建立工廠方法，用於建立具有特定屬性的類別例項的方法。

進階 Python 設計模式與實作技巧

裝飾器模式的深度應用

裝飾器是 Python 中一個強大的功能，能夠在不修改原始函式或類別的情況下擴充套件其功能。以下是一個進階的裝飾器實作範例，用於實作函式執行時間的測量：

import time
from functools import wraps

def measure_time(func):
 @wraps(func)
 def wrapper(*args, **kwargs):
 start_time = time.time()
 result = func(*args, **kwargs)
 end_time = time.time()
 print(f"函式 {func.__name__} 執行時間：{end_time - start_time:.4f} 秒")
 return result
 return wrapper

@measure_time
def complex_calculation(n):
 total = 0
 for i in range(n):
 total += i
 return total

complex_calculation(10000000)

內容解密：

此範例定義了一個名為 measure_time 的裝飾器，用於測量被裝飾函式的執行時間。@wraps(func) 用於保留原始函式的後設資料。complex_calculation 函式被 @measure_time 裝飾，因此每次呼叫時都會輸出其執行時間。

類別裝飾器的進階應用

類別裝飾器可以為類別新增額外的屬性和方法。以下是一個為類別新增版本資訊的裝飾器範例：

def add_version(version):
 def decorator(cls):
 class VersionedClass(cls):
 @property
 def version(self):
 return version
 return VersionedClass
 return decorator

@add_version("2.0")
class MyClass:
 pass

print(MyClass().version) # 輸出:2.0

內容解密：

此範例定義了一個名為 add_version 的類別裝飾器，它為被裝飾的類別新增了一個名為 version 的屬性，並指定為指定的版本號碼。MyClass 被 @add_version("2.0") 修飾，因此具備了 version 屬性。

閉包的高階應用

閉包允許建立具有持久狀態的函式。以下是一個使用閉包實作計數器的範例：

def create_counter():
 count = 0
 def counter():
 nonlocal count
 count += 1
 return count
 return counter

counter = create_counter()
print(counter()) # 輸出:1
print(counter()) # 輸出:2
print(counter()) # 輸出:3

內容解密：

此範例定義了一個名為 create_counter 的函式，它傳回一個內部函式 counter。counter 函式記住了 create_counter 中的 count 變數，並在每次呼叫時遞增其值。

流程控制與錯誤處理的最佳實踐

在實際開發中，適當的流程控制和錯誤處理至關重要。以下是一個結合裝飾器和錯誤處理的範例：

def error_handler(func):
 @wraps(func)
 def wrapper(*args, **kwargs):
 try:
 return func(*args, **kwargs)
 except Exception as e:
 print(f"錯誤發生：{e}")
 return None
 return wrapper

@error_handler
def divide(a, b):
 return a / b

print(divide(10, 2)) # 輸出:5.0
print(divide(10, 0)) # 輸出:錯誤發生：division by zero

內容解密：

此範例定義了一個名為 error_handler 的裝飾器，用於捕捉被裝飾函式中的異常。divide 函式被 @error_handler 裝飾，因此在發生除零錯誤時會輸出錯誤訊息而不是丟擲異常。

視覺化圖表與架構解析

系統架構圖

  graph LR
 A[使用者請求] --> B[Web 伺服器]
 B --> C[應用伺服器]
 C --> D[資料函式庫]
 D --> E[資料快取]
 E --> F[回應生成]
 F --> B
 B --> A

圖表剖析：

此架構圖展示了一個典型的 Web 應用系統架構。使用者請求首先到達 Web 伺服器，然後轉發到應用伺服器進行業務邏輯處理。應用伺服器與資料函式庫和資料快取互動以取得所需資料。最終，回應被生成並傳回給使用者。

執行流程圖

  graph TD
 A[開始] --> B{檢查輸入}
 B -->|有效| C[處理資料]
 B -->|無效| D[錯誤處理]
 C --> E[生成結果]
 D --> F[傳回錯誤]
 E --> G[傳回結果]

圖表剖析：

此流程圖展示了一個典型的資料處理流程。首先檢查輸入的有效性。如果輸入有效，則進行資料處理並生成結果。如果輸入無效，則進行錯誤處理。最終，根據處理結果傳回相應的輸出。

進階技術議題探討

效能最佳化技巧

在實際開發中，效能最佳化是一個重要的議題。以下是一些常見的最佳化技巧：

  1. 使用高效的資料結構：選擇合適的資料結構可以顯著提高程式效能。例如，使用 set 進行快速查詢。
  2. 避免不必要的計算：透過快取計算結果或使用惰性求值來減少不必要的計算。
  3. 平行處理：利用多執行緒或多程式來平行處理任務，提高整體效能。

安全最佳實踐

在開發過程中，安全是一個不可忽視的重要議題。以下是一些常見的安全最佳實踐：

  1. 輸入驗證：始終驗證使用者輸入，防止 SQL 注入和 XSS 攻擊。
  2. 使用安全的密碼儲存：使用加鹽雜湊（salted hash）來儲存使用者密碼。
  3. 定期更新依賴函式庫：保持依賴函式庫的最新版本，以修復已知的安全漏洞。

從技術架構視角來看，Python 函式的靈活運用，體現了程式設計的精髓。純函式的設計提升了程式碼的可測試性和可維護性，而副作用函式和修改可變引數的函式則為狀態管理和與外部系統互動提供了必要的途徑。靜態方法和類別方法的應用，有效地組織了程式碼結構，並提升了程式碼的重用性。然而，需注意副作用函式可能帶來的狀態管理複雜性，以及修改可變引數可能引入的非預期錯誤。對於重視程式碼穩健性的開發者，建議優先採用純函式，並謹慎使用全域變數。隨著函式式程式設計的興起，純函式的應用將更加廣泛，而對副作用的管理也將更加精細化。玄貓認為，深入理解不同型別函式的特性，並根據實際需求選擇合適的函式型別，是提升 Python 程式設計水平的關鍵。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。