跳转至

Python 函数

函数是组织代码的基本单位，可以提高代码的可重用性和可读性。本章将详细介绍 Python 函数的定义、参数、作用域和高级特性。

第一章：函数定义

（一）基本函数定义

函数语法： 

def function_name(parameters):
    """函数文档字符串"""
    # 函数体
    return value

简单函数示例： 

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

# 调用函数
greet()  # Hello, World!

带参数的函数： 

def greet(name):
    """向指定的人打招呼"""
    print(f"Hello, {name}!")

greet("张三")  # Hello, 张三!

带返回值的函数： 

def add(a, b):
    """返回两个数的和"""
    return a + b

result = add(3, 5)
print(result)  # 8

（二）参数类型

位置参数： 

def greet(name, greeting):
    """使用指定的问候语向某人打招呼"""
    return f"{greeting}, {name}!"

print(greet("张三", "Hello"))  # Hello, 张三!
print(greet("Hello", "张三"))  # 张三, Hello!

关键字参数： 

def greet(name, greeting):
    """使用指定的问候语向某人打招呼"""
    return f"{greeting}, {name}!"

print(greet(greeting="Hello", name="张三"))  # Hello, 张三!

默认参数： 

def greet(name, greeting="Hello"):
    """向某人打招呼，默认问候语为 Hello"""
    return f"{greeting}, {name}!"

print(greet("张三"))                    # Hello, 张三!
print(greet("张三", "Hi"))              # Hi, 张三!

可变参数（*args）： 

def sum_all(*args):
    """计算所有参数的和"""
    return sum(args)

print(sum_all(1, 2, 3, 4, 5))  # 15
print(sum_all(10, 20, 30))      # 60

关键字可变参数（kwargs）**： 

def print_info(**kwargs):
    """打印所有关键字参数"""
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="张三", age=20, city="北京")
# name: 张三
# age: 20
# city: 北京

参数组合： 

def complex_function(a, b, c=10, *args, **kwargs):
    """复杂的参数组合"""
    print(f"a: {a}")
    print(f"b: {b}")
    print(f"c: {c}")
    print(f"args: {args}")
    print(f"kwargs: {kwargs}")

complex_function(1, 2, 3, 4, 5, name="张三", age=20)
# a: 1
# b: 2
# c: 3
# args: (4, 5)
# kwargs: {'name': '张三', 'age': 20}

（三）函数文档字符串

文档字符串： 

def calculate_circle_area(radius):
    """
    计算圆的面积

    参数:
        radius (float): 圆的半径

    返回:
        float: 圆的面积

    示例:
        >>> calculate_circle_area(5)
        78.53981633974483
    """
    import math
    return math.pi * radius ** 2

# 访问文档字符串
print(calculate_circle_area.__doc__)

# 使用 help() 函数
help(calculate_circle_area)

第二章：函数作用域

（一）局部变量和全局变量

局部变量： 

def my_function():
    local_var = 10  # 局部变量
    print(f"函数内：{local_var}")

my_function()  # 函数内：10
# print(local_var)  # NameError: name 'local_var' is not defined

全局变量： 

global_var = 100  # 全局变量

def my_function():
    print(f"函数内访问全局变量：{global_var}")

my_function()  # 函数内访问全局变量：100
print(f"函数外访问全局变量：{global_var}")  # 函数外访问全局变量：100

在函数内修改全局变量： 

global_var = 100

def modify_global():
    global global_var  # 声明使用全局变量
    global_var = 200
    print(f"函数内修改后的全局变量：{global_var}")

modify_global()  # 函数内修改后的全局变量：200
print(f"函数外访问修改后的全局变量：{global_var}")  # 函数外访问修改后的全局变量：200

（二）嵌套函数

嵌套函数： 

def outer_function(x):
    """外部函数"""
    def inner_function(y):
        """内部函数"""
        return x + y

    return inner_function

# 调用外部函数
add_five = outer_function(5)
result = add_five(3)
print(result)  # 8

# 或者直接调用
result = outer_function(10)(5)
print(result)  # 15

闭包： 

def make_multiplier(factor):
    """创建一个乘法器函数"""
    def multiplier(number):
        return number * factor
    return multiplier

times_three = make_multiplier(3)
times_five = make_multiplier(5)

print(times_three(10))  # 30
print(times_five(10))   # 50

第三章：高级函数特性

（一）lambda 函数

lambda 函数语法： 

# lambda arguments: expression
square = lambda x: x ** 2
print(square(5))  # 25

# 多参数
add = lambda x, y: x + y
print(add(3, 5))  # 8

lambda 函数的应用： 

# 与内置函数结合使用
numbers = [1, 2, 3, 4, 5]

# map() 函数
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# filter() 函数
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4]

# sorted() 函数
students = [("张三", 20), ("李四", 18), ("王五", 22)]
sorted_students = sorted(students, key=lambda x: x[1])
print(sorted_students)  # [('李四', 18), ('张三', 20), ('王五', 22)]

（二）高阶函数

map() 函数： 

numbers = [1, 2, 3, 4, 5]

# 基本用法
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# 使用普通函数
def square(x):
    return x ** 2

squared = list(map(square, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# 多个可迭代对象
numbers1 = [1, 2, 3]
numbers2 = [4, 5, 6]
sums = list(map(lambda x, y: x + y, numbers1, numbers2))
print(sums)  # [5, 7, 9]

filter() 函数： 

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 基本用法
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4, 6, 8, 10]

# 使用普通函数
def is_even(x):
    return x % 2 == 0

evens = list(filter(is_even, numbers))
print(evens)  # [2, 4, 6, 8, 10]

reduce() 函数： 

from functools import reduce

numbers = [1, 2, 3, 4, 5]

# 计算乘积
product = reduce(lambda x, y: x * y, numbers)
print(product)  # 120

# 计算最大值
maximum = reduce(lambda x, y: x if x > y else y, numbers)
print(maximum)  # 5

（三）装饰器

装饰器概念： 装饰器是一个函数，它接受一个函数作为参数，并返回一个新的函数。

基本装饰器： 

def my_decorator(func):
    """装饰器函数"""
    def wrapper():
        print("函数执行前")
        func()
        print("函数执行后")
    return wrapper

@my_decorator
def say_hello():
    """被装饰的函数"""
    print("Hello!")

say_hello()
# 函数执行前
# Hello!
# 函数执行后

带参数的装饰器： 

def repeat(times):
    """重复执行函数的装饰器"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def greet(name):
    """问候函数"""
    print(f"Hello, {name}!")

greet("张三")
# Hello, 张三!
# Hello, 张三!
# Hello, 张三!

第四章：递归函数

（一）递归的基本概念

递归函数： 函数调用自身来解决问题的函数。

递归的要素： 1. 基准情况（终止条件） 2. 递归情况（调用自身）

示例：阶乘： 

def factorial(n):
    """计算阶乘"""
    if n <= 1:  # 基准情况
        return 1
    else:  # 递归情况
        return n * factorial(n - 1)

print(factorial(5))  # 120

示例：斐波那契数列： 

def fibonacci(n):
    """计算斐波那契数列的第 n 项"""
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(10))  # 55

（二）递归的优化

记忆化递归： 

from functools import lru_cache

@lru_cache(maxsize=None)  # 缓存所有结果
def fibonacci(n):
    """计算斐波那契数列的第 n 项（带缓存）"""
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(50))  # 12586269025（计算速度更快）

第五章：练习题目

基础练习

  1. 函数定义
  2. 编写一个函数，计算两个数的和、差、积、商
  3. 编写一个函数，判断一个数字是否为质数

  4. 编写一个函数，计算阶乘

  5. 参数类型

  6. 编写一个函数，使用位置参数和关键字参数
  7. 编写一个函数，使用默认参数

  8. 编写一个函数，使用可变参数

  9. 作用域

  10. 编写一个函数，演示局部变量和全局变量的区别
  11. 编写一个函数，演示如何在函数内修改全局变量
  12. 编写一个嵌套函数，演示闭包的概念

进阶练习

  1. 高级函数
  2. 使用 map() 函数处理列表
  3. 使用 filter() 函数筛选列表

  4. 使用 reduce() 函数计算列表元素的和

  5. 装饰器

  6. 编写一个简单的装饰器
  7. 编写一个带参数的装饰器

  8. 编写一个装饰器，测量函数执行时间

  9. 递归函数

  10. 编写递归函数计算阶乘
  11. 编写递归函数计算斐波那契数列
  12. 编写递归函数实现汉诺塔问题

竞赛练习

  1. 函数式编程
  2. 使用 lambda 函数和 map() 处理数据
  3. 使用 lambda 函数和 filter() 筛选数据

  4. 使用 lambda 函数和 reduce() 聚合数据

  5. 算法实现

  6. 实现递归版本的快速排序
  7. 实现递归版本的二分查找

  8. 实现递归版本的深度优先搜索

  9. 综合应用

  10. 实现一个简单的计算器（使用函数）
  11. 实现一个简单的密码生成器
  12. 实现一个简单的文本分析器

恭喜你完成了 Python 函数的学习！继续学习下一章，掌握更多 Python 知识！