Python中的函数通过return
语句返回值给调用者。理解return
的工作原理对于编写高效的Python代码至关重要。
return
语句的基本语法非常简单:
def 函数名(参数列表):
# 函数体
return 返回值
当Python执行到return
语句时,函数会立即终止执行并将指定的值返回给调用者。
def 计算平方(数字):
结果 = 数字 * 数字
return 结果
# 调用函数并接收返回值
平方结果 = 计算平方(5)
print(平方结果) # 输出: 25
return
语句可以用于在满足特定条件时提前结束函数执行:
def 检查年龄(年龄):
if 年龄 < 0:
return "年龄不能为负数"
if 年龄 < 18:
return "未成年"
return "成年人"
print(检查年龄(-5)) # 输出: 年龄不能为负数
print(检查年龄(16)) # 输出: 未成年
print(检查年龄(20)) # 输出: 成年人
如果return
语句不带任何值,或者函数没有return
语句,函数将返回None
:
def 无返回值函数():
print("这个函数没有返回值")
return
结果 = 无返回值函数()
print(结果) # 输出: None
return
语句后的代码不会执行return
语句,但只有一个会被执行Python函数可以轻松地返回多个值,这是许多其他编程语言所不具备的特性。
最常见的方法是通过元组返回多个值:
def 获取个人信息():
姓名 = "张三"
年龄 = 30
职业 = "程序员"
return 姓名, 年龄, 职业 # 自动打包为元组
# 调用函数并解包返回值
姓名, 年龄, 职业 = 获取个人信息()
print(f"姓名: {姓名}, 年龄: {年龄}, 职业: {职业}")
# 也可以接收为单个元组
个人信息 = 获取个人信息()
print(个人信息) # 输出: ('张三', 30, '程序员')
print(个人信息[0]) # 访问第一个值: 张三
当返回的值数量可能变化时,列表是一个好选择:
def 获取成绩单(包含不及格=False):
所有成绩 = [85, 92, 78, 55, 60, 45, 98]
if not 包含不及格:
return [分数 for 分数 in 所有成绩 if 分数 >= 60]
return 所有成绩
及格成绩 = 获取成绩单()
print(及格成绩) # 输出: [85, 92, 78, 60, 98]
所有成绩 = 获取成绩单(True)
print(所有成绩) # 输出: [85, 92, 78, 55, 60, 45, 98]
当需要为返回的值提供标签时,字典是最佳选择:
def 计算统计数据(数字列表):
return {
"总和": sum(数字列表),
"平均值": sum(数字列表) / len(数字列表),
"最大值": max(数字列表),
"最小值": min(数字列表),
"数量": len(数字列表)
}
统计结果 = 计算统计数据([10, 20, 30, 40, 50])
print(f"平均值: {统计结果['平均值']}")
print(f"最大值: {统计结果['最大值']}")
对于更复杂的数据结构,可以使用自定义类:
class 学生成绩单:
def __init__(self, 姓名, 成绩列表):
self.姓名 = 姓名
self.成绩列表 = 成绩列表
self.平均分 = sum(成绩列表) / len(成绩列表)
self.最高分 = max(成绩列表)
def 生成成绩单(姓名, 成绩列表):
return 学生成绩单(姓名, 成绩列表)
小明成绩单 = 生成成绩单("小明", [85, 92, 78, 90])
print(f"{小明成绩单.姓名}的平均分是{小明成绩单.平均分}")
偏函数(Partial Function)是Python functools
模块中的一个重要功能,它允许我们固定函数的某些参数,从而创建一个新的函数。
偏函数的主要用途是:
from functools import partial
# 原始函数
def 幂运算(底数, 指数):
return 底数 ** 指数
# 创建平方函数 - 固定指数为2
平方 = partial(幂运算, 指数=2)
# 创建立方函数 - 固定指数为3
立方 = partial(幂运算, 指数=3)
# 使用偏函数
print(平方(4)) # 输出: 16
print(立方(4)) # 输出: 64
from functools import partial
def 格式化打印(内容, 前缀="", 后缀="", 是否换行=True):
结果 = f"{前缀}{内容}{后缀}"
if 是否换行:
print(结果)
else:
print(结果, end="")
# 创建特定格式的打印函数
错误打印 = partial(格式化打印, 前缀="错误: ", 后缀="!", 是否换行=True)
警告打印 = partial(格式化打印, 前缀="警告: ", 后缀=".", 是否换行=True)
错误打印("文件不存在") # 输出: 错误: 文件不存在!
警告打印("磁盘空间不足") # 输出: 警告: 磁盘空间不足.
from functools import partial
# 创建一个只接收十进制数的int函数
二进制转十进制 = partial(int, base=2)
十六进制转十进制 = partial(int, base=16)
print(二进制转十进制("1010")) # 输出: 10
print(十六进制转十进制("1A")) # 输出: 26
from functools import partial
学生列表 = [
{"姓名": "张三", "年龄": 18, "成绩": 85},
{"姓名": "李四", "年龄": 17, "成绩": 92},
{"姓名": "王五", "年龄": 19, "成绩": 78}
]
def 按键排序(列表, 键):
return sorted(列表, key=lambda x: x[键])
按年龄排序 = partial(按键排序, 键="年龄")
按成绩排序 = partial(按键排序, 键="成绩")
print("按年龄排序:")
for 学生 in 按年龄排序(学生列表):
print(f"{学生['姓名']}: {学生['年龄']}岁")
print("\n按成绩排序:")
for 学生 in 按成绩排序(学生列表):
print(f"{学生['姓名']}: {学生['成绩']}分")
递归是一种函数调用自身的编程技术,适合解决可以分解为相似子问题的任务。
一个典型的递归函数包含两个部分:
def 递归函数(参数):
# 基本情况 - 终止递归
if 终止条件:
return 基本结果
# 递归情况 - 调用自身
return 递归函数(新参数)
阶乘是递归的经典应用:
def 阶乘(n):
# 基本情况
if n == 0 or n == 1:
return 1
# 递归情况
return n * 阶乘(n-1)
print(阶乘(5)) # 输出: 120 (5*4*3*2*1)
递归过程分析:
阶乘(5) = 5 * 阶乘(4) = 5 * 24 = 120
阶乘(4) = 4 * 阶乘(3) = 4 * 6 = 24
阶乘(3) = 3 * 阶乘(2) = 3 * 2 = 6
阶乘(2) = 2 * 阶乘(1) = 2 * 1 = 2
阶乘(1) = 1 (基本情况)
斐波那契数列是另一个递归的经典例子:
def 斐波那契(n):
# 基本情况
if n <= 0:
return 0
elif n == 1:
return 1
# 递归情况
return 斐波那契(n-1) + 斐波那契(n-2)
for i in range(10):
print(f"斐波那契({i}) = {斐波那契(i)}")
输出:
斐波那契(0) = 0
斐波那契(1) = 1
斐波那契(2) = 1
斐波那契(3) = 2
斐波那契(4) = 3
斐波那契(5) = 5
斐波那契(6) = 8
斐波那契(7) = 13
斐波那契(8) = 21
斐波那契(9) = 34
递归非常适合处理树形结构,如文件系统:
import os
def 列出所有文件(目录, 缩进=0):
# 打印当前目录名
print(" " * 缩进 + f"📁 {os.path.basename(目录)}")
# 遍历目录中的所有项目
for 项目 in os.listdir(目录):
完整路径 = os.path.join(目录, 项目)
# 如果是目录,递归调用
if os.path.isdir(完整路径):
列出所有文件(完整路径, 缩进 + 2)
else:
# 如果是文件,直接打印
print(" " * (缩进 + 2) + f"📄 {项目}")
# 使用示例 (替换为实际路径)
# 列出所有文件("/Users/用户名/文档")
简单递归在处理大规模问题时可能效率低下。以斐波那契数列为例,可以使用记忆化技术优化:
def 优化斐波那契(n, 记忆={}):
# 检查是否已计算过
if n in 记忆:
return 记忆[n]
# 基本情况
if n <= 0:
return 0
elif n == 1:
return 1
# 递归计算并存储结果
记忆[n] = 优化斐波那契(n-1, 记忆) + 优化斐波那契(n-2, 记忆)
return 记忆[n]
# 比较优化前后的性能差异
import time
n = 35
开始时间 = time.time()
结果1 = 斐波那契(n)
结束时间 = time.time()
print(f"普通递归: 斐波那契({n}) = {结果1}, 耗时: {结束时间-开始时间:.2f}秒")
开始时间 = time.time()
结果2 = 优化斐波那契(n)
结束时间 = time.time()
print(f"优化递归: 斐波那契({n}) = {结果2}, 耗时: {结束时间-开始时间:.2f}秒")
sys.setrecursionlimit()
修改递归特别适合以下场景:
通过这些实例,你应该能够理解递归的基本原理和应用场景,为解决更复杂的问题打下基础。
扫码关注腾讯云开发者
领取腾讯云代金券
Copyright © 2013 - 2025 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有
深圳市腾讯计算机系统有限公司 ICP备案/许可证号:粤B2-20090059 深公网安备号 44030502008569
腾讯云计算(北京)有限责任公司 京ICP证150476号 | 京ICP备11018762号 | 京公网安备号11010802020287
Copyright © 2013 - 2025 Tencent Cloud.
All Rights Reserved. 腾讯云 版权所有