目录

一、函数的核心概念

二、函数的基本语法（自定义函数）

2.1 函数的定义格式

2.2 最简单的函数示例（无参数、无返回值）

2.3 带参数、有返回值的函数示例

三、函数的参数详解（重点）

3.1 位置参数（必选参数）

3.2 关键字参数

3.3 默认参数（可选参数）

3.4 可变参数（不定长参数）

3.4.1 *args（接收位置可变参数）

3.4.2 **kwargs（接收关键字可变参数）

3.4.3 可变参数的混合使用

四、函数的返回值（return）

4.1 返回值的基本使用

4.2 返回多个值

4.3 无返回值的情况

五、函数的调用与嵌套

5.1 函数的调用时机

5.2 函数的嵌套调用

5.3 函数的嵌套定义

六、函数的进阶知识点

6.1 匿名函数（lambda函数）

6.2 函数的作用域

6.3 递归函数

6.4 常用内置函数

七、函数的实战案例

案例1：封装函数，判断一个数是否为质数

案例2：封装函数，实现学生成绩统计（计算平均分、最高分、最低分）

八、常见错误与注意事项

九、总结

---

一、函数的核心概念

函数是Python中组织代码的核心方式，本质是一段可重复调用、功能独立的代码块，用于实现特定的逻辑或功能。使用函数可以减少代码冗余、提高代码可读性和可维护性，同时实现代码的模块化拆分——将复杂任务拆解为多个简单的函数，逐一实现，降低开发难度。

类比生活场景：函数就像一台“加工机器”，我们输入“原材料”（参数），机器执行固定的加工逻辑（函数体），最终输出“成品”（返回值）。例如，计算两个数的和，我们可以将“求和逻辑”封装成函数，每次需要求和时，直接调用该函数即可，无需重复编写求和代码。

Python中的函数分为两类：内置函数（Python自带，可直接调用，如print()、len()）和自定义函数（开发者根据需求自己编写的函数），本教程重点讲解自定义函数的编写与使用。

二、函数的基本语法（自定义函数）

2.1 函数的定义格式

Python中使用def关键字定义函数，基本语法如下：

def 函数名(参数列表): """函数文档字符串（可选，用于说明函数功能、参数、返回值）""" # 函数体：实现具体功能的代码（缩进4个空格，Python语法要求） 代码语句 return 返回值（可选）

各部分说明：

• def：定义函数的关键字，必须放在函数名前面，后面加空格。

• 函数名：遵循Python命名规范，由字母、数字、下划线组成，不能以数字开头，不能使用Python关键字（如if、for、def等），建议命名简洁明了，体现函数功能（如sum_num、calculate_area）。

• 参数列表：括号内的内容，用于接收外部传入的数据，可空（无参数函数），也可包含一个或多个参数，多个参数用逗号分隔。

• 函数文档字符串：用三引号（单引号、双引号均可）包裹，用于说明函数的功能、参数含义、返回值类型等，可通过help(函数名)查看，提升代码可读性，非必需但强烈推荐。

• 函数体：函数的核心逻辑，所有代码必须缩进（默认4个空格），缩进不一致会导致语法错误。

• return：用于返回函数的执行结果（返回值），可省略，省略时函数默认返回None；return后面的代码不会执行（即return是函数的“终止符”）。

2.2 最简单的函数示例（无参数、无返回值）

需求：定义一个函数，打印“Hello, Python函数！”

# 定义无参数、无返回值的函数 def print_hello(): """打印问候语""" print("Hello, Python函数！") # 调用函数：函数名 + 括号（无参数则括号内空） print_hello() # 运行结果：Hello, Python函数！

说明：调用函数时，必须写括号（即使无参数），否则不会执行函数，只会打印函数对象的信息（如<function print_hello at 0x0000023F78E8A670>）。

2.3 带参数、有返回值的函数示例

需求：定义一个函数，接收两个整数参数，返回它们的和。

# 定义带参数、有返回值的函数 def sum_num(a, b): """计算两个整数的和 参数： a: 第一个整数 b: 第二个整数 返回值： 两个整数的和（int类型） """ result = a + b # 函数体：计算和 return result # 返回计算结果 # 调用函数：传入参数，接收返回值 num1 = 10 num2 = 20 total = sum_num(num1, num2) # 将函数返回值赋值给变量total print(f"{num1} + {num2} = {total}") # 运行结果：10 + 20 = 30

说明：调用函数时，传入的参数数量、类型需与函数定义的参数列表匹配（否则会报错），返回值可直接使用或赋值给变量。

三、函数的参数详解（重点）

函数的参数是函数与外部交互的接口，根据传入方式和作用，可分为4种类型，优先级：位置参数 > 关键字参数 > 默认参数 > 可变参数。

3.1 位置参数（必选参数）

最基础的参数类型，必须按照函数定义的顺序传入参数，数量不能多也不能少，否则会报错。

# 定义位置参数函数：计算长方形面积（长、宽为必选参数） def calculate_area(length, width): """计算长方形面积 参数： length: 长方形的长（int/float） width: 长方形的宽（int/float） 返回值： 长方形面积（int/float） """ return length * width # 正确调用：按顺序传入长、宽 area1 = calculate_area(5, 3) print("长方形面积1：", area1) # 结果：15 # 错误调用1：参数数量不足（少传1个） # area2 = calculate_area(5) # 报错：missing 1 required positional argument: 'width' # 错误调用2：参数顺序错误（长和宽颠倒，结果错误但不报错） area3 = calculate_area(3, 5) print("长方形面积3：", area3) # 结果：15（巧合正确，实际逻辑错误）

注意：位置参数的顺序至关重要，传入时需严格匹配函数定义的参数顺序。

3.2 关键字参数

调用函数时，通过“参数名=值”的方式传入参数，无需遵循位置顺序，可提高代码可读性，尤其适合参数较多的场景。

# 复用上面的calculate_area函数 # 关键字参数调用：不按顺序，指定参数名 area4 = calculate_area(width=3, length=5) print("长方形面积4：", area4) # 结果：15（正确） # 混合调用：位置参数在前，关键字参数在后（必须遵循此顺序） area5 = calculate_area(5, width=3) print("长方形面积5：", area5) # 结果：15（正确） # 错误调用：关键字参数在前，位置参数在后 # area6 = calculate_area(width=3, 5) # 报错：positional argument follows keyword argument

规则：关键字参数不能在位置参数前面，否则Python无法识别参数对应的位置。

3.3 默认参数（可选参数）

定义函数时，给参数指定一个默认值，调用函数时，若不传入该参数，则使用默认值；若传入，则覆盖默认值。默认参数必须放在位置参数后面（否则报错）。

# 定义带默认参数的函数：计算长方形面积，默认宽为2 def calculate_area(length, width=2): """计算长方形面积，默认宽为2""" return length * width # 调用1：不传入width，使用默认值2 area7 = calculate_area(5) print("长方形面积7：", area7) # 结果：5*2=10 # 调用2：传入width，覆盖默认值 area8 = calculate_area(5, width=4) print("长方形面积8：", area8) # 结果：5*4=20 # 错误定义：默认参数放在位置参数前面 # def calculate_area(width=2, length): # 报错：non-default argument follows default argument

注意：默认参数的值只在函数定义时初始化一次，若默认值是可变对象（如列表、字典），多次调用函数可能会出现意外结果（后续进阶部分讲解）。

3.4 可变参数（不定长参数）

当不确定传入的参数数量时，使用可变参数，分为两种：*args（接收任意数量的位置参数）和**kwargs（接收任意数量的关键字参数）。

3.4.1 *args（接收位置可变参数）

*args会将传入的多个位置参数打包成一个元组，函数内部可通过遍历元组获取每个参数的值。

# 定义可变参数函数：计算任意多个数的和 def sum_all(*args): """计算任意多个数的和，args是元组类型""" total = 0 for num in args: total += num return total # 调用：传入任意数量的位置参数 print(sum_all(1, 2)) # 结果：3 print(sum_all(1, 2, 3, 4)) # 结果：10 print(sum_all()) # 结果：0（传入0个参数，args为空元组） print(sum_all(5, 6, 7, 8, 9)) # 结果：35

3.4.2 **kwargs（接收关键字可变参数）

**kwargs会将传入的多个关键字参数打包成一个字典，键是参数名，值是参数值，函数内部可通过字典操作获取参数。

# 定义可变参数函数：打印用户信息（姓名、年龄、性别等，数量不确定） def print_user_info(**kwargs): """打印用户信息，kwargs是字典类型""" for key, value in kwargs.items(): print(f"{key}：{value}") # 调用：传入任意数量的关键字参数 print_user_info(name="张三", age=20, gender="男") # 运行结果： # name：张三 # age：20 # gender：男 print_user_info(name="李四", city="北京") # 运行结果： # name：李四 # city：北京

3.4.3 可变参数的混合使用

当函数同时包含位置参数、默认参数、*args、**kwargs时，必须遵循以下顺序：位置参数 > 默认参数 > *args > **kwargs。

# 混合参数示例 def mix_params(a, b, c=0, *args, **kwargs): """混合参数演示""" print("位置参数a：", a) print("位置参数b：", b) print("默认参数c：", c) print("可变位置参数args：", args) print("可变关键字参数kwargs：", kwargs) # 调用 mix_params(1, 2, 3, 4, 5, name="张三", age=20) # 运行结果： # 位置参数a： 1 # 位置参数b： 2 # 默认参数c： 3 # 可变位置参数args： (4, 5) # 可变关键字参数kwargs： {'name': '张三', 'age': 20}

四、函数的返回值（return）

4.1 返回值的基本使用

return用于将函数的执行结果返回给调用者，函数执行到return语句后，会立即终止，后续代码不会执行。

def test_return(): print("执行return前的代码") return "我是返回值" # 执行到return，函数终止 print("执行return后的代码") # 不会执行 result = test_return() print(result) # 输出：我是返回值

4.2 返回多个值

Python函数可以通过return返回多个值，多个值用逗号分隔，本质是返回一个元组（可省略括号），调用时可通过多个变量接收。

# 返回多个值：计算两个数的和与差 def sum_and_sub(a, b): sum_result = a + b sub_result = a - b return sum_result, sub_result # 等价于 return (sum_result, sub_result) # 接收多个返回值 sum_val, sub_val = sum_and_sub(10, 3) print("和：", sum_val) # 输出：13 print("差：", sub_val) # 输出：7 # 也可以用一个变量接收（得到元组） result = sum_and_sub(10, 3) print(result) # 输出：(13, 7)

4.3 无返回值的情况

若函数没有return语句，或return后面没有任何内容，函数默认返回None（None是Python中的空值，表示“没有值”）。

def no_return(): print("没有return语句") def return_none(): print("return后面没有内容") return result1 = no_return() result2 = return_none() print(result1) # 输出：None print(result2) # 输出：None

五、函数的调用与嵌套

5.1 函数的调用时机

函数必须先定义，后调用（顺序不能颠倒），否则会报错；函数可以在其他函数内部调用，也可以多次调用。

# 错误：先调用，后定义 # test() # 报错：name 'test' is not defined # 正确：先定义，后调用 def test(): print("函数被调用了") # 多次调用 test() # 输出：函数被调用了 test() # 输出：函数被调用了

5.2 函数的嵌套调用

函数内部可以调用另一个函数，称为嵌套调用，嵌套的层数没有限制（但不建议嵌套过深，否则代码可读性差）。

# 定义函数A def func_a(): print("进入func_a") # 定义函数B，内部调用func_a def func_b(): print("进入func_b") func_a() # 嵌套调用func_a print("离开func_b") # 调用func_b func_b() # 运行结果： # 进入func_b # 进入func_a # 离开func_b

示例：嵌套调用实现复杂逻辑——计算三个数的平均值（先求和，再求平均）

# 定义求和函数 def sum_three(a, b, c): return a + b + c # 定义求平均值函数，嵌套调用sum_three def average_three(a, b, c): total = sum_three(a, b, c) # 嵌套调用 return total / 3 # 调用 avg = average_three(10, 20, 30) print("平均值：", avg) # 输出：20.0

5.3 函数的嵌套定义

函数内部可以定义另一个函数（内部函数），内部函数只能在外部函数内部调用，外部无法直接调用。

# 定义外部函数 def outer_func(): print("进入外部函数") # 定义内部函数（嵌套定义） def inner_func(): print("进入内部函数") # 内部函数只能在外部函数内部调用 inner_func() print("离开外部函数") # 调用外部函数 outer_func() # 运行结果： # 进入外部函数 # 进入内部函数 # 离开外部函数 # 错误：外部直接调用内部函数 # inner_func() # 报错：name 'inner_func' is not defined

六、函数的进阶知识点

6.1 匿名函数（lambda函数）

匿名函数是一种简化的函数，没有函数名，仅适用于实现简单的逻辑（一行代码可完成），语法：lambda 参数列表: 表达式。

特点：匿名函数只能有一个表达式，表达式的结果就是函数的返回值，无需写return；不能包含复杂的代码块（如循环、条件判断的多行逻辑）。

# 用lambda定义匿名函数（计算两个数的和） sum_lambda = lambda a, b: a + b # 等价于def sum_lambda(a,b): return a+b # 调用匿名函数 print(sum_lambda(3, 5)) # 输出：8 # 匿名函数常用于临时使用，如作为sorted()、map()等函数的参数 # 示例：对列表中的元组，按元组的第二个元素排序 list1 = [(1, 3), (4, 1), (2, 5)] # sorted()的key参数接收一个函数，用lambda简化 sorted_list = sorted(list1, key=lambda x: x[1]) print(sorted_list) # 输出：[(4, 1), (1, 3), (2, 5)]

6.2 函数的作用域

作用域指变量的可访问范围，Python中变量的作用域分为4种，从内到外依次是：

• 局部作用域（L）：函数内部定义的变量，仅在函数内部可访问，函数执行结束后，局部变量会被销毁。

• 嵌套作用域（E）：嵌套函数中，内部函数可访问外部函数定义的变量（非全局变量）。

• 全局作用域（G）：函数外部定义的变量，可在整个模块（当前Python文件）中访问。

• 内置作用域（B）：Python自带的变量和函数（如print、len、int），可在任何地方访问。

规则：就近原则——变量访问时，优先在当前作用域查找，找不到再向上一级作用域查找，直到内置作用域，若都找不到则报错。

# 全局变量 global_var = "我是全局变量" def outer(): # 嵌套作用域变量 outer_var = "我是外部函数变量" def inner(): # 局部变量 inner_var = "我是内部函数变量" # 访问变量：就近原则 print(inner_var) # 访问局部变量 print(outer_var) # 访问嵌套作用域变量 print(global_var) # 访问全局变量 inner() # 调用外部函数 outer() # 错误：外部无法访问局部变量 # print(inner_var) # 报错：name 'inner_var' is not defined

补充：使用global关键字，可在函数内部修改全局变量；使用nonlocal关键字，可在内部函数中修改外部函数的变量。

6.3 递归函数

递归函数指函数自己调用自己，用于解决可拆解为“相同子问题”的复杂问题（如阶乘、斐波那契数列）。

递归的两个核心条件：

• 基线条件（终止条件）：当满足该条件时，函数停止递归（否则会陷入无限递归，导致栈溢出）。

• 递归条件：函数调用自己，且每次调用时，问题规模缩小（向基线条件靠近）。

# 示例1：递归计算n的阶乘（n! = n × (n-1) × ... × 1，0! = 1） def factorial(n): # 基线条件：n=0或n=1时，阶乘为1 if n == 0 or n == 1: return 1 # 递归条件：n! = n × (n-1)! return n * factorial(n-1) # 调用 print(factorial(5)) # 输出：120（5×4×3×2×1） print(factorial(0)) # 输出：1 # 示例2：递归计算斐波那契数列（第n项 = 第n-1项 + 第n-2项，前两项为1） def fibonacci(n): # 基线条件：n=1或n=2时，值为1 if n == 1 or n == 2: return 1 # 递归条件 return fibonacci(n-1) + fibonacci(n-2) # 调用：计算第10项斐波那契数 print(fibonacci(10)) # 输出：55

注意：递归函数的效率较低（多次重复调用），且递归深度有限（Python默认递归深度约1000层，超过会报错），复杂场景可改用循环实现。

6.4 常用内置函数

Python自带大量内置函数，可直接调用，无需定义，常用的有：

函数名	功能	示例
print()	打印内容	print("Hello") → Hello
len()	获取对象长度（字符串、列表等）	len([1,2,3]) → 3
max()	获取序列中的最大值	max([1,5,3]) → 5
min()	获取序列中的最小值	min([1,5,3]) → 1
sum()	计算序列中元素的和	sum([1,2,3]) → 6
int()	将其他类型转换为整数	int("123") → 123
str()	将其他类型转换为字符串	str(123) → "123"
sorted()	对序列进行排序，返回新列表	sorted([3,1,2]) → [1,2,3]

七、函数的实战案例

案例1：封装函数，判断一个数是否为质数

def is_prime(num): """判断一个正整数是否为质数 参数： num: 正整数 返回值： True：是质数，False：不是质数 """ # 边界条件：小于2的数不是质数 if num < 2: return False # 遍历2到num的平方根，判断是否能整除 for i in range(2, int(num**0.5) + 1): if num % i == 0: return False return True # 调用函数，判断多个数 nums = [7, 12, 17, 20, 23] for n in nums: print(f"{n}是{'质数' if is_prime(n) else '非质数'}") # 运行结果： # 7是质数 # 12是非质数 # 17是质数 # 20是非质数 # 23是质数

案例2：封装函数，实现学生成绩统计（计算平均分、最高分、最低分）

def score_statistics(scores): """统计学生成绩 参数： scores: 包含学生成绩的列表（int/float） 返回值： 平均分、最高分、最低分（元组） """ # 边界条件：列表为空时，返回None if not scores: return None, None, None average = sum(scores) / len(scores) max_score = max(scores) min_score = min(scores) return round(average, 2), max_score, min_score # round保留2位小数 # 调用函数 student_scores = [85, 92, 78, 90, 88, 95] avg, max_s, min_s = score_statistics(student_scores) print(f"成绩统计结果：") print(f"平均分：{avg}") print(f"最高分：{max_s}") print(f"最低分：{min_s}") # 运行结果： # 成绩统计结果： # 平均分：88.0 # 最高分：95 # 最低分：78

八、常见错误与注意事项

• 缩进错误：函数体必须缩进（默认4个空格），缩进不一致会导致语法错误，这是初学者最常见的错误。

• 参数不匹配：调用函数时，传入的参数数量、类型与函数定义不匹配，会报错（如少传、多传参数，传入字符串却需要整数）。

• 变量作用域错误：试图在函数外部访问局部变量，或在内部函数中修改外部变量未使用nonlocal/global关键字。

• 无限递归：递归函数未设置正确的基线条件，导致函数无限调用自己，最终引发栈溢出错误（RecursionError）。

• 默认参数使用可变对象：默认参数若为列表、字典等可变对象，多次调用函数会导致默认值被修改（建议用None作为默认值，在函数内部初始化可变对象）。

九、总结

函数是Python模块化编程的核心，掌握函数的定义、参数、返回值是基础，进阶部分的匿名函数、递归、作用域等知识点能帮助你编写更简洁、高效的代码。学习函数的关键是多练习——先模仿示例编写简单函数，再尝试封装复杂逻辑，逐步掌握函数的灵活运用。

后续可结合Python的模块、类等知识点，进一步提升代码的组织性和复用性，为编写大型程序打下基础。