深入浅出 Python 函数：从基础概念到高级应用

函数是编程世界的基石，也是 Python 中最核心的概念之一。无论是简单的数值计算，还是复杂的业务逻辑封装，函数都能让你的代码更具可读性、复用性和可维护性。本文将从基础概念出发，逐步深入，带你全面掌握 Python 函数的方方面面。

一、函数概念

你可以把函数理解为一个具有特定功能的代码块，它就像一个工厂：接收原材料（输入参数），经过内部加工处理，最后产出产品（返回值）。在 Python 中，函数是组织好的、可重复使用的、用来实现单一或相关联功能的代码段。

函数的本质是代码的封装，它将一段完成特定任务的代码抽象出来，赋予一个名字，让我们可以在需要的时候随时调用，而无需重复编写相同的代码。

二、函数目的

使用函数主要有以下几个核心目的：

三、函数声明

在 Python 中，使用def关键字来声明（定义）函数，基本语法如下：

def 函数名(参数列表):
"""函数文档字符串（可选）：描述函数功能、参数、返回值等"""
# 函数体（要执行的代码）
代码逻辑
[return 返回值] # 可选

基础示例：

# 定义一个计算两数之和的函数
def add_numbers(a, b):
"""
计算两个数字的和

参数:
a — 第一个数字
b — 第二个数字

返回:
两个数字的和
"""
result = a + b
return result

关键说明：

• def：定义函数的关键字，必须以这个开头
• 函数名：遵循标识符命名规则（字母、数字、下划线，不能以数字开头），建议使用小写 + 下划线的形式（snake_case）
• 参数列表：括号内的变量，接收外部传入的数据
• 冒号：函数定义结束的标志
• 函数体：缩进的代码块（通常 4 个空格），实现具体功能
• 文档字符串：可选但推荐，用于说明函数功能，可通过函数名.__doc__查看

四、函数调用

定义函数只是声明了一段功能代码，只有调用函数时，这段代码才会真正执行。调用函数的语法非常简单：

函数名(参数值列表)

例子:

# 调用上面定义的add_numbers函数
sum_result = add_numbers(5, 3)
print(f"5 + 3 = {sum_result}") # 输出：5 + 3 = 8

# 多次调用
print(add_numbers(10, 20)) # 输出：30
print(add_numbers(-5, 7)) # 输出：2

调用过程说明：

五、函数形参

形参（形式参数）是函数定义时括号内声明的变量，它是函数接收数据的 “接口”。Python 支持多种形式的形参：

1. 位置形参

最基础的形参，调用时按位置顺序传递参数：

def print_info(name, age):
print(f"姓名：{name}，年龄：{age}")

print_info("张三", 25) # 姓名：张三，年龄：25

2. 默认参数

为形参指定默认值，调用时如果不传递该参数，就使用默认值：

def print_info(name, age=18):
print(f"姓名：{name}，年龄：{age}")

print_info("李四") # 姓名：李四，年龄：18
print_info("王五", 30) # 姓名：王五，年龄：30

注意：默认参数必须放在位置参数之后

3. 关键字参数（形参角度）

调用时可以通过参数名指定传递的值，顺序可以任意：

print_info(age=28, name="赵六") # 姓名：赵六，年龄：28

4. 可变长度参数

经典示例：计算阶乘

• *args：接收任意数量的位置参数，打包成元组
• **kwargs：接收任意数量的关键字参数，打包成字典

• def sum_all(*args):
  """计算任意多个数字的和"""
  total = 0
  for num in args:
  total += num
  return total

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

  print(sum_all(1, 2, 3)) # 输出：6
  print(sum_all(10, 20, 30, 40)) # 输出：100

  print_kwargs(name="小明", age=20, city="北京")
  # 输出：
  # name: 小明
  # age: 20
  # city: 北京

  六、函数实参

  实参（实际参数）是调用函数时传递给形参的具体值。实参的类型可以是任意 Python 对象：数字、字符串、列表、字典，甚至是另一个函数。

  实参传递方式

• 位置实参：按形参定义的顺序传递

• add_numbers(5, 3) # 5和3是位置实参

  关键字实参：通过形参名传递，顺序无关

• add_numbers(b=3, a=5) # b和a是关键字实参

  混合传递：位置实参在前，关键字实参在后

• add_numbers(5, b=3) # 合法
  # add_numbers(a=5, 3) # 非法，会报错

  实参解包

  可以将列表、元组、字典解包后作为实参传递：

• nums = [5, 3]
  print(add_numbers(*nums)) # 列表解包，输出：8

  num_dict = {"a": 5, "b": 3}
  print(add_numbers(**num_dict)) # 字典解包，输出：8

  七、函数返回值

  函数执行完成后，可以通过return语句将结果返回给调用者。

  基本用法

• def multiply(a, b):
  return a * b # 返回乘积

  result = multiply(4, 5)
  print(result) # 输出：20

  多个返回值

  Python 支持返回多个值（本质是返回一个元组）：

• def calculate(a, b):
  sum_val = a + b
  diff_val = a – b
  mul_val = a * b
  div_val = a / b if b != 0 else None
  return sum_val, diff_val, mul_val, div_val

  # 接收多个返回值
  sum_r, diff_r, mul_r, div_r = calculate(10, 2)
  print(f"和：{sum_r}，差：{diff_r}，积：{mul_r}，商：{div_r}")
  # 输出：和：12，差：8，积：20，商：5.0

  无返回值

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

• def print_hello():
  print("Hello, Python!")

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

  八、递归函数

  递归函数是指在函数内部调用自身的函数。递归需要满足两个核心条件：

• 基线条件：递归的终止条件，避免无限递归
• 递归条件：函数调用自身，逐步接近基线条件

def factorial(n):
"""
递归计算n的阶乘
n! = n * (n-1) * (n-2) * … * 1
"""
# 基线条件：0! 和 1! 都等于1
if n == 0 or n == 1:
return 1
# 递归条件：n! = n * (n-1)!
else:
return n * factorial(n – 1)

# 测试
print(factorial(5)) # 输出：120 (5*4*3*2*1)
print(factorial(0)) # 输出：1
print(factorial(10)) # 输出：3628800

递归的优缺点

• 优点：代码简洁，逻辑清晰，适合解决分治类问题（如树形结构、阶乘、斐波那契数列等）
• 缺点：递归深度有限（Python 默认递归深度约 1000），且递归调用会占用额外的栈空间，效率略低

九、匿名函数

匿名函数（也叫 lambda 函数）是使用lambda关键字定义的简洁函数，没有函数名，适用于简单的功能场景。

语法

lambda 参数列表: 表达式

例子:

# 定义一个计算两数之和的匿名函数
add = lambda a, b: a + b
print(add(5, 3)) # 输出：8

# 结合内置函数使用（最常见场景）
nums = [1, 2, 3, 4, 5]
# 计算每个数的平方
squares = list(map(lambda x: x**2, nums))
print(squares) # 输出：[1, 4, 9, 16, 25]

# 筛选偶数
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens) # 输出：[2, 4]

特点

• 只能包含一个表达式，不能有复杂的逻辑（如循环、条件语句）
• 表达式的结果就是返回值，无需写return
• 适合定义简单、临时使用的函数
• 常与map()、filter()、sorted()等函数配合使用

十、闭包与装饰器

1. 闭包

闭包是指嵌套函数中，内部函数引用了外部函数的变量，并且外部函数返回内部函数。闭包可以保留外部函数的变量环境，即使外部函数已经执行完毕。

def outer_func(msg):
# 外部函数变量
message = msg

def inner_func():
# 内部函数引用外部函数的变量
print(message)

# 返回内部函数（不调用）
return inner_func

# 创建闭包实例
hello_func = outer_func("Hello, Closure!")
hi_func = outer_func("Hi, Python!")

# 调用闭包
hello_func() # 输出：Hello, Closure!
hi_func() # 输出：Hi, Python!

2. 装饰器

装饰器是闭包的高级应用，用于在不修改原函数代码的前提下，为函数添加额外功能（如日志、计时、权限验证等）。

基础装饰器示例

import time

# 定义装饰器函数
def timer_decorator(func):
"""计算函数执行时间的装饰器"""
def wrapper(*args, **kwargs):
# 执行前：记录开始时间
start_time = time.time()
# 执行原函数
result = func(*args, **kwargs)
# 执行后：计算耗时
end_time = time.time()
print(f"函数 {func.__name__} 执行耗时：{end_time – start_time:.6f} 秒")
# 返回原函数的结果
return result
return wrapper

# 使用装饰器
@timer_decorator
def slow_function(seconds):
"""模拟耗时函数"""
time.sleep(seconds)
print("耗时函数执行完成")

# 调用被装饰的函数
slow_function(2)
# 输出：
# 耗时函数执行完成
# 函数 slow_function 执行耗时：2.002145 秒

装饰器叠加

可以为一个函数添加多个装饰器：

def log_decorator(func):
"""记录函数调用日志的装饰器"""
def wrapper(*args, **kwargs):
print(f"调用函数 {func.__name__}，参数：{args}, {kwargs}")
result = func(*args, **kwargs)
print(f"函数 {func.__name__} 执行完成，返回值：{result}")
return result
return wrapper

# 叠加装饰器（执行顺序：从上到下装饰，从下到上执行）
@log_decorator
@timer_decorator
def add(a, b):
return a + b

add(5, 3)
# 输出：
# 调用函数 wrapper，参数：(5, 3), {}
# 函数 add 执行耗时：0.000001 秒
# 函数 wrapper 执行完成，返回值：8

十一、系统内置函数

Python 提供了大量内置函数，无需导入模块即可直接使用，这些函数覆盖了常用的基础功能：

常用内置函数列表

内置函数示例

# 基础内置函数
print(len("Python")) # 输出：6
print(type(123)) # 输出：<class 'int'>
print(max([1, 5, 3, 9, 2])) # 输出：9
print(sum(range(1, 11))) # 输出：55（1到10的和）

# 高级内置函数
nums = [10, 5, 8, 3]
# 排序
print(sorted(nums)) # 输出：[3, 5, 8, 10]
# 带索引遍历
for idx, num in enumerate(nums):
print(f"索引 {idx}：{num}")
# 打包多个列表
names = ["张三", "李四", "王五"]
scores = [90, 85, 95]
for name, score in zip(names, scores):
print(f"{name}：{score}分")

总结

掌握函数的这些知识点，能让你写出更简洁、高效、可维护的 Python 代码，也是进阶学习面向对象编程、框架开发等内容的重要基础。