跳到主要内容

Python 函数基础

什么是函数？​

函数是组织好的、可重复使用的、用来实现单一或相关联功能的代码块。在Python中，函数是一等公民，这意味着函数可以被赋值给变量，可以作为参数传递，也可以作为返回值返回。

提示

函数的核心优势：代码复用、提高可读性、便于维护

为什么需要函数？​

想象一下，如果你需要在程序的多个地方执行同样的操作：

python
# 不使用函数的情况
print("计算第一组数据...")
result1 = (10 + 20) * 3 - 5
print(f"结果是: {result1}")

print("计算第二组数据...")
result2 = (15 + 25) * 3 - 5
print(f"结果是: {result2}")

print("计算第三组数据...")
result3 = (30 + 40) * 3 - 5
print(f"结果是: {result3}")

使用函数后，代码会变得更加简洁和易于维护：

python
# 使用函数的情况
def calculate(a, b):
    print(f"计算 {a} 和 {b} 的数据...")
    result = (a + b) * 3 - 5
    print(f"结果是: {result}")
    return result

result1 = calculate(10, 20)  # 结果是: 85
result2 = calculate(15, 25)  # 结果是: 115
result3 = calculate(30, 40)  # 结果是: 205

函数的定义与调用​

定义函数​

在Python中，定义函数使用def关键字，后跟函数名和括号内的参数列表：

python
def 函数名(参数1, 参数2, ...):
    """文档字符串（Docstring）：描述函数的功能"""
    # 函数体
    return 返回值  # 可选

调用函数​

调用函数只需使用函数名后跟括号，并在括号中传入所需的参数：

python
函数名(参数1值, 参数2值, ...)

实例：简单的问候函数​

python
def greet(name):
    """向指定的人打招呼"""
    return f"你好，{name}！"

# 调用函数
message = greet("小明")
print(message)  # 输出: 你好，小明！

函数参数​

Python函数的参数系统非常灵活，提供了多种参数类型。

1. 位置参数​

最基本的参数传递方式，按照定义顺序传递参数：

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

result = add(3, 5)  # a=3, b=5
print(result)  # 输出: 8

2. 关键字参数​

使用参数名指定参数，这样可以不按顺序传递参数：

python
def describe_person(name, age):
    return f"{name}今年{age}岁"

# 使用关键字参数，顺序可以不同
result1 = describe_person(age=25, name="小红")
print(result1)  # 输出: 小红今年25岁

3. 默认参数​

为参数提供默认值，如果调用时未提供该参数，则使用默认值：

python
def greet(name, greeting="你好"):
    return f"{greeting}，{name}！"

print(greet("小明"))  # 输出: 你好，小明！
print(greet("小红", "早上好"))  # 输出: 早上好，小红！
警告

默认参数必须放在非默认参数后面，否则会导致语法错误。

4. 可变长度参数 (*args)​

使用*args允许函数接收任意数量的位置参数：

python
def sum_all(*numbers):
    """计算所有传入数字的和"""
    total = 0
    for num in numbers:
        total += num
    return total

print(sum_all(1, 2, 3))  # 输出: 6
print(sum_all(1, 2, 3, 4, 5))  # 输出: 15

5. 可变关键字参数 (**kwargs)​

使用**kwargs允许函数接收任意数量的关键字参数：

python
def print_info(**info):
    """打印所有传入的信息"""
    for key, value in info.items():
        print(f"{key}: {value}")

print_info(name="小明", age=18, city="北京")
# 输出:
# name: 小明
# age: 18
# city: 北京

返回值​

函数可以通过return语句返回值。如果没有显式地return，Python函数默认返回None。

单一返回值​

python
def square(x):
    """返回x的平方"""
    return x ** 2

result = square(4)
print(result)  # 输出: 16

多个返回值​

Python函数可以返回多个值，实际上是返回了一个元组：

python
def get_dimensions(width, height):
    """返回面积和周长"""
    area = width * height
    perimeter = 2 * (width + height)
    return area, perimeter

area, perimeter = get_dimensions(5, 3)
print(f"面积: {area}, 周长: {perimeter}")  # 输出: 面积: 15, 周长: 16

函数作用域和变量​

Python函数有自己的作用域，在函数内声明的变量称为局部变量。

python
def test_scope():
    local_var = 100  # 局部变量
    print(local_var)

test_scope()  # 输出: 100
# print(local_var)  # 会产生错误，因为local_var只在函数内部可见

如果要在函数内部修改全局变量，需要使用global关键字：

python
count = 0  # 全局变量

def increment():
    global count
    count += 1
    print(count)

increment()  # 输出: 1
increment()  # 输出: 2
print(count)  # 输出: 2

函数的实际应用案例​

案例1：温度转换器​

python
def celsius_to_fahrenheit(celsius):
    """将摄氏度转换为华氏度"""
    return (celsius * 9/5) + 32

def fahrenheit_to_celsius(fahrenheit):
    """将华氏度转换为摄氏度"""
    return (fahrenheit - 32) * 5/9

# 使用函数
celsius = 25
fahrenheit = celsius_to_fahrenheit(celsius)
print(f"{celsius}°C = {fahrenheit:.1f}°F")  # 输出: 25°C = 77.0°F

fahrenheit = 98.6
celsius = fahrenheit_to_celsius(fahrenheit)
print(f"{fahrenheit}°F = {celsius:.1f}°C")  # 输出: 98.6°F = 37.0°C

案例2：简易计算器​

python
def calculator(num1, num2, operator='+'):
    """简易计算器函数
    
    参数:
        num1: 第一个数字
        num2: 第二个数字
        operator: 操作符，默认为'+'
    
    返回:
        计算结果
    """
    if operator == '+':
        return num1 + num2
    elif operator == '-':
        return num1 - num2
    elif operator == '*':
        return num1 * num2
    elif operator == '/':
        if num2 == 0:
            return "错误：除数不能为零"
        return num1 / num2
    else:
        return "不支持的操作符"

# 测试计算器函数
print(calculator(10, 5, '+'))  # 输出: 15
print(calculator(10, 5, '-'))  # 输出: 5
print(calculator(10, 5, '*'))  # 输出: 50
print(calculator(10, 5, '/'))  # 输出: 2.0
print(calculator(10, 0, '/'))  # 输出: 错误：除数不能为零

案例3：生成斐波那契数列​

python
def fibonacci(n):
    """生成斐波那契数列的前n项
    
    参数:
        n: 项数
        
    返回:
        包含斐波那契数列前n项的列表
    """
    fib_list = [0, 1]
    
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return fib_list
    
    for i in range(2, n):
        next_num = fib_list[i-1] + fib_list[i-2]
        fib_list.append(next_num)
    
    return fib_list

# 生成斐波那契数列的前10项
fib_sequence = fibonacci(10)
print(fib_sequence)  # 输出: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

函数文档（Docstring）​

编写良好的函数应该包含文档字符串（Docstring），它描述了函数的功能、参数和返回值，使用三重引号包围：

python
def calculate_average(numbers):
    """
    计算数字列表的平均值
    
    参数:
        numbers (list): 包含数字的列表
        
    返回:
        float: 列表中数字的平均值
        
    异常:
        ZeroDivisionError: 如果列表为空
    """
    return sum(numbers) / len(numbers)

# 可以通过help()函数或__doc__属性访问文档
print(calculate_average.__doc__)
# 或者
help(calculate_average)

匿名函数（Lambda函数）​

Lambda函数是一种小型匿名函数，用于创建简单的、一次性使用的函数：

python
# 常规函数
def square(x):
    return x ** 2

# 等效的lambda函数
square_lambda = lambda x: x ** 2

print(square(5))       # 输出: 25
print(square_lambda(5))  # 输出: 25

# Lambda函数常用于简单的排序或过滤操作
numbers = [1, 5, 3, 9, 2]
sorted_numbers = sorted(numbers, key=lambda x: x)
print(sorted_numbers)  # 输出: [1, 2, 3, 5, 9]

# 使用lambda和filter函数过滤偶数
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)    # 输出: [2]
备注

Lambda函数主要用于需要一个简短函数的场景，尤其是当函数作为参数传递时。对于复杂的逻辑，还是应该使用常规函数。

总结​

函数是Python编程中最基本也是最强大的概念之一。通过合理使用函数，可以：

  1. 提高代码复用性：避免重复编写相同的代码
  2. 提高可读性：通过有意义的函数名使代码更易理解
  3. 模块化设计：将复杂问题分解为更小、更易管理的部分
  4. 增强可维护性：修改功能只需修改函数内部代码

掌握函数的定义和使用是成为熟练Python开发者的重要一步。

练习题​

为了巩固您对Python函数的理解，尝试完成以下练习：

  1. 编写一个函数，接收一个列表作为参数，返回列表中的最大值和最小值。
  2. 创建一个函数，计算给定数字的阶乘。
  3. 编写一个函数，检查给定的字符串是否是回文（正着读和倒着读一样）。
  4. 实现一个函数，接收任意数量的数字，返回它们的平均值。
  5. 创建一个函数，生成指定范围内的所有质数。

额外资源​

要深入学习Python函数，请考虑查阅以下资源：

  • Python官方文档中的函数部分
  • 参考第三方教程和书籍中关于Python函数的进阶内容
  • 尝试解决实际编程问题，培养使用函数解决问题的思维方式