Day 30 函数定义与参数

@浙大疏锦行

在 Python 中，函数是封装可重用代码块 的基本单位，通过定义函数可以将一段逻辑抽象化，实现代码的模块化和复用。函数的核心是 "输入（参数）→ 处理 → 输出（返回值）"，其中参数的设计直接决定了函数的灵活性和适用范围。

一、函数的定义：基础语法

函数通过 def 关键字定义，基本结构如下：

复制代码

def 函数名(参数列表):
    """函数文档字符串（可选，用于说明功能）"""
    # 函数体（具体逻辑）
    return 返回值  # 可选，无 return 则默认返回 None

示例：最简单的函数

复制代码

def greet():
    """打印问候语"""
    print("Hello, World!")

# 调用函数
greet()  # 输出：Hello, World!
print(greet())  # 输出：Hello, World!  None（因无 return，默认返回 None）

二、函数的参数：核心分类

参数是函数的 "输入"，决定了函数调用时需要传入的数据。Python 的函数参数非常灵活，按传递方式和作用可分为以下几类：

1. 位置参数（Positional Arguments）

最基础的参数类型，必须按顺序传入，且数量必须与定义时一致。

示例：计算两数之和

复制代码

def add(a, b):  # a 和 b 是位置参数
    return a + b

# 调用时必须按顺序传入两个参数
print(add(2, 3))  # 输出：5（a=2, b=3）
print(add(3, 2))  # 输出：5（a=3, b=2）

# 错误：参数数量不符
# add(1)  # 报错：TypeError: add() missing 1 required positional argument: 'b'

2. 关键字参数（Keyword Arguments）

调用函数时通过 参数名=值 的形式传入，无需按顺序，增强代码可读性。

示例：用关键字参数调用函数

复制代码

def describe_person(name, age):
    print(f"姓名：{name}，年龄：{age}")

# 纯关键字参数调用（顺序可换）
describe_person(age=18, name="Alice")  # 输出：姓名：Alice，年龄：18

# 位置参数 + 关键字参数（位置参数必须在前）
describe_person("Bob", age=20)  # 输出：姓名：Bob，年龄：20

3. 默认参数（Default Arguments）

定义函数时给参数指定默认值，调用时可省略传入，适合 "常用值固定" 的场景。

示例：带默认值的函数

复制代码

def greet(name, prefix="Hello"):  # prefix 是默认参数，默认值为 "Hello"
    print(f"{prefix}, {name}!")

# 省略默认参数（使用默认值）
greet("Alice")  # 输出：Hello, Alice!

# 传入默认参数（覆盖默认值）
greet("Bob", prefix="Hi")  # 输出：Hi, Bob!

注意事项：

默认参数必须放在位置参数之后（否则报错）；

默认参数的值在函数定义时计算一次 ，若默认值是可变对象（如列表），需谨慎使用：

复制代码

def add_item(item, lst=[]):  # 危险：默认值是可变列表
    lst.append(item)
    return lst

print(add_item(1))  # [1]
print(add_item(2))  # [1, 2]（默认列表被复用，非预期结果）

# 正确写法：默认值设为 None，在函数内初始化
def add_item(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

4. 可变位置参数（*args）

允许传入任意数量的位置参数 ，函数内部会将其封装为元组。适合参数数量不确定的场景。

示例：计算任意个数的和

复制代码

def sum_all(*args):  # *args 接收所有位置参数，打包为元组
    print("传入的参数：", args)  # 元组形式
    return sum(args)

print(sum_all(1, 2, 3))  # 传入3个参数 → 输出：6（args=(1,2,3)）
print(sum_all(10, 20))   # 传入2个参数 → 输出：30（args=(10,20)）
print(sum_all())         # 传入0个参数 → 输出：0（args=()）

扩展：解包可迭代对象传给 *args

在可迭代对象（列表、元组等）前加 *，可将其元素拆分为单个位置参数：

复制代码

nums = [1, 2, 3, 4]
print(sum_all(*nums))  # 等价于 sum_all(1,2,3,4) → 输出：10

5. 可变关键字参数（**kwargs）

允许传入任意数量的关键字参数 ，函数内部会将其封装为字典。适合需要接收 "键值对" 形式的不定参数场景。

示例：打印任意键值对信息

复制代码

def print_info(**kwargs):  # **kwargs 接收所有关键字参数，打包为字典
    print("传入的键值对：", kwargs)  # 字典形式
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=18, city="Beijing")
# 输出：
# 传入的键值对： {'name': 'Alice', 'age': 18, 'city': 'Beijing'}
# name: Alice
# age: 18
# city: Beijing

扩展：解包字典传给 **kwargs

在字典前加 **，可将其键值对拆分为单个关键字参数：

复制代码

info = {"name": "Bob", "age": 20}
print_info(** info)  # 等价于 print_info(name="Bob", age=20)

三、参数的组合使用：优先级规则

当函数同时使用多种参数时，必须按以下优先级顺序 定义：** 位置参数 → 默认参数 → 可变位置参数（*args）→ 可变关键字参数（kwargs）

示例：多类型参数组合

复制代码

def complex_func(a, b=0, *args, **kwargs):
    print(f"位置参数 a: {a}")
    print(f"默认参数 b: {b}")
    print(f"可变位置参数 args: {args}")
    print(f"可变关键字参数 kwargs: {kwargs}")

# 调用函数
complex_func(1, 2, 3, 4, x=5, y=6)
# 输出：
# 位置参数 a: 1
# 默认参数 b: 2
# 可变位置参数 args: (3, 4)
# 可变关键字参数 kwargs: {'x': 5, 'y': 6}

四、函数的返回值（return）

函数通过 return 语句返回结果，执行到 return 后立即退出函数；
可返回任意类型（数值、字符串、列表、字典、甚至函数）；
无 return 或 return 后无值，默认返回 None；
可返回多个值（本质是返回元组，调用时可解包）。

示例：返回多个值

复制代码

def get_name_and_age():
    return "Alice", 18  # 等价于 return ("Alice", 18)

# 调用时解包
name, age = get_name_and_age()
print(name)  # Alice
print(age)   # 18

作业：

题目1wu

题目2

题目3

题目4

题目5