编程马·菜鸟教程

Appearance

第11章：函数 ​

11.1 函数的核心概念 ​

函数是Python中非常重要的概念，它是将一段可复用的代码封装起来，需要时调用，减少冗余代码。函数就像一个黑盒，输入一些参数，经过内部处理，然后返回结果。

  • 函数的作用：
    • 代码复用：避免重复编写相同的代码
    • 模块化：将复杂的问题分解为小的、可管理的部分
    • 提高代码可读性：通过函数名清晰地表达代码的功能
    • 便于维护：修改函数内部实现不会影响其他代码

11.2 函数的定义与调用 ​

定义语法 ​

python
def 函数名(参数):
    # 函数体
    代码1
    代码2
    ...
    return 返回值

函数调用 ​

python
# 调用函数并获取返回值
结果 = 函数名(参数)

无参数函数 ​

无参数函数不需要传递参数，直接调用即可。

python
# 定义无参数函数
def print_hello():
    print("Hello, Python!")

# 调用无参数函数
print_hello()  # 输出：Hello, Python!

有参数函数 ​

有参数函数需要传递参数，实现灵活复用。

python
# 定义有参数函数
def add(a, b):
    return a + b

# 调用有参数函数
result = add(1, 2)
print(result)  # 输出：3

11.3 函数参数 ​

位置参数 ​

位置参数是最基本的参数类型，按参数顺序传递，必须传值且数量匹配。

python
def greet(name, age):
    print(f"你好，{name}！你今年{age}岁。")

# 按顺序传递参数
greet("张三", 18)  # 输出：你好，张三！你今年18岁。

关键字参数 ​

关键字参数按参数名传递，顺序可打乱。

python
def greet(name, age):
    print(f"你好，{name}！你今年{age}岁。")

# 使用关键字参数
greet(age=18, name="张三")  # 输出：你好，张三！你今年18岁。

默认参数 ​

默认参数在定义函数时给参数设置默认值，调用时可省略传递。

python
def greet(name, age=18):
    print(f"你好，{name}！你今年{age}岁。")

# 省略默认参数
greet("张三")  # 输出：你好，张三！你今年18岁。

# 覆盖默认参数
greet("李四", 20)  # 输出：你好，李四！你今年20岁。

不定长参数 ​

不定长参数用于处理不确定数量的参数。

  • *args：接收多个位置参数，返回一个元组
  • **kwargs：接收多个关键字参数，返回一个字典
python
# 处理多个位置参数
def sum_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_numbers(1, 2, 3, 4, 5))  # 输出：15

# 处理多个关键字参数
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="张三", age=18, gender="男")
# 输出：
# name: 张三
# age: 18
# gender: 男

11.4 函数返回值 ​

return语句 ​

return语句用于返回函数执行结果，可返回单个值、多个值（返回元组）。

python
# 返回单个值
def square(x):
    return x * x

print(square(5))  # 输出：25

# 返回多个值
def get_user_info():
    name = "张三"
    age = 18
    gender = "男"
    return name, age, gender

user_name, user_age, user_gender = get_user_info()
print(f"姓名：{user_name}，年龄：{user_age}，性别：{user_gender}")
# 输出：姓名：张三，年龄：18，性别：男

无return ​

如果函数没有return语句，默认返回None。

python
def print_message():
    print("Hello")

result = print_message()
print(result)  # 输出：None

11.5 函数嵌套 ​

函数嵌套是指在一个函数内部定义另一个函数，内部函数可以访问外部函数的变量。

python
def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

# 创建一个闭包
add_five = outer_function(5)
print(add_five(3))  # 输出：8

add_ten = outer_function(10)
print(add_ten(3))  # 输出：13

11.6 匿名函数（lambda函数） ​

Lambda函数是一种简洁的、匿名的函数，适用于简单的、只使用一次的场景。

语法 ​

python
lambda 参数: 表达式

示例 ​

python
# 定义lambda函数
add = lambda a, b: a + b
print(add(1, 2))  # 输出：3

# 在排序中使用lambda函数
students = [
    {"name": "张三", "score": 85},
    {"name": "李四", "score": 92},
    {"name": "王五", "score": 78}
]

# 按分数排序
students.sort(key=lambda student: student["score"])
print([student["name"] for student in students])  # 输出：['王五', '张三', '李四']

# 按分数降序排序
students.sort(key=lambda student: student["score"], reverse=True)
print([student["name"] for student in students])  # 输出：['李四', '张三', '王五']

实操案例：编写加法函数 ​

案例：加法函数 ​

python
"""
加法函数
功能：计算两个数的和
"""

# 定义加法函数
def add(a, b):
    """计算两个数的和"""
    return a + b

# 测试函数
print("1 + 2 =", add(1, 2))
print("3.5 + 4.5 =", add(3.5, 4.5))
print("'Hello' + ' World' =", add("Hello", " World"))

运行结果 ​

1 + 2 = 3
3.5 + 4.5 = 8.0
'Hello' + ' World' = Hello World

实操案例：求最大值函数 ​

案例：求最大值函数 ​

python
"""
求最大值函数
功能：求多个数中的最大值
"""

# 定义求最大值函数
def get_max(*numbers):
    """求多个数中的最大值"""
    if not numbers:
        return None
    max_num = numbers[0]
    for num in numbers[1:]:
        if num > max_num:
            max_num = num
    return max_num

# 测试函数
print("最大值：", get_max(1, 5, 3, 9, 2))
print("最大值：", get_max(10))
print("最大值：", get_max())

运行结果 ​

最大值： 9
最大值： 10
最大值： None

实操案例：用户信息查询函数 ​

案例：用户信息查询函数 ​

python
"""
用户信息查询函数
功能：根据用户ID查询用户信息
"""

# 用户数据
users = {
    "user1": {"name": "张三", "age": 18, "email": "zhangsan@example.com"},
    "user2": {"name": "李四", "age": 20, "email": "lisi@example.com"},
    "user3": {"name": "王五", "age": 22, "email": "wangwu@example.com"}
}

# 定义用户信息查询函数
def get_user_info(user_id, default=None):
    """根据用户ID查询用户信息"""
    return users.get(user_id, default)

# 测试函数
user1 = get_user_info("user1")
print("user1:", user1)

user4 = get_user_info("user4", {"name": "未知", "age": 0, "email": "未知"})
print("user4:", user4)

运行结果 ​

user1: {'name': '张三', 'age': 18, 'email': 'zhangsan@example.com'}
user4: {'name': '未知', 'age': 0, 'email': '未知'}

实操案例：lambda函数排序 ​

案例：lambda函数排序 ​

python
"""
lambda函数排序
功能：使用lambda函数对复杂数据结构进行排序
"""

# 商品数据
products = [
    {"name": "手机", "price": 3999, "sales": 10000},
    {"name": "电脑", "price": 5999, "sales": 5000},
    {"name": "平板", "price": 2999, "sales": 8000},
    {"name": "手表", "price": 1999, "sales": 15000}
]

print("原始数据：")
for product in products:
    print(product)

# 按价格排序
products.sort(key=lambda p: p["price"])
print("\n按价格排序：")
for product in products:
    print(product)

# 按销量排序
products.sort(key=lambda p: p["sales"], reverse=True)
print("\n按销量排序：")
for product in products:
    print(product)

运行结果 ​

原始数据：
{'name': '手机', 'price': 3999, 'sales': 10000}
{'name': '电脑', 'price': 5999, 'sales': 5000}
{'name': '平板', 'price': 2999, 'sales': 8000}
{'name': '手表', 'price': 1999, 'sales': 15000}

按价格排序：
{'name': '手表', 'price': 1999, 'sales': 15000}
{'name': '平板', 'price': 2999, 'sales': 8000}
{'name': '手机', 'price': 3999, 'sales': 10000}
{'name': '电脑', 'price': 5999, 'sales': 5000}

按销量排序：
{'name': '手表', 'price': 1999, 'sales': 15000}
{'name': '手机', 'price': 3999, 'sales': 10000}
{'name': '平板', 'price': 2999, 'sales': 8000}
{'name': '电脑', 'price': 5999, 'sales': 5000}

新手易错点 ​

  • 函数参数数量不匹配：调用函数时参数数量与定义不匹配

    python
    def add(a, b):
    return a + b

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

# 错误：参数数量过多
add(1, 2, 3)  # 错误：add() takes 2 positional arguments but 3 were given

  • return语句位置错误：return语句放在了循环内部，导致函数提前返回

    python
    def sum_numbers(numbers):
    total = 0
    for num in numbers:
        total += num
        return total  # 错误：放在循环内部，只计算第一个数

print(sum_numbers([1, 2, 3, 4, 5]))  # 输出：1

  • 匿名函数表达式过于复杂：lambda函数只适合简单的表达式

    python
    # 错误：lambda函数过于复杂
complex_func = lambda x: (x * 2 + 1) if x > 0 else (x * 3 - 1) if x < 0 else 0

# 正确：对于复杂逻辑，使用普通函数
def complex_func(x):
    if x > 0:
        return x * 2 + 1
    elif x < 0:
        return x * 3 - 1
    else:
        return 0

通过本章的学习，你已经掌握了Python中函数的基本概念和使用方法。函数是Python编程的核心，它可以帮助你组织代码、提高代码复用性和可读性。在实际编程中，你会大量使用函数来构建复杂的应用程序。

© 2026 编程马·菜鸟教程 版权所有

基于 VitePress 构建