一、函数的基本结构（图解）

Python 函数由「定义部分」和「调用部分」组成，定义用 def 关键字，调用通过「函数名 +()」触发。

1. 函数定义的核心结构

plaintext

展开 

代码语言：TXT

自动换行

AI代码解释

def 函数名(参数1, 参数2, ...):
    """文档字符串（可选，说明函数功能）"""
    函数体（要执行的代码逻辑）
    return 返回值（可选，无return则返回None）

# 图解各部分含义
┌─────────┬─────────────────────────────────────────┐
│ 部分     │ 说明                                   │
├─────────┼─────────────────────────────────────────┤
│ def     │ 定义函数的关键字（固定）                 │
│ 函数名   │ 符合Python命名规范的标识符（如get_sum）  │
│ 参数     │ 函数的输入（可选，可无参数）             │
│ 文档字符串│ 函数说明（用help(函数名)可查看）        │
│ 函数体   │ 核心逻辑（缩进代码块）                  │
│ return   │ 函数的输出（可选，结束函数执行）        │
└─────────┴─────────────────────────────────────────┘

2. 函数定义与调用的流程图解

以「计算两数之和」的函数为例：
plaintext

展开 

代码语言：TXT

自动换行

AI代码解释

# 定义阶段（仅封装逻辑，不执行）
def get_sum(a, b):
    """计算两个数的和"""
    result = a + b
    return result

# 调用阶段（触发函数执行，传递参数，接收返回值）
total = get_sum(3, 5)

# 执行流程图解
1. 调用get_sum(3,5) → 程序跳转到函数定义处
2. 形参a接收3，形参b接收5（参数绑定）
3. 执行函数体：计算3+5=8，赋值给result
4. return result → 将8返回给调用处
5. 调用处将返回值8赋值给变量total

代码验证：

python

运行

展开 

代码语言：TXT

自动换行

AI代码解释

# 定义函数
def get_sum(a, b):
    """计算两个数的和"""
    result = a + b
    return result

# 调用函数
total = get_sum(3, 5)
print("两数之和：", total)  # 输出：8
print("函数说明：", get_sum.__doc__)  # 输出：计算两个数的和
help(get_sum)  # 终端会显示函数的文档字符串

二、函数的参数（核心图解 + 代码）

参数是函数的「输入接口」，Python 支持多种参数类型，核心分为「形参（定义时）」和「实参（调用时）」。

1. 形参 vs 实参（图解）

plaintext

展开 

代码语言：TXT

自动换行

AI代码解释

def get_sum(a, b):  # a、b是形参（形式参数，定义时的占位符）
    return a + b

total = get_sum(3, 5)  # 3、5是实参（实际参数，调用时传递的具体值）

# 绑定关系图解
形参 a ←── 接收 ←── 实参 3
形参 b ←── 接收 ←── 实参 5

2. 四种参数类型（图解 + 代码）

参数类型	定义方式	调用方式	核心特点
位置参数	def f(a, b):	f(1, 2)	按顺序传递，一一对应
关键字参数	-	f(b=2, a=1)	按参数名传递，顺序可打乱
默认参数	def f(a, b=10):	f(5) 或 f(5, 20)	调用时可省略，使用默认值
可变参数	def f(*args, **kwargs):	f(1,2,3, name="Tom")	接收任意数量的位置 / 关键字参数

（1）位置参数（最基础）

图解传递逻辑：
plaintext

代码语言：TXT

自动换行

AI代码解释

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

print_info("Alice", 20)
# 位置绑定：name→"Alice"，age→20（顺序不能错）

代码验证：
python

运行

代码语言：TXT

自动换行

AI代码解释

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

print_info("Alice", 20)  # 输出：姓名：Alice，年龄：20
# print_info(20, "Alice")  # 顺序错误，输出混乱（慎用）

（2）关键字参数（灵活）

图解传递逻辑：
plaintext

代码语言：TXT

自动换行

AI代码解释

print_info(age=20, name="Alice")
# 按名绑定：age→20，name→"Alice"（顺序无关）

代码验证：
python

运行

代码语言：TXT

自动换行

AI代码解释

print_info(age=20, name="Alice")  # 输出：姓名：Alice，年龄：20

（3）默认参数（简化调用）

图解默认值逻辑：
plaintext

代码语言：TXT

自动换行

AI代码解释

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

print_info("Bob")  # 未传age，使用默认值18 → 姓名：Bob，年龄：18
print_info("Bob", 22)  # 传age=22，覆盖默认值 → 姓名：Bob，年龄：22

代码验证：
python

运行

代码语言：TXT

自动换行

AI代码解释

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

print_info("Bob")        # 输出：姓名：Bob，年龄：18
print_info("Bob", 22)    # 输出：姓名：Bob，年龄：22

⚠️ 注意：默认参数建议使用「不可变类型（如数字、字符串、元组）」，避免用列表 / 字典（否则多次调用会累积修改）。

（4）可变参数（接收任意数量参数）

• *args：接收任意数量的位置参数，打包为「元组」；

• **kwargs：接收任意数量的关键字参数，打包为「字典」。

图解 *args 和 **kwargs：
plaintext

展开 

代码语言：TXT

自动换行

AI代码解释

def f(*args, **kwargs):
    print("args（元组）：", args)
    print("kwargs（字典）：", kwargs)

f(1, 2, 3, name="Tom", age=20)
# args → (1, 2, 3)（位置参数打包）
# kwargs → {"name": "Tom", "age": 20}（关键字参数打包）

代码验证：
python

运行

展开 

代码语言：TXT

自动换行

AI代码解释

def f(*args, **kwargs):
    print("args（元组）：", args)
    print("kwargs（字典）：", kwargs)

f(1, 2, 3, name="Tom", age=20)
# 输出：
# args（元组）： (1, 2, 3)
# kwargs（字典）： {'name': 'Tom', 'age': 20}

3. 参数解包（反向操作）

将列表 元组 字典解包为函数的参数，图解逻辑：
plaintext

展开 

代码语言：TXT

自动换行

AI代码解释

# 列表解包（*）
lst = [1, 2]
get_sum(*lst)  # 等价于get_sum(1, 2)

# 字典解包（**）
dic = {"a": 1, "b": 2}
get_sum(**dic)  # 等价于get_sum(a=1, b=2)

代码验证：
python

运行

展开 

代码语言：TXT

自动换行

AI代码解释

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

lst = [3, 5]
print("列表解包求和：", get_sum(*lst))  # 输出：8

dic = {"a": 4, "b": 6}
print("字典解包求和：", get_sum(**dic))  # 输出：10

三、函数的返回值（图解 + 代码）

return 是函数的「输出接口」，核心作用：① 返回数据给调用处；② 立即结束函数执行。

1. 返回值的基本逻辑

图解 return 执行流程：
plaintext

展开 

代码语言：TXT

自动换行

AI代码解释

def check_num(n):
    if n > 0:
        return "正数"  # 执行return，函数立即结束
    elif n == 0:
        return "零"
    else:
        return "负数"

result = check_num(5)
# 流程：调用check_num(5) → n=5 → 满足n>0 → return "正数" → 赋值给result

代码验证：
python

运行

展开 

代码语言：TXT

自动换行

AI代码解释

def check_num(n):
    if n > 0:
        return "正数"
    elif n == 0:
        return "零"
    else:
        return "负数"

print(check_num(5))   # 输出：正数
print(check_num(-3))  # 输出：负数
print(check_num(0))   # 输出：零

2. 多返回值（Python 特色）

Python 函数可返回多个值，本质是「自动打包为元组」，调用时可解包为多个变量。
图解多返回值逻辑：
plaintext

展开 

代码语言：TXT

自动换行

AI代码解释

def get_info():
    name = "Alice"
    age = 20
    return name, age  # 等价于return (name, age)

# 调用方式1：接收为元组
info = get_info()
# info → ("Alice", 20)

# 调用方式2：解包为变量
name, age = get_info()
# name→"Alice"，age→20

代码验证：
python

运行

展开 

代码语言：TXT

自动换行

AI代码解释

def get_info():
    name = "Alice"
    age = 20
    return name, age

# 方式1：元组接收
info = get_info()
print("元组接收：", info)  # 输出：('Alice', 20)

# 方式2：解包接收
name, age = get_info()
print(f"解包接收：姓名{name}，年龄{age}")  # 输出：姓名Alice，年龄20

3. 无 return 的函数

若函数无 return，默认返回 None（空值）。
代码验证：
python

运行

代码语言：TXT

自动换行

AI代码解释

def print_hello():
    print("Hello Python")

result = print_hello()
print("无return的返回值：", result)  # 输出：None

四、函数的作用域（图解 + 代码）

作用域是「变量的可访问范围」，Python 函数的作用域分为：「局部作用域（函数内）」和「全局作用域（函数外）」。

1. 作用域规则图解

plaintext

展开 

代码语言：TXT

自动换行

AI代码解释

# 全局作用域（整个程序可访问）
global_var = 10

def func():
    # 局部作用域（仅函数内可访问）
    local_var = 20
    print("函数内访问全局变量：", global_var)  # 允许
    print("函数内访问局部变量：", local_var)  # 允许

func()
print("函数外访问全局变量：", global_var)  # 允许
# print("函数外访问局部变量：", local_var)  # 报错（局部变量不可访问）

核心规则：

• 局部变量：函数内定义，仅函数内可用，函数执行结束后销毁；

• 全局变量：函数外定义，整个程序可用；

• 函数内可访问全局变量，但默认不能修改（需用 global 关键字）。

2. 修改全局变量（global 关键字）

图解 global 用法：
plaintext

展开 

代码语言：TXT

自动换行

AI代码解释

global_var = 10

def func():
    global global_var  # 声明使用全局变量
    global_var = 20    # 修改全局变量

func()
print("修改后的全局变量：", global_var)  # 输出：20

代码验证：
python

运行

展开 

代码语言：TXT

自动换行

AI代码解释

global_var = 10

def func():
    global global_var
    global_var = 20

func()
print(global_var)  # 输出：20

3. 嵌套函数的作用域（nonlocal 关键字）

嵌套函数中，nonlocal 用于声明「访问外层函数的局部变量」。
图解嵌套函数作用域：
plaintext

展开 

代码语言：TXT

自动换行

AI代码解释

def outer():
    outer_var = 10  # 外层函数的局部变量
    
    def inner():
        nonlocal outer_var  # 声明使用外层局部变量
        outer_var = 20     # 修改外层局部变量
    
    inner()
    print("外层变量：", outer_var)  # 输出：20

outer()

代码验证：
python

运行

展开 

代码语言：TXT

自动换行

AI代码解释

def outer():
    outer_var = 10
    
    def inner():
        nonlocal outer_var
        outer_var = 20
    
    inner()
    print(outer_var)  # 输出：20

outer()

五、函数的高级用法（图解 + 代码）

1. 匿名函数（lambda）

lambda 是「简化版匿名函数」，适用于简单逻辑（一行代码），语法：lambda 参数: 表达式。
图解 lambda 结构：
plaintext

展开 

代码语言：TXT

自动换行

AI代码解释

# 普通函数
def get_sum(a, b):
    return a + b

# 等价的lambda函数
lambda a, b: a + b

# 调用lambda
f = lambda a, b: a + b
f(3, 5)  # 输出：8

代码验证：
python

运行

展开 

代码语言：TXT

自动换行

AI代码解释

# 定义lambda函数
f = lambda a, b: a + b
print("lambda求和：", f(3, 5))  # 输出：8

# 结合内置函数使用（如sorted）
lst = [(1, 3), (4, 1), (2, 2)]
# 按元组第二个元素排序
lst_sorted = sorted(lst, key=lambda x: x[1])
print("排序结果：", lst_sorted)  # 输出：[(4, 1), (2, 2), (1, 3)]

2. 函数作为参数（高阶函数）

Python 中函数是「一等对象」，可作为参数传递给另一个函数（高阶函数）。
图解高阶函数逻辑：
plaintext

展开 

代码语言：TXT

自动换行

AI代码解释

# 定义计算函数
def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

# 定义高阶函数（接收函数作为参数）
def calculate(func, a, b):
    return func(a, b)

# 调用：传递add函数
calculate(add, 3, 5)  # 等价于add(3,5) → 8
# 调用：传递multiply函数
calculate(multiply, 3, 5)  # 等价于multiply(3,5) → 15

代码验证：
python

运行

展开 

代码语言：TXT

自动换行

AI代码解释

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

def multiply(a, b):
    return a * b

def calculate(func, a, b):
    return func(a, b)

print("高阶函数+加法：", calculate(add, 3, 5))      # 输出：8
print("高阶函数+乘法：", calculate(multiply, 3, 5)) # 输出：15

六、函数的常用场景（图解总结）

plaintext

展开 

代码语言：TXT

自动换行

AI代码解释

函数核心价值：
┌─────────────┬─────────────────────────────────┐
│ 模块化      │ 将复杂逻辑拆分为多个小函数，易维护 │
├─────────────┼─────────────────────────────────┤
│ 可复用      │ 一次定义，多次调用，减少重复代码 │
├─────────────┼─────────────────────────────────┤
│ 解耦        │ 函数内部逻辑不影响外部，降低耦合 │
├─────────────┼─────────────────────────────────┤
│ 易测试      │ 单个函数可独立测试，定位问题快 │
└─────────────┴─────────────────────────────────┘

函数常用场景：
1. 封装重复逻辑（如数据清洗、计算逻辑）
2. 拆分复杂功能（如电商系统的「下单」拆分为校验、扣库存、生成订单）
3. 作为参数传递（如结合sorted、map、filter等内置函数）
4. 函数返回函数（装饰器的基础）

七、核心对比（图解）

特性	普通函数	lambda函数
命名	有名称（如 get_sum）	匿名（可赋值给变量）
复杂度	支持多行逻辑、条件、循环	仅支持单行表达式
用途	复杂逻辑	简单逻辑、临时使用
返回值	需显式 return	表达式结果自动返回