Python 函数 return 多个数据：用法、实例与实战技巧

在 Python 编程中，函数是代码复用与逻辑封装的核心载体。多数场景下，我们需要函数返回单一结果（如计算两数之和返回一个数值），但实际开发中，常遇到 “一次调用需获取多个关联结果” 的需求 —— 例如计算矩形的 “面积与周长”、分析数据集的 “总和与均值”、查询用户信息时返回 “姓名、年龄与订单数量”。此时，Python 支持的 “函数 return 多个数据” 功能便成为高效解决方案。本文将从基础原理出发，通过丰富实例讲解其用法，结合实战场景说明应用技巧，帮助开发者灵活应对多结果返回需求。

一、为什么需要函数返回多个数据？—— 场景与价值

在未掌握多数据返回前，若需函数输出多个结果，往往需借助 “全局变量”“列表临时存储” 或 “多次函数调用”，这些方式存在明显缺陷：

• 全局变量：易造成变量污染，破坏函数封装性；

• 列表临时存储：需手动解析列表元素含义，可读性差；

• 多次调用：重复执行函数逻辑（如重复遍历数据集计算总和与均值），降低效率。

而 Python 的多数据返回功能，可直接通过一个函数调用获取多个关联结果，兼具 “效率、可读性、封装性” 三大优势，适用于以下核心场景：

1. 数据统计分析：一次返回数据集的 “总和、均值、中位数、标准差”；

2. 多结果计算：如几何图形的 “面积与周长”、两数的 “和、差、积、商”；

3. 业务信息查询：返回用户的 “基础信息（姓名 / 年龄）+ 业务数据（订单数 / 消费额）”；

4. 状态与结果同步：返回 “操作是否成功（布尔值）+ 结果数据 / 错误信息”。

二、Python 函数返回多个数据的本质：不是 “多值返回”，而是 “容器封装”

Python 并不支持真正意义上的 “多值返回”，其底层逻辑是：将多个数据封装成一个 “容器对象”（如元组、列表、字典），函数实际返回的是这个容器，再通过 “解包” 操作提取其中的多个数据。

其中，元组（tuple）是默认的封装类型—— 当函数 return 后紧跟多个数据时，Python 会自动将其打包为元组；若需明确指定容器类型，也可手动封装为列表、字典或自定义对象。

理解这一本质，能帮助我们避免 “多值返回” 的认知误区，更灵活地选择封装方式。

三、不同类型的多数据返回实例：从基础到进阶

根据返回容器的不同，Python 函数多数据返回可分为 “元组返回（默认）”“列表返回”“字典返回”“对象返回” 四类，各自适用于不同场景，以下结合实例详细说明。

（一）默认方式：返回元组（最常用，简洁高效）

当函数 return 多个数据且未指定容器时，Python 会自动将其打包为元组。调用函数时，可通过 “变量解包” 直接获取单个数据，无需手动解析元组。

实例 1：计算矩形的面积与周长

def calculate_rectangle(length, width):

   """计算矩形的面积与周长，返回两个结果"""

   area = length * width  # 面积 = 长 × 宽

   perimeter = 2 * (length + width)  # 周长 = 2×(长+宽)

   return area, perimeter  # 自动打包为元组 (area, perimeter)

# 调用函数：解包元组，将两个结果分别赋值给变量

rect_area, rect_perimeter = calculate_rectangle(5, 3)

# 输出结果

print(f"矩形面积：{rect_area}")  # 输出：矩形面积：15

print(f"矩形周长：{rect_perimeter}")  # 输出：矩形周长：16

关键说明：

• 函数返回时无需写括号（return (area, perimeter) 与 return area, perimeter 效果一致），Python 默认打包为元组；

• 解包时，变量数量需与返回数据数量一致（若多写变量会报错，少写则获取部分数据，需用 _ 忽略无关值，如 rect_area, _ = calculate_rectangle(5, 3) 仅获取面积）；

• 适用场景：返回数据关联紧密、数量固定且无需明确标识（如 “面积与周长”“和与差”）。

（二）灵活选择：返回列表（支持动态修改结果）

若返回的多个数据需要后续修改（如添加、删除元素），可手动将数据封装为列表返回。列表与元组的核心区别是 “可变性”，因此列表更适合 “需二次处理结果” 的场景。

实例 2：分析列表的 “极值与元素个数”

def analyze_list(num_list):

   """分析数字列表，返回最大值、最小值、元素个数（列表形式）"""

   if not num_list:  # 处理空列表场景

       return [None, None, 0]

   max_val = max(num_list)

   min_val = min(num_list)

   count = len(num_list)

   return [max_val, min_val, count]  # 手动封装为列表

# 调用函数并获取结果

result = analyze_list([12, 5, 23, 8, 3])

print("原始结果：", result)  # 输出：原始结果：[23, 5, 5]

# 对返回的列表进行二次修改（如添加平均值）

avg_val = sum(result[:2]) / 2  # 计算最大最小值的平均值

result.append(avg_val)

print("添加平均值后的结果：", result)  # 输出：添加平均值后的结果：[23, 5, 5, 14.0]

关键说明：

• 列表返回需手动用 [] 封装数据，后续可通过列表方法（append/insert/pop）修改结果；

• 适用场景：返回数据需二次加工（如添加额外计算结果）、数据数量可能动态变化。

（三）清晰标识：返回字典（明确数据含义，可读性优先）

当返回数据较多或需要明确区分每个结果的含义时，使用字典返回是最佳选择 —— 字典的 “键（key）” 可直接标识数据语义，避免 “通过索引猜含义” 的问题，尤其适合团队协作场景。

实例 3：获取学生的 “成绩详情”

def get_student_grade(student_id):

   """根据学生ID，返回成绩详情（字典形式，含科目分数、总分、等级）"""

   # 模拟从数据库获取数据（实际开发中替换为真实查询逻辑）

   grades = {

       "math": 92,

       "english": 88,

       "python": 95

   }

   total = sum(grades.values())  # 计算总分

   avg = total / len(grades)     # 计算平均分

  

   # 判定等级

   if avg >= 90:

       level = "A"

   elif avg >= 80:

       level = "B"

   else:

       level = "C"

  

   # 返回字典：键明确标识数据含义

   return {

       "student_id": student_id,

       "subject_grades": grades,

       "total_score": total,

       "average_score": round(avg, 1),  # 保留1位小数

       "grade_level": level

   }

# 调用函数，通过字典键获取指定结果

student_result = get_student_grade("2025001")

print(f"学生{student_result['student_id']}总分：{student_result['total_score']}")

print(f"平均分：{student_result['average_score']}，等级：{student_result['grade_level']}")

print(f"Python成绩：{student_result['subject_grades']['python']}")

# 输出结果：

# 学生2025001总分：275

# 平均分：91.7，等级：A

# Python成绩：95

关键说明：

• 字典的键需具备语义化（如 total_score“grade_level”），避免使用无意义的键（如 key1“key2”）；

• 调用时通过 字典名['键名'] 提取数据，无需记忆索引位置，可读性极强；

• 适用场景：返回数据较多（3 个以上）、需明确区分数据含义、团队协作或接口开发（需给调用方清晰的数据说明）。

（四）复杂场景：返回自定义对象（结构化数据的终极方案）

当返回数据包含 “属性” 与 “方法”（如用户信息不仅有基本字段，还需验证手机号格式）时，可定义一个类，让函数返回该类的对象 —— 这是面向对象编程中处理复杂结构化数据的标准方式。

实例 4：返回 “用户信息对象” 并调用对象方法

class User:

   """用户类：封装用户属性与方法"""

   def __init__(self, name, age, phone, order_count):

       self.name = name          # 姓名

       self.age = age            # 年龄

       self.phone = phone        # 手机号

       self.order_count = order_count  # 订单数量


   def is_adult(self):

       """判断是否为成年人"""

       return self.age >= 18



   def format_phone(self):

       """格式化手机号（如138****1234）"""

       if len(self.phone) == 11:

           return f"{self.phone[:3]}****{self.phone[7:]}"

       return "手机号格式错误"

def get_user_info(user_id):

   """根据用户ID，返回User对象（含属性与方法）"""

   # 模拟数据库查询结果

   user_data = {

       "name": "张三",

       "age": 25,

       "phone": "13812345678",

       "order_count": 12

   }

   # 返回User对象，封装所有属性与方法

   return User(

       name=user_data["name"],

       age=user_data["age"],

       phone=user_data["phone"],

       order_count=user_data["order_count"]

   )

# 调用函数获取User对象，访问属性与调用方法

user = get_user_info("U20250815")

print(f"用户名：{user.name}，订单数：{user.order_count}")

print(f"是否成年：{user.is_adult()}")

print(f"格式化手机号：{user.format_phone()}")

# 输出结果：

# 用户名：张三，订单数：12

# 是否成年：True

# 格式化手机号：138****5678

关键说明：

• 自定义对象将 “数据（属性）” 与 “逻辑（方法）” 封装在一起，适合处理复杂业务（如用户信息验证、订单数据计算）；

• 适用场景：返回数据需关联业务逻辑（如验证、格式化、计算）、数据结构复杂且需复用（如在多个函数中传递同一类数据）。

四、实战场景：多数据返回函数的典型应用

场景 1：数据处理 —— 计算数据集的核心统计指标

import statistics

def get_data_stats(data):

   """计算数据集的核心统计指标：总和、均值、中位数、标准差"""

   if not data:

       return None, None, None, None  # 空数据返回None

   total = sum(data)

   mean = statistics.mean(data)

   median = statistics.median(data)

   std_dev = statistics.stdev(data) if len(data) > 1 else 0  # 标准差需至少2个数据

   return total, mean, median, std_dev

# 测试：分析月度销售额数据

sales_data = [52000, 68000, 75000, 63000, 81000]

total_sales, avg_sales, median_sales, std_sales = get_data_stats(sales_data)

print(f"月度总销售额：{total_sales:,}元")

print(f"月均销售额：{avg_sales:,.1f}元")

print(f"销售额中位数：{median_sales:,}元")

print(f"销售额标准差：{std_sales:,.1f}元")  # 反映数据波动程度

场景 2：业务逻辑 —— 用户登录验证与信息返回

def user_login(username, password):

   """用户登录验证：返回（登录状态，提示信息，用户数据）"""

   # 模拟用户数据库（实际为数据库查询）

   valid_users = {

       "admin": {"password": "123456", "role": "管理员", "login_count": 156},

       "user123": {"password": "abc789", "role": "普通用户", "login_count": 23}

   }


   # 验证逻辑

   if username not in valid_users:

       return False, "用户名不存在", None

   if valid_users[username]["password"] != password:

       return False, "密码错误", None



   # 登录成功：更新登录次数（模拟数据库更新）

   valid_users[username]["login_count"] += 1

   user_data = valid_users[username]

   return True, "登录成功", user_data

# 调用函数并处理结果

login_status, msg, user = user_login("admin", "123456")

if login_status:

   print(f"{msg}！用户角色：{user['role']}，累计登录次数：{user['login_count']}")

else:

   print(f"登录失败：{msg}")

五、使用注意事项与最佳实践

1. 解包时注意 “变量数量匹配”

函数返回的多数据需通过 “解包” 获取，若变量数量与返回数据数量不匹配，会触发 ValueError：

# 错误示例：返回2个数据，却用3个变量接收

area, perimeter, extra = calculate_rectangle(5, 3)  # 报错：too many values to unpack (expected 3)

# 正确处理：用`_`忽略无关数据（仅获取面积）

area, _ = calculate_rectangle(5, 3)

2. 优先选择 “语义化返回方式”

• 数据量≤2 个且关联紧密：用元组（简洁高效）；

• 数据量≥3 个或需明确含义：用字典（可读性优先）；

• 数据需关联业务逻辑：用自定义对象（结构化封装）；

• 避免用列表返回 “固定含义数据”（列表无语义标识，易混淆）。

3. 处理 “空数据” 或 “异常场景”

函数返回多数据时，需提前考虑异常情况（如空输入、计算错误），避免返回 “不完整数据”：

def divide_and_remainder(a, b):

   """计算两数的商与余数，处理除数为0的异常"""

   if b == 0:

       return None, None, "除数不能为0"  # 返回None+错误信息

   quotient = a // b

   remainder = a % b

   return quotient, remainder, "计算成功"

# 调用时判断异常

q, r, msg = divide_and_remainder(10, 0)

if q is None:

   print(f"错误：{msg}")

else:

   print(f"商：{q}，余数：{r}")

六、结语

Python 函数 return 多个数据，本质是 “容器封装 + 解包” 的语法糖，却极大提升了代码效率与可读性。从简单的元组返回，到复杂的对象返回，不同方式适用于不同场景 —— 核心原则是 “兼顾效率与可读性，贴合业务需求”。

在实际开发中，灵活运用多数据返回函数，可避免冗余代码（如多次函数调用）、减少变量污染（如替代全局变量），让代码更简洁、逻辑更清晰。无论是数据处理、业务逻辑，还是接口开发，多数据返回都是 Python 开发者必备的核心技巧之一。掌握其用法与最佳实践，能显著提升编程效率，应对更复杂的开发场景。

学习入口：https://edu.cda.cn/goods/show/3814?targetId=6587&preview=0

推荐学习书籍 《CDA一级教材》适合CDA一级考生备考，也适合业务及数据分析岗位的从业者提升自我。完整电子版已上线CDA网校，累计已有10万+在读~ !

免费加入阅读：https://edu.cda.cn/goods/show/3151?targetId=5147&preview=0