Python return函数返回值

Python中的函数通过return语句返回值给调用者。理解return的工作原理对于编写高效的Python代码至关重要。

基本用法

return语句的基本语法非常简单：

登录后复制def 函数名(参数列表):

# 函数体

return 返回值

1.2.3.

当Python执行到return语句时，函数会立即终止执行并将指定的值返回给调用者。

示例1：返回单个值

登录后复制def 计算平方(数字):

结果 = 数字 * 数字

return 结果

# 调用函数并接收返回值

平方结果 = 计算平方(5)

print(平方结果) # 输出: 25

1.2.3.4.5.6.7.

示例2：提前返回

return语句可以用于在满足特定条件时提前结束函数执行：

登录后复制def 检查年龄(年龄):

if 年龄 < 0:

return "年龄不能为负数"

if 年龄 < 18:

return "未成年"

return "成年人"

print(检查年龄(-5)) # 输出: 年龄不能为负数

print(检查年龄(16)) # 输出: 未成年

print(检查年龄(20)) # 输出: 成年人

1.2.3.4.5.6.7.8.9.10.

示例3：不带值的return

如果return语句不带任何值，或者函数没有return语句，函数将返回None：

登录后复制def 无返回值函数():

print("这个函数没有返回值")

return

结果 = 无返回值函数()

print(结果) # 输出: None

1.2.3.4.5.6.

注意事项

return语句后的代码不会执行一个函数可以有多个return语句，但只有一个会被执行可以返回任何类型的数据，包括列表、字典、对象等

Python函数怎样返回多个值？

Python函数可以轻松地返回多个值，这是许多其他编程语言所不具备的特性。

使用元组返回多个值

最常见的方法是通过元组返回多个值：

登录后复制def 获取个人信息():

姓名 = "张三"

年龄 = 30

职业 = "程序员"

return 姓名, 年龄, 职业 # 自动打包为元组

# 调用函数并解包返回值

姓名, 年龄, 职业 = 获取个人信息()

print(f"姓名: {姓名}, 年龄: {年龄}, 职业: {职业}")

# 也可以接收为单个元组

个人信息 = 获取个人信息()

print(个人信息) # 输出: ('张三', 30, '程序员')

print(个人信息[0]) # 访问第一个值: 张三

1.2.3.4.5.6.7.8.9.10.11.12.13.14.

使用列表返回多个值

当返回的值数量可能变化时，列表是一个好选择：

登录后复制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]

1.2.3.4.5.6.7.8.9.10.11.

使用字典返回多个值

当需要为返回的值提供标签时，字典是最佳选择：

登录后复制def 计算统计数据(数字列表):

return {

"总和": sum(数字列表),

"平均值": sum(数字列表) / len(数字列表),

"最大值": max(数字列表),

"最小值": min(数字列表),

"数量": len(数字列表)

}

统计结果 = 计算统计数据([10, 20, 30, 40, 50])

print(f"平均值: {统计结果['平均值']}")

print(f"最大值: {统计结果['最大值']}")

1.2.3.4.5.6.7.8.9.10.11.12.

使用类和对象返回复杂数据

对于更复杂的数据结构，可以使用自定义类：

登录后复制class 学生成绩单:

def __init__(self, 姓名, 成绩列表):

self.姓名 = 姓名

self.成绩列表 = 成绩列表

self.平均分 = sum(成绩列表) / len(成绩列表)

self.最高分 = max(成绩列表)

def 生成成绩单(姓名, 成绩列表):

return 学生成绩单(姓名, 成绩列表)

小明成绩单 = 生成成绩单("小明", [85, 92, 78, 90])

print(f"{小明成绩单.姓名}的平均分是{小明成绩单.平均分}")

1.2.3.4.5.6.7.8.9.10.11.12.

Python partial偏函数

偏函数(Partial Function)是Python functools模块中的一个重要功能，它允许我们固定函数的某些参数，从而创建一个新的函数。

基本概念

偏函数的主要用途是：

减少重复代码提高代码可读性创建特定场景的专用函数

基本用法

登录后复制from functools import partial

# 原始函数

def 幂运算(底数, 指数):

return 底数 ** 指数

# 创建平方函数 - 固定指数为2

平方 = partial(幂运算, 指数=2)

# 创建立方函数 - 固定指数为3

立方 = partial(幂运算, 指数=3)

# 使用偏函数

print(平方(4)) # 输出: 16

print(立方(4)) # 输出: 64

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.

实际应用场景

示例1：简化函数调用

登录后复制from functools import partial

def 格式化打印(内容, 前缀="", 后缀="", 是否换行=True):

结果 = f"{前缀}{内容}{后缀}"

if 是否换行:

print(结果)

else:

print(结果, end="")

# 创建特定格式的打印函数

错误打印 = partial(格式化打印, 前缀="错误: ", 后缀="!", 是否换行=True)

警告打印 = partial(格式化打印, 前缀="警告: ", 后缀=".", 是否换行=True)

错误打印("文件不存在") # 输出: 错误: 文件不存在!

警告打印("磁盘空间不足") # 输出: 警告: 磁盘空间不足.

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.

示例2：配合内置函数

登录后复制from functools import partial

# 创建一个只接收十进制数的int函数

二进制转十进制 = partial(int, base=2)

十六进制转十进制 = partial(int, base=16)

print(二进制转十进制("1010")) # 输出: 10

print(十六进制转十进制("1A")) # 输出: 26

1.2.3.4.5.6.7.8.

示例3：配合排序函数

登录后复制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"{学生['姓名']}: {学生['成绩']}分")

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.

注意事项

偏函数不会修改原始函数可以固定位置参数和关键字参数创建偏函数时未指定的参数在调用时需要提供

从实例出发，攻克Python函数递归

递归是一种函数调用自身的编程技术，适合解决可以分解为相似子问题的任务。

递归的基本结构

一个典型的递归函数包含两个部分：

基本情况(Base Case) - 不再递归调用的终止条件递归情况(Recursive Case) - 函数调用自身的情况

登录后复制def 递归函数(参数):

# 基本情况 - 终止递归

if 终止条件:

return 基本结果

# 递归情况 - 调用自身

return 递归函数(新参数)

1.2.3.4.5.6.7.

示例1：计算阶乘

阶乘是递归的经典应用：

登录后复制def 阶乘(n):

# 基本情况

if n == 0 or n == 1:

return 1

# 递归情况

return n * 阶乘(n-1)

print(阶乘(5)) # 输出: 120 (5*4*3*2*1)

1.2.3.4.5.6.7.8.9.

递归过程分析：

登录后复制阶乘(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 (基本情况)1.2.3.4.5.

示例2：斐波那契数列

斐波那契数列是另一个递归的经典例子：

登录后复制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)}")

1.2.3.4.5.6.7.8.9.10.11.12.

输出：

登录后复制斐波那契(0) = 0

斐波那契(1) = 1

斐波那契(2) = 1

斐波那契(3) = 2

斐波那契(4) = 3

斐波那契(5) = 5

斐波那契(6) = 8

斐波那契(7) = 13

斐波那契(8) = 21

斐波那契(9) = 341.2.3.4.5.6.7.8.9.10.

示例3：递归遍历目录

递归非常适合处理树形结构，如文件系统：

登录后复制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/用户名/文档")

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.

递归的优化：记忆化

简单递归在处理大规模问题时可能效率低下。以斐波那契数列为例，可以使用记忆化技术优化：

登录后复制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}秒")

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.

递归的注意事项

递归深度限制：Python默认限制递归深度为1000，可以通过sys.setrecursionlimit()修改栈溢出风险：过深的递归可能导致栈溢出性能考虑：某些情况下，循环可能比递归更高效尾递归：在函数的最后一步调用自身的递归，某些语言会进行优化(但Python不会)

何时使用递归

递归特别适合以下场景：

问题可以分解为相似的子问题数据结构是分层或树形的(如文件系统、XML解析)回溯算法分治算法(如快速排序、归并排序)

通过这些实例，你应该能够理解递归的基本原理和应用场景，为解决更复杂的问题打下基础。