Colab 與 Python 函數定義與呼叫

在 Python 程式設計中，函數 (function) 是一個可重複使用的程式碼區塊，用於執行特定任務。使用函數可以提高程式碼的模組化、可讀性和可維護性。本文將詳細介紹在 Colab 環境中如何定義和呼叫 Python 函數，並涵蓋函數的各個重要概念。

什麼是函數？為什麼要使用函數？

函數就像一個小型工廠，它接收一些輸入 (參數)，進行一些處理，然後產生輸出 (返回值)。使用函數的好處包括：

• 程式碼重用 (Code Reusability): 您可以將重複使用的程式碼片段封裝成函數，然後在程式的不同位置多次呼叫該函數，而不需要重複編寫相同的程式碼。
• 模組化 (Modularity): 將大型程式分解成多個較小的函數，每個函數負責一個特定的任務，使程式碼更易於組織和理解。
• 提高可讀性 (Readability): 使用函數可以將複雜的邏輯分解成更易於理解的步驟，並為每個步驟命名 (函數名稱)，使程式碼更易於閱讀和維護。
• 抽象化 (Abstraction): 使用者不需要知道函數內部的所有細節，只需要知道如何使用 (輸入是什麼, 輸出是什麼)。

函數定義 (Defining a Function)

在 Python 中，使用 def 關鍵字來定義函數，基本語法如下：

def 函數名稱(參數1, 參數2, ...):
    """
    Docstring (文件字串): 函數的說明文件 (可選，但強烈建議)
    """
    # 函數體 (function body): 執行特定任務的程式碼區塊
    # ...
    return 返回值  # 可選

重要元素

• def: 定義函數的關鍵字。
• 函數名稱: 為函數取一個有意義的名稱 (遵循變數命名規則)。
• 參數 (parameters): 放在括號 () 內，用於接收傳入函數的資料。
• 冒號 (:): 標記函數定義的開始。
• 函數體 (function body): 縮排的程式碼區塊，包含函數要執行的程式碼。
• return: 可選的關鍵字，用於返回函數的結果 (若無則返回 None)。
• Docstring: 函數的說明文件，用於解釋函數的功能、參數和返回值 (可選，但強烈建議撰寫)。

範例：

def greet(name):
    """
    這個函數會向傳入的名字打招呼。

    Args:
        name (str): 要打招呼的名字。
    """
    print(f"Hello, {name}!")

def add(a, b):
    """
    這個函數計算兩個數的和。

    Args:
        a (int or float): 第一個數字。
        b (int or float): 第二個數字。

    Returns:
        int or float: 兩個數字的和。
    """
    return a + b

函數呼叫 (Calling a Function)

定義函數後，您可以使用函數名稱和括號 () 來呼叫 (執行) 函數。 如果函數需要參數，請在括號內傳入實際參數 (arguments)：

# 呼叫 greet 函數，傳入 "Alice" 作為參數
greet("Alice")

# 呼叫 add 函數，傳入 5 和 3 作為參數，並將返回值賦值給 result
result = add(5, 3)
print(result)  # 輸出: 8

# 呼叫有 docstring 的函數，可使用 help() 或 __doc__ 查看說明
help(greet)
print(greet.__doc__)

函數參數 (Function Arguments)

Python 函數的參數非常靈活，有以下幾種類型：

1. 位置參數 (Positional Arguments)

按照定義的順序傳入參數。 這是最常見的參數類型。

def describe_pet(animal_type, pet_name):
    print(f"I have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name}.")

# 按照順序傳入參數
describe_pet("dog", "Buddy")

2. 關鍵字參數 (Keyword Arguments)

使用 參數名=值 的形式傳入參數，可以不按照定義的順序。

# 使用關鍵字參數，順序可以調換
describe_pet(pet_name="Whiskers", animal_type="cat")

3. 預設參數 (Default Arguments)

在定義函數時為參數指定預設值。 如果呼叫函數時沒有傳入該參數，則使用預設值。

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice")        # 輸出: Hello, Alice! (使用預設的 greeting)
greet("Bob", "Hi")    # 輸出: Hi, Bob!      (覆蓋預設的 greeting)

注意事項: 預設參數值只會在函數定義時計算一次。如果預設參數是一個可變物件 (例如串列或字典)，這可能會導致意外的行為。建議使用 None 作為可變物件的預設值，並在函數體內進行檢查和初始化。

def append_to_list(value, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(value)
    return my_list

4. 可變數量參數 (Variable-Length Arguments)

有時候您可能希望函數接收不確定數量的參數。 Python 提供了兩種方式來實現：

• *args: 接收任意數量的位置參數，將它們組合成一個元組 (tuple)。
• **kwargs: 接收任意數量的關鍵字參數，將它們組合成一個字典 (dict)。

def my_function(*args, **kwargs):
    print("Positional arguments (*args):", args)
    print("Keyword arguments (**kwargs):", kwargs)

my_function(1, 2, 3, name="Alice", age=30)
# 輸出：
# Positional arguments (*args): (1, 2, 3)
# Keyword arguments (**kwargs): {'name': 'Alice', 'age': 30}

def print_args(*args):
    for arg in args:
        print(arg)
print_args(1, 2, 3, 'a', 'b')

def print_kwargs(**kwargs):
    for k, v in kwargs.items():
        print(f'{k}: {v}')
print_kwargs(name="Alice", age=29)

函數返回值 (Return Values)

使用 return 語句返回函數的結果。 return 語句也可以用來提前結束函數的執行。

def add(a, b):
    return a + b
result = add(5, 3)
print(result)  # 輸出: 8

def get_name_and_age():
    return "Bob", 25  # 返回多個值 (實際上是返回一個元組)
name, age = get_name_and_age()
print(name, age)  # 輸出: Bob 25

def check_number(x):
    if x > 10:
        return # 提前結束, 沒有 return 值, 則回傳 None
    print('small number')
result = check_number(15)
print(result) # 輸出: None

函數的作用域 (Scope)

作用域決定了變數的可見性和生命週期。 Python 中有以下幾種作用域：

• 區域作用域 (Local): 在函數內部定義的變數，只在函數內部有效。
• 全域作用域 (Global): 在函數外部定義的變數，在整個程式中都有效。
• 封閉作用域 (Enclosing/Nonlocal): 在巢狀函數中，內層函數可以存取外層函數的變數。
• 內建作用域 (Built-in): Python 內建的名稱，例如 print, len 等。

global_var = 10  # 全域變數

def my_function():
    local_var = 5  # 區域變數
    print("Inside function, can read global:", global_var)

    def inner_function():
        nonlocal local_var # 宣告 nonlocal
        local_var = 8      # 修改外層函數的區域變數
        print("Inner scope:", local_var)

    inner_function()
    print("Outer scope after inner call:", local_var)

my_function()

def another_function():
    global global_var  # 宣告要修改全域變數
    global_var = 20

another_function()
print("Global var after modification:", global_var)  # 輸出: 20

匿名函數 (Lambda Functions)

使用 lambda 關鍵字定義簡潔的單行函數。匿名函數通常用於需要一個簡單函數作為參數的場合 (例如 map()、filter()、sorted() 等高階函數)。

語法: lambda arguments: expression

add = lambda x, y: x + y
print(add(2, 3))  # 輸出: 5

# 搭配 map() 使用
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # 輸出: [1, 4, 9, 16, 25]

# 搭配 filter() 使用
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # 輸出: [2, 4, 6]

# 搭配 sorted() 使用
students = [
    {'name': 'Alice', 'grade': 85},
    {'name': 'Bob', 'grade': 92},
    {'name': 'Charlie', 'grade': 78}
]
sorted_students = sorted(students, key=lambda student: student['grade'])
print(sorted_students)

總結

本文詳細介紹了在 Colab 和 Python 中定義和呼叫函數的各種方法，包括函數的定義、呼叫、參數傳遞、返回值、作用域以及匿名函數。掌握這些概念是 Python 程式設計的基石，也是進一步學習更進階主題的關鍵。在 Colab 環境中，您可以輕鬆地編寫和執行 Python 程式碼，並即時查看結果，這使得學習和實驗 Python 函數變得非常方便。