Python函数:函数的参数

上一期我们掌握了Python函数的核心概念与def定义语法，学会了如何封装可复用的代码块；今天我们聚焦函数的“灵魂组件”——函数的参数，详细拆解不同类型参数的用法、适用场景，帮你理解参数的本质，轻松实现函数的灵活调用，摆脱“参数写错就报错”的困扰，让代码更具扩展性。

在函数的使用中，参数就像“函数的输入接口”，负责接收外部传入的数据，让函数摆脱固定逻辑的限制，实现“同一函数，不同输入，不同输出”。无论是简单的数值计算，还是复杂的业务逻辑处理，参数的灵活运用都能让函数更强大、更通用，是Python函数实战的核心重点。

📌 什么是函数的参数？

函数的参数，本质是函数定义时预留的“输入入口”，用于接收外部传入的数据，供函数体内部逻辑使用。简单来说，参数就像“函数的原材料”，没有参数，函数只能执行固定逻辑；有了参数，函数就能根据不同的输入，执行对应的逻辑，返回不同的结果。

举个生活中的例子：我们之前定义的“咖啡机函数”，如果没有参数，它只能固定产出一种咖啡；而加上“咖啡类型”“甜度”“温度”这些参数，我们就能通过传入不同的参数，得到美式、拿铁、卡布奇诺等不同的咖啡，这就是参数的核心价值——让函数更灵活、更通用。

核心说明：参数分为“形参”和“实参”，二者一一对应、缺一不可：形参是函数定义时写在括号里的“变量名”（预留的输入位置），实参是函数调用时传入括号里的“具体值”（实际的原材料），只有形参与实参匹配，函数才能正常执行。

# 简单示例：形参与实参的对应关系# 定义函数（a、b是形参，预留输入位置）def add_num(a, b):    return a + b# 调用函数（3、5是实参，实际传入的数值）result = add_num(3, 5)print(result)  # 输出：8# 说明：形参a接收实参3，形参b接收实参5，函数体执行3+5，返回结果

🔧 核心分类：4种常用函数参数

Python中函数的参数有4种核心类型，分别是位置参数、关键字参数、默认参数、可变参数，每种类型都有明确的适用场景和语法规则，结合实例练习，就能快速掌握，灵活搭配使用。

1. 位置参数

位置参数，又称“必选参数”，是最基础的参数类型，必须按照定义的顺序传入实参，且实参的数量必须与形参完全一致，缺一不可、多一不可，否则会直接报错。

适用场景：函数参数数量固定、逻辑简单，且参数之间有明确的顺序要求（如数值计算、简单数据处理）。

# 示例1：两数相加（位置参数）def add_num(a, b):  # a、b是位置形参，有顺序要求    return a + b# 正确调用：实参顺序与形参一致，数量一致print(add_num(3, 5))  # 输出：8（a=3，b=5）print(add_num(5, 3))  # 输出：8（a=5，b=3）# 错误调用（必避）# print(add_num(3))  # 错误：实参数量不足（少1个）# print(add_num(3, 5, 7))  # 错误：实参数量过多（多1个）# print(add_num(b=3, a=5))  # 不报错，但不是位置参数的调用方式（属于关键字参数）
# 示例2：多位置参数（实战场景）def get_user_info(name, age, gender):  # 3个位置形参，顺序固定    print(f"姓名：{name}，年龄：{age}，性别：{gender}")# 正确调用：实参顺序与形参一致（姓名→年龄→性别）get_user_info("小明", 20, "男")  # 输出：姓名：小明，年龄：20，性别：男

2. 关键字参数（更灵活，实战常用）

关键字参数，是通过“形参名=实参值”的形式传入实参，无需遵循形参的定义顺序，只要保证形参名正确、实参数量匹配，就能正常执行，极大提升了函数调用的灵活性。

适用场景：函数参数数量较多、顺序容易记混，或只需传入部分参数（结合默认参数使用），避免因顺序错误导致函数执行异常。

# 示例：结合位置参数，使用关键字参数调用def get_user_info(name, age, gender):    print(f"姓名：{name}，年龄：{age}，性别：{gender}")# 正确调用：关键字参数，无需遵循顺序get_user_info(age=20, name="小明", gender="男")  # 输出：姓名：小明，年龄：20，性别：男get_user_info(name="小红", gender="女", age=19)  # 输出：姓名：小红，年龄：19，性别：女# 混合调用：位置参数在前，关键字参数在后（必须遵循此规则）get_user_info("小李", gender="男", age=21)  # 正确：位置参数name在前，关键字参数在后# get_user_info(gender="女", "小张", 18)  # 错误：关键字参数不能在位置参数前面# 核心优势：避免记混参数顺序，尤其适合参数多的场景def calculate(a, b, c, d):  # 4个参数，顺序易混    return a + b - c * d# 关键字参数调用，清晰明了print(calculate(a=10, b=5, c=2, d=3))  # 输出：10+5-2*3=9

3. 默认参数（省时间，提升效率）

默认参数，是函数定义时给形参指定一个默认值，函数调用时，若不传入该参数，就使用默认值；若传入该参数，就使用传入的实参值，无需每次调用都重复传入相同的参数，极大提升调用效率。

适用场景：函数的某个或某些参数，在大多数调用场景下取值相同（如默认配置、默认选项），避免重复传入冗余参数。

# 示例1：基础默认参数（实战常用）def get_user_info(name, age, gender="男"):  # gender是默认参数，默认值为"男"    print(f"姓名：{name}，年龄：{age}，性别：{gender}")# 调用1：不传入默认参数，使用默认值get_user_info("小明", 20)  # 输出：姓名：小明，年龄：20，性别：男# 调用2：传入默认参数，覆盖默认值get_user_info("小红", 19, "女")  # 输出：姓名：小红，年龄：19，性别：女get_user_info("小刚", 21, gender="男")  # 结合关键字参数，更清晰# 示例2：多个默认参数（注意顺序）def calculate(a, b, c=0, d=1):  # 默认参数放在位置参数后面（必遵循）    return a + b - c * d# 调用：可只传入位置参数，默认参数使用默认值print(calculate(10, 5))  # 输出：10+5-0*1=15# 调用：传入部分默认参数，其余使用默认值print(calculate(10, 5, c=2))  # 输出：10+5-2*1=13# 调用：传入所有参数，覆盖默认值print(calculate(10, 5, 2, 3))  # 输出：10+5-2*3=9# 注意：默认参数必须放在位置参数后面（错误示例）# def get_user_info(gender="男", name, age):  # 错误：默认参数不能在位置参数前面

4. 可变参数

可变参数，又称“不定长参数”，用于处理参数数量不确定的场景，无需提前定义参数个数，可接收任意数量的实参，分为两种：*args（接收任意数量的位置参数）和**kwargs（接收任意数量的关键字参数）。

适用场景：函数参数数量不确定（如批量处理数据、灵活传入配置），避免因参数数量变化导致函数定义频繁修改。

# 示例1：*args（接收任意数量的位置参数，返回元组）def add_all(*args):  # *args 接收所有位置实参，存储为元组    total = 0    for num in args:        total += num    return total# 调用：传入任意数量的位置参数print(add_all(1, 2, 3))  # 输出：6（1+2+3）print(add_all(10, 20, 30, 40))  # 输出：100（10+20+30+40）print(add_all())  # 输出：0（传入0个参数，args为空元组）
# 示例2：**kwargs（接收任意数量的关键字参数，返回字典）def get_info(**kwargs):  # **kwargs 接收所有关键字实参，存储为字典    for key, value in kwargs.items():        print(f"{key}：{value}")# 调用：传入任意数量的关键字参数get_info(name="小明", age=20, hobby="Python")# 输出：# name：小明# age：20# hobby：Python
# 示例3：混合使用（位置参数+默认参数+可变参数，实战常用）def mix_params(name, age=18, *args, **kwargs):    print(f"姓名：{name}，年龄：{age}")    print("额外位置参数：", args)    print("额外关键字参数：", kwargs)# 调用：灵活传入各类参数mix_params("小明", 20, 175, "男", hobby="Python", height=175)# 输出：# 姓名：小明，年龄：20# 额外位置参数： (175, '男')# 额外关键字参数： {'hobby': 'Python', 'height': 175}

✅ 函数参数的核心规则

使用函数参数时，有几个核心规则必须遵守，否则会直接报错或导致函数执行异常，一定要记牢：

• 参数顺序：定义函数时，参数顺序必须遵循「位置参数 → 默认参数 → *args → **kwargs」，不可颠倒，否则会报错；

• 形实匹配：位置参数必须按顺序传入，实参数量与形参数量一致；关键字参数必须保证形参名正确，不可传入未定义的形参；

• 默认参数注意：默认参数的值只在函数定义时初始化一次，后续调用不会重新初始化（避免使用可变对象作为默认值）；

• 可变参数区分：*args接收位置参数（返回元组），**kwargs接收关键字参数（返回字典），二者可单独使用，也可结合使用，但*args必须在**kwargs前面。

# 规则示例（避坑重点）# 1. 参数顺序错误（错误）# def test(a, *args, b=10, **kwargs):  # 错误：默认参数在*args后面#     pass# 正确顺序：位置参数→默认参数→*args→**kwargsdef test(a, b=10, *args, **kwargs):    pass# 2. 默认参数使用可变对象（错误，易踩坑）def add_list(item, lst=[]):  # 错误：默认参数是可变对象（列表）    lst.append(item)    return lstprint(add_list(1))  # 输出：[1]print(add_list(2))  # 输出：[1, 2]（预期是[2]，因为默认参数未重新初始化）# 正确做法：默认参数用不可变对象，在函数内部初始化可变对象def add_list(item, lst=None):    if lst is None:        lst = []    lst.append(item)    return lstprint(add_list(1))  # 输出：[1]print(add_list(2))  # 输出：[2]（正确）# 3. 传入未定义的关键字参数（错误）def get_user_info(name, age):    pass# get_user_info(name="小明", age=20, gender="男")  # 错误：gender未在形参中定义

❌ 必避的4个参数使用坑

使用函数参数时，容易在参数顺序、默认参数、可变参数的使用上踩坑，这4个常见坑一定要避开，确保函数正常调用、逻辑正确：

• 坑1：参数顺序颠倒：定义函数时，默认参数放在位置参数前面、*args放在默认参数后面，或**kwargs放在*args前面，都会直接报错；

• 坑2：默认参数使用可变对象：用列表、字典等可变对象作为默认参数，会导致多次调用函数时，默认参数值被累积修改，出现逻辑异常；

• 坑3：关键字参数与位置参数顺序错误：调用函数时，关键字参数放在位置参数前面，会报错；

• 坑4：混淆*args与**kwargs的用法：用*args接收关键字参数、**kwargs接收位置参数，会导致参数无法正常接收，出现报错。

# 避坑示例（必看）# 坑1：参数顺序颠倒（错误）# def test(*args, a, b=10):  # 错误：*args在位置参数a前面#     pass# 正确做法def test(a, b=10, *args):    pass# 坑2：默认参数用可变对象（错误）def append_item(item, lst=[]):    lst.append(item)    return lst# 预期每次调用返回[item]，实际累积print(append_item(1))  # [1]print(append_item(2))  # [1,2]（错误）# 正确做法def append_item(item, lst=None):    if lst is None:        lst = []    lst.append(item)    return lst# 坑3：关键字参数在位置参数前面（错误）def get_info(name, age):    pass# get_info(age=20, "小明")  # 错误：关键字参数age在位置参数name前面# 正确做法get_info("小明", age=20)# 坑4：混淆*args与**kwargs（错误）def test(*args, **kwargs):    print(args, kwargs)# test(name="小明", age=20)  # 正确：**kwargs接收关键字参数，输出：() {'name': '小明', 'age': 20}# test(1, 2, name="小明")  # 正确：*args接收1、2，**kwargs接收name，输出：(1,2) {'name': '小明'}# test(*{"name": "小明", "age": 20})  # 错误：*args接收字典的键，不是关键字参数test(**{"name": "小明", "age": 20})  # 正确：**kwargs接收字典，等价于name="小明", age=20

📝 核心总结

• 参数核心：分为形参（定义时预留）和实参（调用时传入），二者需匹配，是函数灵活调用的关键；

• 4种类型：位置参数（必选、按顺序）、关键字参数（灵活、按名称）、默认参数（省时间、有默认值）、可变参数（不定长、*args/**kwargs）；

• 参数顺序：定义时遵循「位置参数→默认参数→*args→**kwargs」，调用时关键字参数需在位置参数后面；

• 避坑重点：不颠倒参数顺序、不使用可变对象作为默认参数、不混淆*args与**kwargs、保证形实匹配；

• 实战价值：灵活运用4种参数，能让函数更通用、更高效，适配不同的调用场景，后续学习复杂函数、类和项目，都离不开参数的灵活搭配。

函数的参数是函数的“灵活灵魂”，掌握不同类型参数的用法，就能摆脱固定逻辑的限制，写出更具扩展性、更易维护的代码。今天我们重点掌握4种核心参数的用法和避坑技巧，下一期我们将讲解函数的返回值、函数调用的进阶用法，以及实战中的参数搭配技巧。

✨ 小任务：定义一个函数，结合4种参数类型（位置参数、默认参数、*args、**kwargs），实现“批量处理用户信息”的功能，要求：接收用户名（位置参数）、默认年龄18（默认参数）、额外的用户标签（*args）、额外的用户配置（**kwargs），并打印所有用户信息。