函数是Python中用于封装可重用代码的基本构建块。通过函数，我们可以将复杂的程序分解为更小、更易于管理的模块，提高代码的可读性、可维护性和复用性。本文将详细介绍Python函数的定义、参数、返回值、作用域、闭包、装饰器、递归和生成器函数等核心概念和高级用法。
一、函数概述
1. 什么是函数？
函数是一段封装了特定功能的代码块，它可以接收输入参数，执行特定的操作，并返回结果。函数的核心思想是将代码模块化，实现代码的复用和逻辑的分离。
2. Python函数的特点
Python函数具有以下特点：
3. 函数的分类
Python函数可以分为以下几类：
- 内置函数：Python自带的函数，如
print()、len()、range()等 - 自定义函数
- 匿名函数
- 递归函数
- 生成器函数
二、函数定义与调用
1. 函数定义的基本语法
使用def关键字定义函数的基本语法如下：
def 函数名(参数列表):"""函数文档字符串""" 函数体return 返回值
其中：
2. 函数定义示例
# 无参数、无返回值的函数defhello():"""打印问候信息"""print("Hello, World!")# 有参数、无返回值的函数defgreet(name):"""向指定名称的人打招呼"""print(f"Hello, {name}!")# 有参数、有返回值的函数defadd(a, b):"""计算两个数的和并返回结果"""return a + b# 有默认参数的函数defpower(base, exponent=2):"""计算base的exponent次方，默认exponent为2"""return base ** exponent# 有可变参数的函数defsum(*args):"""计算任意数量参数的和""" total =0for num in args: total += numreturn total
3. 函数调用
定义函数后，可以通过函数名和参数列表来调用函数：
# 调用无参数函数hello()# 输出：Hello, World!# 调用有参数函数greet("张三")# 输出：Hello, 张三!# 调用有返回值的函数result = add(3,5)print(result)# 输出：8# 调用有默认参数的函数print(power(3))# 输出：9（使用默认参数exponent=2）print(power(3,3))# 输出：27（使用指定参数exponent=3）# 调用有可变参数的函数print(sum(1,2,3,4,5))# 输出：15
4. 文档字符串
文档字符串（Docstring）是函数的说明文档，用于描述函数的功能、参数和返回值。文档字符串使用三重引号"""定义，可以通过help()函数或.__doc__属性查看：
# 文档字符串示例defadd(a, b):"""计算两个数的和 参数: a: 第一个数 b: 第二个数 返回: 两个数的和 """return a + b# 查看文档字符串help(add)# 通过help()函数查看print(add.__doc__)# 通过.__doc__属性查看
三、函数参数
Python函数支持多种类型的参数，包括位置参数、关键字参数、默认参数、可变参数等。
1. 位置参数
位置参数是最基本的参数类型，参数的顺序决定了它们的值：
# 位置参数示例defgreet(name, age):"""向指定名称和年龄的人打招呼"""print(f"Hello, {name}! You are {age} years old.")# 调用函数时，参数必须按照定义的顺序传递greet("张三",30)# 输出：Hello, 张三! You are 30 years old.
2. 关键字参数
关键字参数允许通过参数名指定参数值，参数的顺序可以任意：
# 关键字参数示例defgreet(name, age):"""向指定名称和年龄的人打招呼"""print(f"Hello, {name}! You are {age} years old.")# 调用函数时，使用参数名指定参数值greet(age=30, name="张三")# 输出：Hello, 张三! You are 30 years old.# 混合使用位置参数和关键字参数greet("张三", age=30)# 输出：Hello, 张三! You are 30 years old.
3. 默认参数
默认参数允许为参数指定默认值，当调用函数时不提供该参数，将使用默认值：
# 默认参数示例defgreet(name, age=18):"""向指定名称的人打招呼，默认年龄为18"""print(f"Hello, {name}! You are {age} years old.")# 不提供默认参数greet("张三")# 输出：Hello, 张三! You are 18 years old.# 提供默认参数greet("张三",30)# 输出：Hello, 张三! You are 30 years old.
4. 可变位置参数（*args）
可变位置参数允许函数接收任意数量的位置参数，参数将被收集到一个元组中：
# 可变位置参数示例defsum(*args):"""计算任意数量参数的和""" total =0for num in args: total += numreturn total# 调用函数时，可以传递任意数量的位置参数print(sum(1,2,3))# 输出：6print(sum(1,2,3,4,5))# 输出：15print(sum())# 输出：0（没有传递参数）
5. 可变关键字参数（**kwargs）
可变关键字参数允许函数接收任意数量的关键字参数，参数将被收集到一个字典中：
# 可变关键字参数示例defdisplay_info(**kwargs):"""显示任意数量的关键字参数"""for key, value in kwargs.items():print(f"{key}: {value}")# 调用函数时，可以传递任意数量的关键字参数display_info(name="张三", age=30, city="北京")# 输出：# name: 张三# age: 30# city: 北京# 混合使用位置参数和可变参数defgreet(name,*args,**kwargs):"""混合使用位置参数、可变位置参数和可变关键字参数"""print(f"Hello, {name}!")if args:print(f"额外的位置参数: {args}")if kwargs:print(f"额外的关键字参数: {kwargs}")greet("张三",30,175, city="北京", occupation="工程师")# 输出：# Hello, 张三!# 额外的位置参数: (30, 175)# 额外的关键字参数: {'city': '北京', 'occupation': '工程师'}
6. 参数的顺序
函数参数的顺序应该是：位置参数 → 默认参数 → 可变位置参数 → 可变关键字参数：
# 参数顺序示例deffunc(positional_arg, default_arg=0,*args,**kwargs):"""参数顺序：位置参数 → 默认参数 → 可变位置参数 → 可变关键字参数"""pass
7. 解包参数
可以使用*和**操作符解包序列或字典，将其作为参数传递给函数：
# 解包参数示例# 解包列表作为位置参数defadd(a, b, c):return a + b + cnumbers =[1,2,3]print(add(*numbers))# 输出：6（相当于add(1, 2, 3)）# 解包字典作为关键字参数defdisplay_info(name, age):print(f"Name: {name}, Age: {age}")person ={"name":"张三","age":30}display_info(**person)# 输出：Name: 张三, Age: 30（相当于display_info(name="张三", age=30)）# 混合解包numbers =[1,2]extra ={"c":3,"d":4}deffunc(a, b, c, d):return a + b + c + dprint(func(*numbers,**extra))# 输出：10（相当于func(1, 2, c=3, d=4)）
四、函数返回值
1. 返回单个值
函数可以使用return语句返回单个值：
# 返回单个值示例defsquare(x):"""计算x的平方并返回结果"""return x **2result = square(5)print(result)# 输出：25
2. 返回多个值
函数可以使用return语句返回多个值，这些值将被打包成一个元组：
# 返回多个值示例defget_coordinates():"""返回坐标信息""" x =10 y =20 z =30return x, y, z # 返回一个元组# 接收返回的多个值x, y, z = get_coordinates()print(x, y, z)# 输出：10 20 30# 接收返回的元组coordinates = get_coordinates()print(coordinates)# 输出：(10, 20, 30)print(type(coordinates))# 输出：<class 'tuple'>
3. 返回None
如果函数没有显式的return语句，或者return语句后面没有值，函数将返回None：
# 返回None示例defgreet(name):"""打印问候信息"""print(f"Hello, {name}!")result = greet("张三")print(result)# 输出：Noneprint(type(result))# 输出：<class 'NoneType'># 显式返回Nonedefdo_nothing():"""什么都不做，显式返回None"""returnNoneresult = do_nothing()print(result)# 输出：None
4. 提前返回
函数可以使用return语句提前返回，函数将在执行到return语句时立即结束：
# 提前返回示例defis_even(num):"""判断一个数是否为偶数"""if num %2==0:returnTrue# 提前返回returnFalseprint(is_even(4))# 输出：Trueprint(is_even(5))# 输出：False
五、函数的作用域
1. 作用域概述
作用域是变量可见的范围，Python中的变量作用域分为：
- 局部作用域（Local）
- 嵌套作用域（Enclosing）：在嵌套函数外的函数中定义的变量，在嵌套函数内部可见
- 全局作用域（Global）
- 内置作用域（Built-in）：Python内置的变量和函数，如
print()、len()等
2. 局部作用域
在函数内部定义的变量具有局部作用域，只在函数内部可见：
# 局部作用域示例defmy_function():"""在函数内部定义局部变量""" local_var ="局部变量"print(f"函数内部: {local_var}")my_function()# 输出：函数内部: 局部变量# 尝试在函数外部访问局部变量print(f"函数外部: {local_var}")# 抛出NameError异常
3. 全局作用域
在模块级别定义的变量具有全局作用域，在整个模块中可见：
# 全局作用域示例# 定义全局变量global_var ="全局变量"defmy_function():"""在函数内部访问全局变量"""print(f"函数内部访问全局变量: {global_var}")my_function()# 输出：函数内部访问全局变量: 全局变量print(f"函数外部访问全局变量: {global_var}")# 输出：函数外部访问全局变量: 全局变量
4. global关键字
在函数内部修改全局变量时，需要使用global关键字声明变量为全局变量：
# global关键字示例global_var ="全局变量"defmy_function():"""在函数内部修改全局变量"""global global_var # 声明为全局变量 global_var ="修改后的全局变量"print(f"函数内部修改后的全局变量: {global_var}")my_function()# 输出：函数内部修改后的全局变量: 修改后的全局变量print(f"函数外部访问修改后的全局变量: {global_var}")# 输出：函数外部访问修改后的全局变量: 修改后的全局变量
5. nonlocal关键字
在嵌套函数内部修改外部函数的变量时，需要使用nonlocal关键字声明变量为非局部变量：
# nonlocal关键字示例defouter_function():"""外部函数""" outer_var ="外部函数变量"definner_function():"""嵌套函数"""nonlocal outer_var # 声明为非局部变量 outer_var ="修改后的外部函数变量"print(f"嵌套函数内部: {outer_var}")print(f"外部函数调用前: {outer_var}") inner_function()print(f"外部函数调用后: {outer_var}")outer_function()# 输出：# 外部函数调用前: 外部函数变量# 嵌套函数内部: 修改后的外部函数变量# 外部函数调用后: 修改后的外部函数变量
六、Lambda函数
1. Lambda函数概述
Lambda函数是一种匿名函数，使用lambda关键字定义，通常用于定义简单的函数。Lambda函数的语法如下：
lambda 参数列表: 表达式
2. Lambda函数示例
# Lambda函数示例# 定义一个简单的lambda函数square =lambda x: x **2print(square(5))# 输出：25# 带有多个参数的lambda函数add =lambda x, y: x + yprint(add(3,5))# 输出：8# 带有默认参数的lambda函数power =lambda base, exponent=2: base ** exponentprint(power(3))# 输出：9print(power(3,3))# 输出：27# 在高阶函数中使用lambda函数numbers =[1,2,3,4,5]# 使用map()函数和lambda函数平方数 =list(map(lambda x: x **2, numbers))print(平方数)# 输出：[1, 4, 9, 16, 25]# 使用filter()函数和lambda函数偶数 =list(filter(lambda x: x %2==0, numbers))print(偶数)# 输出：[2, 4]# 使用sorted()函数和lambda函数students =[{"name":"张三","age":25},{"name":"李四","age":20},{"name":"王五","age":30}]# 按年龄排序sorted_students =sorted(students, key=lambda x: x["age"])print(sorted_students)# 输出：[{'name': '李四', 'age': 20}, {'name': '张三', 'age': 25}, {'name': '王五', 'age': 30}]
3. Lambda函数与普通函数的比较
Lambda函数与普通函数的主要区别是：
# Lambda函数与普通函数的比较示例# 普通函数defsquare(x):return x **2# Lambda函数square =lambda x: x **2# 普通函数defis_even(x):return x %2==0# Lambda函数is_even =lambda x: x %2==0
七、装饰器
1. 装饰器概述
装饰器（Decorator）是一种特殊的函数，它可以修改其他函数的行为，而不需要修改函数本身的代码。装饰器的核心思想是函数嵌套和闭包。
2. 装饰器的基本原理
装饰器的基本原理是：
3. 装饰器示例
# 装饰器示例defmy_decorator(func):"""一个简单的装饰器"""defwrapper(*args,**kwargs):"""包装函数"""print("装饰器开始执行") result = func(*args,**kwargs)print("装饰器结束执行")return resultreturn wrapper# 使用装饰器@my_decoratordefgreet(name):"""打印问候信息"""print(f"Hello, {name}!")returnf"Greeted {name}"# 调用装饰后的函数result = greet("张三")print(f"函数返回值: {result}")# 输出：# 装饰器开始执行# Hello, 张三!# 装饰器结束执行# 函数返回值: Greeted 张三
4. 带参数的装饰器
装饰器可以接受参数，需要在装饰器函数外部再包装一层函数：
# 带参数的装饰器示例defrepeat(times):"""带参数的装饰器，重复执行函数指定次数"""defdecorator(func):"""装饰器函数"""defwrapper(*args,**kwargs):"""包装函数""" results =[]for _ inrange(times): results.append(func(*args,**kwargs))return resultsreturn wrapperreturn decorator# 使用带参数的装饰器@repeat(3)defgreet(name):"""打印问候信息"""print(f"Hello, {name}!")returnf"Greeted {name}"# 调用装饰后的函数result = greet("张三")print(f"函数返回值: {result}")# 输出：# Hello, 张三!# Hello, 张三!# Hello, 张三!# 函数返回值: ['Greeted 张三', 'Greeted 张三', 'Greeted 张三']
5. 多个装饰器的使用
可以同时使用多个装饰器，装饰器的执行顺序是从下到上：
# 多个装饰器的使用示例defdecorator1(func):"""装饰器1"""defwrapper(*args,**kwargs):print("装饰器1开始执行") result = func(*args,**kwargs)print("装饰器1结束执行")return resultreturn wrapperdefdecorator2(func):"""装饰器2"""defwrapper(*args,**kwargs):print("装饰器2开始执行") result = func(*args,**kwargs)print("装饰器2结束执行")return resultreturn wrapper# 使用多个装饰器，执行顺序是从下到上@decorator1@decorator2defgreet(name):"""打印问候信息"""print(f"Hello, {name}!")returnf"Greeted {name}"# 调用装饰后的函数result = greet("张三")print(f"函数返回值: {result}")# 输出：# 装饰器1开始执行# 装饰器2开始执行# Hello, 张三!# 装饰器2结束执行# 装饰器1结束执行# 函数返回值: Greeted 张三
八、递归函数
1. 递归函数概述
递归函数是指在函数内部调用自身的函数。递归函数的核心思想是将复杂的问题分解为更小的、相同结构的子问题。
2. 递归函数的基本原理
递归函数的基本原理是：
- 基本情况（Base Case）：递归的终止条件，当满足基本情况时，函数返回一个值，不再递归调用
- 递归情况（Recursive Case）：递归的核心部分，将问题分解为更小的子问题，并递归调用自身
3. 递归函数示例
# 递归函数示例# 计算阶乘deffactorial(n):"""使用递归计算n的阶乘"""# 基本情况if n ==0:return1# 递归情况return n * factorial(n -1)print(factorial(5))# 输出：120（5! = 5 × 4 × 3 × 2 × 1 = 120）# 计算斐波那契数列deffibonacci(n):"""使用递归计算斐波那契数列的第n项"""# 基本情况if n <=1:return n# 递归情况return fibonacci(n -1)+ fibonacci(n -2)print(fibonacci(10))# 输出：55（斐波那契数列：0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55）# 递归遍历目录deflist_files(path):"""使用递归遍历目录下的所有文件"""import osfor item in os.listdir(path): item_path = os.path.join(path, item)if os.path.isfile(item_path):print(f"文件: {item_path}")else:print(f"目录: {item_path}") list_files(item_path)# 递归调用# 调用递归函数# list_files(".") # 遍历当前目录
4. 递归的优缺点
优点：
- 适合解决具有递归结构的问题，如树的遍历、图的搜索等
缺点：
5. 递归的优化
可以使用**记忆化（Memoization）**技术优化递归函数，避免重复计算：
# 递归优化（记忆化）示例# 使用装饰器实现记忆化defmemoize(func):"""记忆化装饰器""" cache ={}defwrapper(*args):if args notin cache: cache[args]= func(*args)return cache[args]return wrapper# 使用记忆化优化斐波那契数列deffibonacci(n):"""使用递归计算斐波那契数列的第n项"""if n <=1:return nreturn fibonacci(n -1)+ fibonacci(n -2)# 使用装饰器优化后的斐波那契数列@memoizedeffibonacci_memoized(n):"""使用记忆化递归计算斐波那契数列的第n项"""if n <=1:return nreturn fibonacci_memoized(n -1)+ fibonacci_memoized(n -2)# 测试性能import timen =35start_time = time.time()fibonacci(n)end_time = time.time()print(f"未优化的斐波那契数列（n={n}）耗时: {end_time - start_time:.4f}秒")start_time = time.time()fibonacci_memoized(n)end_time = time.time()print(f"优化后的斐波那契数列（n={n}）耗时: {end_time - start_time:.4f}秒")
九、生成器函数
1. 生成器函数概述
生成器函数是一种特殊的函数，它使用yield关键字代替return关键字返回值。生成器函数返回一个生成器对象，可以使用next()函数或for循环遍历生成器对象。
2. 生成器函数的基本原理
生成器函数的基本原理是：
- 调用生成器函数时，它返回一个生成器对象，而不是执行函数体
- 使用
next()函数或for循环遍历生成器对象时，函数体开始执行 - 当遇到
yield关键字时，函数返回yield后面的值，并暂停执行 - 再次调用
next()函数时，函数体从上次暂停的位置继续执行
3. 生成器函数示例
# 生成器函数示例defmy_generator():"""一个简单的生成器函数"""print("生成器函数开始执行")yield1print("生成器函数继续执行")yield2print("生成器函数继续执行")yield3print("生成器函数执行完毕")# 调用生成器函数，返回生成器对象gen = my_generator()print(gen)# 输出：<generator object my_generator at 0x...># 使用next()函数遍历生成器对象print(next(gen))# 输出：生成器函数开始执行# 1print(next(gen))# 输出：生成器函数继续执行# 2print(next(gen))# 输出：生成器函数继续执行# 3print(next(gen))# 输出：生成器函数执行完毕# 抛出StopIteration异常# 使用for循环遍历生成器对象gen = my_generator()for item in gen:print(item)# 输出：# 生成器函数开始执行# 1# 生成器函数继续执行# 2# 生成器函数继续执行# 3# 生成器函数执行完毕
4. 生成器函数的应用场景
生成器函数适用于以下场景：
# 生成器函数的应用场景示例# 生成无限序列definfinite_integers():"""生成无限整数序列""" i =0whileTrue:yield i i +=1# 使用无限序列gen = infinite_integers()for i inrange(10):print(next(gen), end=" ")print()# 输出：0 1 2 3 4 5 6 7 8 9# 生成斐波那契数列deffibonacci_generator(n):"""生成斐波那契数列的前n项""" a, b =0,1for _ inrange(n):yield a a, b = b, a + b# 使用生成器生成斐波那契数列for num in fibonacci_generator(10):print(num, end=" ")print()# 输出：0 1 1 2 3 5 8 13 21 34
十、函数的属性
函数也是对象，具有以下属性：
1. 内置属性
函数的内置属性包括：
__name____doc____module____annotations____code__
2. 自定义属性
可以为函数添加自定义属性：
# 函数属性示例defmy_function():"""一个简单的函数"""pass# 访问函数的内置属性print(f"函数名称: {my_function.__name__}")# 输出：函数名称: my_functionprint(f"函数文档: {my_function.__doc__}")# 输出：函数文档: 一个简单的函数print(f"函数所在模块: {my_function.__module__}")# 输出：函数所在模块: __main__# 添加自定义属性my_function.version ="1.0"my_function.author ="张三"# 访问自定义属性print(f"函数版本: {my_function.version}")# 输出：函数版本: 1.0print(f"函数作者: {my_function.author}")# 输出：函数作者: 张三
十一、函数的最佳实践
1. 函数命名
函数命名应遵循以下规则：
2. 函数长度
函数的长度应适中，通常建议不超过50行代码。如果函数过长，应考虑将其分解为多个更小的函数。
3. 函数参数
函数参数应遵循以下规则：
- 使用*args和**kwargs处理可变数量的参数
- 参数顺序应为：位置参数 → 默认参数 → 可变位置参数 → 可变关键字参数
4. 函数文档
应为每个函数编写文档字符串，描述函数的功能、参数和返回值。
5. 函数返回值
函数返回值应遵循以下规则：
6. 错误处理
函数应包含适当的错误处理机制，如异常处理、参数验证等。
7. 代码复用
应避免重复代码，将重复的代码封装为函数。
8. 测试
应为每个函数编写测试用例，确保函数的正确性。
十二、常见错误
1. 参数传递错误
参数传递错误包括：
# 参数传递错误示例defadd(a, b):"""计算两个数的和"""return a + b# 错误：参数数量不匹配add(1)# 抛出TypeError异常# 错误：参数类型不匹配add("1",2)# 抛出TypeError异常（Python 3）# 错误：参数顺序错误# 在某些情况下可能不会抛出异常，但结果可能不正确
2. 作用域错误
作用域错误包括：
- 在函数内部修改全局变量时，忘记使用global关键字
- 在嵌套函数内部修改外部函数的变量时，忘记使用nonlocal关键字
# 作用域错误示例# 错误：在函数外部访问局部变量defmy_function(): local_var ="局部变量"print(local_var)# 抛出NameError异常# 错误：在函数内部修改全局变量时，忘记使用global关键字global_var ="全局变量"defmy_function(): global_var ="修改后的全局变量"# 创建了一个新的局部变量my_function()print(global_var)# 输出：全局变量（全局变量没有被修改）
3. 递归错误
递归错误包括：
# 递归错误示例# 错误：缺少基本情况，导致无限递归deffactorial(n):"""计算n的阶乘"""return n * factorial(n -1)# 缺少基本情况factorial(5)# 抛出RecursionError异常（递归深度过大）# 错误：递归深度过大，导致栈溢出Python的默认递归深度限制约为1000defdeep_recursion(n):"""深度递归"""if n ==0:return0return deep_recursion(n -1)+1deep_recursion(1000)# 抛出RecursionError异常（递归深度超过限制）
十三、总结
函数是Python中用于封装可重用代码的基本构建块，通过函数，我们可以将复杂的程序分解为更小、更易于管理的模块。本文介绍了Python函数的以下核心概念和高级用法：
函数定义与调用：
函数参数：
- 可变位置参数（*args）、可变关键字参数（**kwargs）
函数返回值：
函数的作用域：
Lambda函数：
装饰器：
递归函数：
生成器函数：
函数的属性：
函数的最佳实践：
通过掌握Python函数的各种概念和用法，可以编写出更简洁、更高效、更易维护的Python代码。
发布网站：荣殿教程（zhangrongdian.com）
作者：张荣殿
10个月宝宝每天需要喝多少奶粉？
