編寫高效Python函數的五個技巧，真心建議你牢記，并當作此后編碼的準繩！
編寫高效和可維護的Python函數對于生成高質量的代碼至關重要。本文將向大家分享5個關鍵技巧（也是眾多技術大牛多年以來的經驗總結），幫助你完善Python函數并提高代碼的可讀性、可維護性和穩健性。
以下是文章的整體概覽：
首先，強調遵循單一職責原則，確保每個函數只執行一個任務。接下來，討論了類型提示（type hints）為增強代碼清晰度和長期可維護性帶來的好處。
接著文章探討了僅關鍵字參數（keyword-only）這一Python功能，它可以通過強制使用參數名稱來最小化出錯的幾率。另一個建議是嚴格控制參數數量，僅使用函數功能所必要的參數，這樣做可以減少復雜性和潛在的 bug。
最后，文章倡導使用生成器（Generator）這種內存高效利用的技術來返回可迭代數據，而不是一次性構造并返回整個列表。
無論你是新手還是經驗豐富的開發者，都建議從現在開始應用這5個技巧，并在日常工作中不斷實踐，相信你可以在未來的編程生涯中編寫出更高效、更具可讀性和可維護性的函數，從而產生更高質量的代碼，從而提高你的生產力。
1. 你的函數應該只做一件事
“你的函數應該只做一件事”原則是整潔代碼和高效編程的核心原則。這一原則也被稱為單一職責原則（Single Responsibility Principle, SRP），它的宗旨是建議一個函數應該只有一個職責或任務。這會讓你的代碼更易于閱讀、測試、調試和維護。以下是應用此原則的一些優點：
- 可讀性（Readability）：當一個函數只做一件事時，會更容易理解，初一瞥就可以一目了然。函數名可以清楚地描述其目的（命名時盡可能做到見名知意??），實現也很簡單。
- 可重用性（Reusability）：單一目的的函數可以在程序的不同部分或其他項目中重復使用，避免重復造輪子。
- 可測試性（Testability）：編寫針對一個單一功能函數的測試更容易，這種測試也更可靠。
- 可維護性（Maintainability）：如果一個函數只負責一個任務，影響該任務的需求變更將局限在該函數內，減少了代碼其他部分出現bug的風險。
假設你正在開發一個Python程序，處理一個數字列表，需要實現:
- 過濾掉負數。
- 對剩余的數字進行平方運算。
- 計算平方數的總和。
def filter_negative_numbers(numbers):
"""Filters out negative numbers from the list."""
return [num for num in numbers if num >= 0]
def square_numbers(numbers):
"""Return a list of squared numbers."""
return [num ** 2 for num in numbers]
def sum_numbers(numbers):
"""Return the sum of numbers."""
return sum(numbers)
def data_processing(numbers):
"""Process the list of nubers: filter, square, and sum."""
positive_numbers = filter_negative_numbers(numbers)
squared_numbers = square_numbers(positive_numbers)
total = sum_numbers(squared_numbers)
return total
if __name__ == '__main__':
numbers = [-2, -3, 4, -1, -2, 1, 5, -3]
result = data_processing(numbers)
print(result) # Output: 422. 增加類型提示以提高可讀性和可維護性
類型提示（Type hints）是Python中一項非常棒的功能，允許你指定變量、函數參數和返回值的預期類型。該特征在 PEP 484 中引入，類型提示不會影響程序運行時的行為，而是提供了一種對代碼執行靜態類型檢查的方式。它們提高了代碼的可讀性，并幫助開發人員理解預期的輸入和輸出類型，使代碼更易于維護。添加類型提示可以改善以下幾點：
- 提高可讀性：通過明確指出函數期望的參數類型和返回值類型，類型提示使代碼更具可讀性，并且更容易理解，一目了然。
- 錯誤檢測：可以使用像 mypy 這樣的工具進行靜態類型檢查，在開發過程的早期就捕捉潛在的 bug。
- 文檔：類型提示可以作為一種文檔形式，提供有關如何使用函數和方法的寶貴信息。
在單一職責原則中我們提供了一個沒有類型提示的示例，接下來我們將提供一個具有類型提示的版本，功能一樣：
from typing import List
def filter_positive_numbers(numbers: List[int]) -> List[int]:
"""Filters out negative numbers from the list."""
return [num for num in numbers if num >= 0]
def square_positive_numbers(numbers: List[int]) -> List[int]:
"""Return a list of squared numbers."""
return [num ** 2 for num in numbers]
def sum_numbers(numbers: List[int]) -> int:
"""Return the sum of numbers."""
return sum(numbers)
def data_processing(numbers: List[int]) -> int:
"""Process the list of nubers: filter, square, and sum."""
positive_numbers = filter_positive_numbers(numbers)
squared_numbers = square_positive_numbers(positive_numbers)
total = sum_numbers(squared_numbers)
return total
if __name__ == '__main__':
numbers = [-2, -3, 4, -1, -2, 1, 5, -3]
result = data_processing(numbers)
print(result) # Output: 42比較這兩段代碼，我們可以發現：
- 可讀性（Readability）****
沒有類型提示：閱讀函數定義時，不太清楚期望什么類型的參數或函數返回什么類型。
有類型提示：函數簽名明確指出它們使用整數列表，并返回整數列表或單個整數。
- 錯誤檢測（Error Detection）
沒有類型提示：類型相關的錯誤可能只會在運行時被捕獲，這可能導致難以追蹤的 bug。
有類型提示：像 mypy 這樣的工具可以在編譯時檢查類型，在代碼執行之前捕捉錯誤。
3. 強制使用僅關鍵字參數以最小化出錯幾率
強制使用“僅關鍵字參數”（keyword-only）是Python中的一種技術，該技術表明，調用函數時某些參數必須通過名稱指定。
這是通過在函數定義中使用特殊語法來完成的，該語法可以防止這些參數以位置方式傳遞。這種方法可以顯著提高代碼的清晰度并減少錯誤。
在Python函數中強制使用“僅關鍵字參數”可以大大增強代碼的清晰度和正確性。關鍵字參數只能使用參數名稱指定。這種強制執行有助于：
- 防止錯誤：通過要求參數按名稱傳遞，可以減少以錯誤順序傳遞參數的風險，從而避免出現微不可查的 bug。
- 提高可讀性：它使函數調用更具可讀性，明確表示每個參數的含義。
- 增強靈活性：它允許你在不破壞現有代碼的情況下，將來可以向函數添加更多參數，因為參數是顯式命名的。
- 提高清晰度：它使代碼的意圖更加清晰，因為每個參數的目的都在調用點指定。
下面是一個郵件發送的示例。send_email 函數接受一個可選的 cc 字符串：
def send_email(recipient: str, subject: str, body: str, cc: str = None):
print(f"Sending email to {recipient}...")
print(f"Subject: {subject}")
print(f"Body: {body}")
if cc:
print(f"CC: {cc}")
if __name__ == '__main__':
send_email('jackzhang@example.com', '編寫高效Python函數的5個技巧',
'本文將向大家分享5個讓你編寫高效Python函數的技巧...', 'cc@example.com')假設您想將可選的 cc 參數設置為關鍵字參數。可以這樣做:
# Make the optional 'cc' argument keyword-only
def send_email(recipient: str, subject: str, body: str, *, cc: str = None):
print(f"Sending email to {recipient}...")
print(f"Subject: {subject}")
print(f"Body: {body}")
if cc:
print(f"CC: {cc}")
if __name__ == '__main__':
send_email('jackzhang@example.com', '編寫高效Python函數的5個技巧',
'本文將向大家分享5個讓你編寫高效Python函數的技巧...', cc='cc@example.com')只需要在可選參數 cc 前使用 * 號將前后隔開即可將其后的參數變成僅關鍵字參數。如果你想了解更多關于關鍵字參數和位置參數的細節，請閱讀我的另一篇文章（Python效率秘籍：使用“*” 和“/” 讓你的函數參數看起來更整潔）。
現在我們再次調用函數時可選參數 cc 就必須用定義時的名稱進行值傳遞：
send_email('jackzhang@example.com', '編寫高效Python函數的5個技巧',
'本文將向大家分享5個讓你編寫高效Python函數的技巧...', cc='cc@example.com')Sending email to jackzhang@example.com...
Subject: 編寫高效Python函數的5個技巧
Body: 本文將向大家分享5個讓你編寫高效Python函數的技巧...
CC: cc@example.com如果我們嘗試像之前一樣所有參數都采用位置參數傳遞：
send_email('jackzhang@example.com', '編寫高效Python函數的5個技巧',
'本文將向大家分享5個讓你編寫高效Python函數的技巧...', 'cc@example.com')你將會收到下面這樣的報錯信息：
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[6], line 10
7 print(f"CC: {cc}")
9 if __name__ == '__main__':
---> 10 send_email('jackzhang@example.com', '編寫高效Python函數的5個技巧',
11 '本文將向大家分享5個讓你編寫高效Python函數的技巧...', 'cc@example.com')
TypeError: send_email() takes 3 positional arguments but 4 were given4. 你的函數應該只使用必要參數
在定義函數時，嚴格限制參數數量，將其限制為函數操作所必要的參數至關重要。不必要的參數會常常會導致混淆，使函數調用臃腫，并且會讓維護變得更復雜。以下是你應該只使用必要參數的幾個原因：
- 提高可讀性：更少的參數使函數簽名更簡單、更易于理解。
- 增強可維護性：參數較少的函數更易于重構和測試。
- 減少錯誤：當函數只接受必要的參數時，可以降低傳遞不正確或冗余數據的可能性。
以下是一個冗余參數的函數示例：
# example function for processing an order including unnecessary arguments
def process_order(order_id: int, customer_id: int, customer_name: str,
amount: float, discount: float = 0.0):
print(f"Processing order {order_id} for customer {customer_id} - {customer_name}")
total_amount = amount * (1 - discount)
print(f"Total amount after discount: {total_amount}")
if __name__ == '__main__':
process_order(666, 888, 'Jack Zhang', 1000.0, 0.05)Processing order 666 for customer 888 - Jack Zhang
Total amount after discount: 950.0在這個例子中，函數 process_order 同時接受 customer_id 和 customer_name 參數，如果所有必需的信息都可以從 order_id 中獲得，這兩個參數可能是不必要的。
現在，讓我們只使用必要的參數，重構該函數：
# example function for processing an order with only necessary arguments
def process_order(order_id: int, amount: float, discount: float = 0.0):
print(f"Processing order {order_id}")
total_amount = amount * (1 - discount)
print(f"Total amount after discount: {total_amount}")
if __name__ == '__main__':
process_order(666, 1000.0, 0.05)5. 使用生成器返回列表
生成器（Generator）是Python中一種特殊的可迭代對象，它允許你逐個迭代序列值，而不需要一次性將整個序列存儲在內存中。生成器通過函數和 yield 關鍵字進行定義，該關鍵字允許函數返回一個值并暫停其狀態，在下次請求值時恢復。這使得生成器成為處理大型數據集或數據流的高效方式。
以下是你應該使用生成器的幾個原因：
- 內存效率：生成器一次只生成一個數據項，并且是按需生成，這意味著它們不需要將整個序列存儲在內存中。這對于大型數據集特別有用。
- 性能：由于生成器按需生成數據項，因此它們可以讓程序性能得到提升，因為避免了創建和存儲大型數據結構的開銷。
- 惰性求值：生成器按需計算值，這可以得到更高效和響應性更強的程序。
- 更簡單的代碼：生成器可以簡化創建迭代器所需的代碼，使其更易于閱讀和維護。
以下是一個不使用生成器返回列表的函數示例：
from typing import List
def get_squares(n: int) -> List[int]:
"""Return a list of squares from 0 to n-1."""
squares = []
for i in range(n):
squares.append(i * i)
return squares
if __name__ == '__main__':
squares_list = get_squares(10)
print(squares_list)
# Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]在這個例子中，函數 get_squares 在返回之前會生成并存儲所有數值（0~n-1）的平方數。現在，我們改用生成器實現相同的功能：
from typing import List
def get_squares(n: int) -> List[int]:
"""Yield squares from 0 to n-1."""
for i in range(n):
yield i * i
if __name__ == '__main__':
squares_gen = get_squares(10)
print(list(squares_gen))在Python中使用生成器返回列表可以在內存效率、性能和惰性求值方面帶來顯著優勢。通過按需生成值，你可以更高效地處理大型數據集，編寫更簡潔、更易維護的代碼。
兩種方法的比較清楚地顯示了使用生成器的好處，特別是對于大型或計算密集型序列的優勢尤其顯著。
