Python 函数详解

原创于 2025-12-03 17:23:13 发布 · 604 阅读

24 ·

CC 4.0 BY-SA版权

文章标签：

#函数 #Python #编程语言

零基础学Python 专栏收录该内容

4 篇文章

订阅专栏

1. 什么是函数？

函数是组织好的、可重复使用的、用于实现单一或相关联功能的代码段。它能提高代码的复用性和可维护性。

2. 函数的定义

使用 def 关键字定义函数：

def 函数名(参数列表):
    """可选的文档字符串（docstring）"""
    函数体
    return 返回值

示例：

def greet(name):
    """向用户问好"""
    print(f"Hello, {name}!")
    return "已问好"

3. 函数的调用

调用函数时只需写函数名并传入参数：

greet("Alice")

4. 参数类型

4.1 位置参数

按顺序传递：

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

add(2, 3)  # 返回 5

4.2 默认参数

设置默认值：

def greet(name, message="Hello"):
    print(f"{message}, {name}!")

greet("Bob")           # 输出 Hello, Bob!
greet("Bob", "Hi")     # 输出 Hi, Bob!

4.3 可变参数

*args（可变位置参数）

def sum_all(*args):
    return sum(args)

sum_all(1, 2, 3, 4)  # 返回 10

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

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Tom", age=20)

4.4 关键字参数

使用参数名传递：

def student(name, age):
    print(name, age)

student(age=18, name="Lucy")

5. 返回值

使用 return 返回一个或多个值：

def min_max(nums):
    return min(nums), max(nums)

a, b = min_max([1, 2, 3, 4])
print(a, b)  # 输出 1 4

6. 变量作用域

局部变量：函数内部定义，只在函数内部有效。
全局变量：函数外部定义，整个文件都能访问。

x = 10  # 全局变量

def foo():
    y = 5  # 局部变量
    print(x, y)

global关键字 用于在函数内部修改全局变量：

count = 0

def increment():
    global count
    count += 1

7. 匿名函数（lambda）

简洁地定义简单函数：

f = lambda x, y: x + y
print(f(2, 3))  # 输出 5

常用于排序、映射等场景：

data = [("Tom", 20), ("Jerry", 18)]
data.sort(key=lambda x: x[1])

8. 文档字符串（docstring）

用于描述函数功能，便于自动化文档工具读取：

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

print(add.__doc__)

9. 内置函数与高阶函数

Python 提供了许多内置函数，如 len(), max(), map(), filter(), sorted() 等。

高阶函数：可以接收函数作为参数或返回函数。

def apply(func, value):
    return func(value)

print(apply(abs, -5))  # 输出 5

10. 函数注解（类型提示）

Python3 支持类型提示：

def add(a: int, b: int) -> int:
    return a + b

11. 函数嵌套与闭包

11.1 嵌套函数

函数内部还可以定义函数：

def outer():
    print("这是外部函数")
    def inner():
        print("这是内部函数")
    inner()
outer()

11.2 闭包（Closure）

闭包是指“函数内部的函数”引用了外部函数的变量，并且外部函数已经返回。

def make_multiplier(n):
    def multiplier(x):
        return x * n
    return multiplier

times3 = make_multiplier(3)
print(times3(10))  # 输出 30

12. 装饰器（Decorator）

装饰器用于在不修改原函数代码的情况下，增加额外功能。常见场景如日志、权限校验、性能统计等。

12.1 基本装饰器

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("函数开始执行")
        result = func(*args, **kwargs)
        print("函数执行结束")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello, {name}")

say_hello("Alice")

12.2 带参数的装饰器

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def greet():
    print("Hi!")

greet()  # 输出3次 Hi!

13. 递归函数

递归是函数调用自身的编程技巧。

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))  # 输出 120

注意递归要有终止条件，否则会导致无限递归。

14. 函数作为对象

在 Python 中，函数也是对象，可以赋值给变量、作为参数传递、作为返回值。

def shout(text):
    return text.upper()

def whisper(text):
    return text.lower()

def greet(func):
    print(func("Hello"))

greet(shout)   # 输出 HELLO
greet(whisper) # 输出 hello

15. 常见内置高阶函数

15.1 map

对序列的每个元素应用函数：

nums = [1, 2, 3]
squared = list(map(lambda x: x**2, nums))
print(squared)  # [1, 4, 9]

15.2 filter

筛选序列：

nums = [1, 2, 3, 4, 5]
even = list(filter(lambda x: x % 2 == 0, nums))
print(even)  # [2, 4]

15.3 reduce

需要 functools 模块。对序列进行累积操作：

from functools import reduce

nums = [1, 2, 3, 4]
product = reduce(lambda x, y: x * y, nums)
print(product)  # 24

16. 参数解包

16.1 序列解包

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

nums = [1, 2, 3]
print(add(*nums))  # 6

16.2 字典解包

def show_info(name, age):
    print(f"{name} is {age} years old.")

info = {'name': 'Tom', 'age': 18}
show_info(**info)

17. 可变对象与不可变对象作为参数

不可变对象（如 int, str, tuple）：函数内部修改不会影响外部。
可变对象（如 list, dict）：函数内部修改会影响外部。

def modify_list(lst):
    lst.append(100)

my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)  # [1, 2, 3, 100]

18. 函数的文档和注释

良好的文档和注释可以帮助他人理解你的函数。

def area_of_circle(r):
    """
    计算圆的面积。
    参数:
        r (float): 半径
    返回:
        float: 面积
    """
    import math
    return math.pi * r ** 2

19. 函数的返回类型

函数可以返回任何类型的对象，包括列表、字典、函数、类实例等。

def get_ops():
    def add(x, y): return x + y
    def sub(x, y): return x - y
    return add, sub

a, s = get_ops()
print(a(2, 3), s(5, 2))  # 5 3

20. 建议

函数是 Python 编程的核心，建议多用函数组织代码。
合理使用参数类型和装饰器能让代码更灵活。
熟练掌握高阶函数、匿名函数、闭包等能提升编程能力。
写好文档和注释，方便维护和协作。

21. 函数的类型注解与静态检查

类型注解可以让代码更易读，也方便使用工具进行类型检查（如 mypy）。

def greeting(name: str) -> str:
    return f"Hello, {name}"

def add(x: int, y: int) -> int:
    return x + y

你可以用第三方工具对类型进行静态检查：

mypy your_script.py

22. 函数的多返回值与解包技巧

Python 函数可以同时返回多个值（以元组形式返回），调用时可以直接解包：

def get_min_max(nums):
    return min(nums), max(nums)

low, high = get_min_max([1, 8, 4, 2])
print(low, high)  # 1 8

甚至可以用星号 * 进行部分解包：

def f():
    return 1, 2, 3, 4

a, *b, c = f()
print(a, b, c)  # 1 [2, 3] 4

23. 函数的柯里化（Currying）

柯里化是将多参数函数转化为一系列单参数函数的技术。Python 可以用嵌套函数和 functools.partial 实现。

def multiply(x):
    def inner(y):
        return x * y
    return inner

double = multiply(2)
print(double(5))  # 10

24. 偏函数（Partial Function）

functools.partial 可以为函数预设部分参数，生成新的函数。

from functools import partial

def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
print(square(5))  # 25

25. 递归优化（尾递归和循环替代）

Python 没有原生的尾递归优化，因此深度递归容易导致栈溢出。可以用循环或辅助参数代替递归。

普通递归：

def fib(n):
    if n <= 2:
        return 1
    return fib(n-1) + fib(n-2)

循环优化：

def fib_iter(n):
    a, b = 1, 1
    for _ in range(n-2):
        a, b = b, a + b
    return b

26. 常见函数设计模式与最佳实践

单一职责原则：一个函数只做一件事，名字要能准确描述其功能。
函数长度适中：过长的函数应拆分为多个小函数。
参数数量控制：参数过多建议用字典或数据类封装。
文档与注释：每个函数写清楚用途、参数和返回值。
异常处理：合理使用 try/except，避免程序崩溃。

27. 函数的错误处理

用 try/except 捕获异常，提升健壮性。

def divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("除数不能为0")
        return None

可以自定义异常：

class MyError(Exception):
    pass

def test(x):
    if x < 0:
        raise MyError("x不能为负数")

28. 函数的性能优化建议

避免不必要的递归，能用循环就用循环。
缓存结果：如斐波那契数列用 functools.lru_cache 缓存结果。

from functools import lru_cache

@lru_cache(maxsize=128)
def fib(n):
    if n <= 2:
        return 1
    return fib(n-1) + fib(n-2)

合理拆分函数，提高复用率。
减少全局变量依赖，提升函数的可测试性。

29. 函数的实际应用场景举例

数据处理：数据清洗、转换、统计等
Web开发：视图函数、路由处理
自动化脚本：批量处理文件、数据分析
科学计算：数学建模、算法实现
系统工具：日志收集、监控、运维

总结

Python 函数是编程中非常重要的组成部分，通过合理使用参数、返回值、匿名函数等特性，可以让代码更加简洁、模块化和易于维护。