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: 可選的關鍵字，用於返回函數的結果 (如果沒有 return 語句，或 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" 作為參數

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

#呼叫有docstring的函數
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(5)
print(result) # None
result = check_number(15)
print(result) # None
```

函數的作用域 (Scope)

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

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

global_var = 10  # 全域變數

def my_function():
    local_var = 5  # 區域變數
    print("Inside function:", global_var) #可以讀取global variable

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

    inner_function()
    print("Outer:", local_var)  # 外層函數的 local_var 已經被修改

my_function()
print("Outside function:", global_var) #仍可讀取global
# print(local_var)  # 錯誤：local_var 在函數外部不可見

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

another_function()
print("Outside another_function", 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_number = list(filter(lambda x: x%2 == 0, numbers))
print(even_number) #[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 函數變得非常方便。