Python中一个函数返回多个值的实现方法

def divide_with_remainder(dividend, divisor):
    """计算除法并返回商和余数"""
    if divisor == 0:
        return None, None  # 错误情况下的处理
    
    quotient = dividend // divisor
    remainder = dividend % divisor
    return quotient, remainder

# 使用示例
result_quotient, result_remainder = divide_with_remainder(17, 5)
print(f"17 ÷ 5 = {result_quotient} 余 {result_remainder}")
# 输出: 17 ÷ 5 = 3 余 2

def get_name_age():
    """返回姓名和年龄"""
    name = "Alice"
    age = 25
    return name, age  # 自动打包成元组

# 调用函数
person_name, person_age = get_name_age()
print(f"姓名: {person_name}, 年龄: {person_age}")
# 输出: 姓名: Alice, 年龄: 25

# 或者接收整个元组
result = get_name_age()
print(result)  # 输出: ('Alice', 25)
print(type(result))  # 输出: <class 'tuple'>

def calculate_stats(numbers):
    """计算数字列表的基本统计信息"""
    if not numbers:
        return None, None, None
    
    total = sum(numbers)
    count = len(numbers)
    average = total / count
    
    return total, count, average

# 多种解包方式
numbers = [10, 20, 30, 40, 50]

# 方式1: 完全解包
total_sum, count, avg = calculate_stats(numbers)
print(f"总和: {total_sum}, 数量: {count}, 平均值: {avg}")

# 方式2: 部分解包（Python 3.x）
first, *rest = calculate_stats(numbers)
print(f"第一个值: {first}, 其他值: {rest}")

# 方式3: 忽略某些值
total_sum, _, avg = calculate_stats(numbers)
print(f"总和: {total_sum}, 平均值: {avg}")

# 方式4: 接收整个元组
stats = calculate_stats(numbers)
print(f"统计信息: {stats}")

import datetime

def analyze_user_data(user_info):
    """
    分析用户数据并返回多个指标
    返回: (活跃度等级, 注册天数, 是否为VIP)
    """
    registration_date = user_info.get('registration_date')
    login_count = user_info.get('login_count', 0)
    is_vip = user_info.get('is_vip', False)
    
    # 计算注册天数
    if registration_date:
        days_registered = (datetime.date.today() - registration_date).days
    else:
        days_registered = 0
    
    # 根据登录次数确定活跃度等级
    if login_count > 100:
        activity_level = "高"
    elif login_count > 50:
        activity_level = "中"
    else:
        activity_level = "低"
    
    return activity_level, days_registered, is_vip

# 使用示例
user = {
    'registration_date': datetime.date(2023, 1, 1),
    'login_count': 75,
    'is_vip': True
}

level, days, vip_status = analyze_user_data(user)
print(f"用户活跃度: {level}")
print(f"注册天数: {days}")
print(f"VIP状态: {vip_status}")

def get_coordinates():
    """返回坐标点"""
    x = 10
    y = 20
    z = 30
    return [x, y, z]  # 使用列表

# 使用示例
coordinates = get_coordinates()
print(f"X坐标: {coordinates[0]}")
print(f"Y坐标: {coordinates[1]}")
print(f"Z坐标: {coordinates[2]}")

# 也可以解包
x, y, z = get_coordinates()
print(f"坐标: ({x}, {y}, {z})")

def get_weather_info(city):
    """获取城市天气信息"""
    # 模拟API调用
    weather_data = {
        'temperature': 25,
        'humidity': 60,
        'pressure': 1013,
        'condition': '晴朗'
    }
    
    return weather_data

# 使用示例
weather = get_weather_info("北京")
print(f"温度: {weather['temperature']}°C")
print(f"湿度: {weather['humidity']}%")
print(f"气压: {weather['pressure']}hPa")
print(f"天气状况: {weather['condition']}")

# 更优雅的访问方式
temp = weather.get('temperature', '未知')
humid = weather.get('humidity', '未知')
print(f"温度: {temp}°C, 湿度: {humid}%")

from collections import namedtuple

# 定义命名元组
WeatherInfo = namedtuple('WeatherInfo', ['temperature', 'humidity', 'pressure', 'condition'])

def get_structured_weather(city):
    """获取结构化天气信息"""
    # 模拟数据
    data = WeatherInfo(
        temperature=25,
        humidity=60,
        pressure=1013,
        condition='晴朗'
    )
    return data

# 使用示例
weather = get_structured_weather("上海")
print(f"温度: {weather.temperature}°C")
print(f"湿度: {weather.humidity}%")
print(f"气压: {weather.pressure}hPa")
print(f"天气: {weather.condition}")

# 仍然可以像普通元组一样使用
temp, humid, press, cond = weather
print(f"解包后: {temp}°C, {humid}%, {press}hPa, {cond}")

from collections import namedtuple

# 定义不同类型的数据结构
Point = namedtuple('Point', ['x', 'y'])
Person = namedtuple('Person', ['name', 'age', 'email'])
DatabaseResult = namedtuple('DatabaseResult', ['success', 'data', 'error_message'])

def create_point(x, y):
    """创建一个点"""
    return Point(x=x, y=y)

def validate_person(name, age, email):
    """验证人员信息"""
    if not name or age < 0 or not email:
        return DatabaseResult(success=False, data=None, error_message="无效的输入")
    
    person = Person(name=name, age=age, email=email)
    return DatabaseResult(success=True, data=person, error_message=None)

# 使用示例
point = create_point(10, 20)
print(f"点坐标: ({point.x}, {point.y})")

result = validate_person("Bob", 30, "bob@example.com")
if result.success:
    print(f"验证成功: {result.data.name}, {result.data.age}岁")
else:
    print(f"验证失败: {result.error_message}")

from dataclasses import dataclass
from typing import Optional

@dataclass
class CalculationResult:
    """计算结果数据类"""
    success: bool
    value: float
    message: str = ""
    details: Optional[dict] = None

def safe_divide(a, b):
    """安全除法运算"""
    if b == 0:
        return CalculationResult(
            success=False,
            value=0.0,
            message="除数不能为零",
            details={'dividend': a, 'divisor': b}
        )
    
    result = a / b
    return CalculationResult(
        success=True,
        value=result,
        message=f"{a} ÷ {b} = {result}",
        details={'dividend': a, 'divisor': b, 'quotient': result}
    )

# 使用示例
calc_result = safe_divide(10, 2)
if calc_result.success:
    print(f"计算成功: {calc_result.message}")
    print(f"详细信息: {calc_result.details}")

calc_result2 = safe_divide(10, 0)
if not calc_result2.success:
    print(f"计算失败: {calc_result2.message}")
    print(f"错误详情: {calc_result2.details}")

def fibonacci_sequence(n):
    """生成斐波那契数列的前n项"""
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

def process_data_stream(data_list):
    """处理数据流并返回多个统计值"""
    processed_count = 0
    total_sum = 0
    max_value = float('-inf')
    
    for item in data_list:
        processed_count += 1
        total_sum += item
        max_value = max(max_value, item)
        
        # 逐步返回中间结果
        yield {
            'processed_count': processed_count,
            'current_sum': total_sum,
            'max_so_far': max_value
        }

# 使用示例
data = [1, 5, 3, 9, 2, 7, 4]
print("处理进度:")
for step_result in process_data_stream(data):
    print(f"已处理{step_result['processed_count']}项, "
          f"当前总和:{step_result['current_sum']}, "
          f"最大值:{step_result['max_so_far']}")

# 获取最终结果
final_results = list(process_data_stream(data))
last_result = final_results[-1]
print(f"\n最终结果: {last_result}")

def robust_calculation(a, b):
    """
    稳健的计算函数，返回计算结果和状态信息
    返回: (success, result, error_message)
    """
    try:
        # 执行可能出错的操作
        if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
            raise TypeError("参数必须是数字")
        
        if b == 0:
            raise ZeroDivisionError("除数不能为零")
        
        result = a / b
        return True, result, None
        
    except (TypeError, ZeroDivisionError) as e:
        return False, None, str(e)
    except Exception as e:
        return False, None, f"未知错误: {str(e)}"

# 使用示例
success, result, error = robust_calculation(10, 2)
if success:
    print(f"计算结果: {result}")
else:
    print(f"计算失败: {error}")

success, result, error = robust_calculation(10, 0)
if success:
    print(f"计算结果: {result}")
else:
    print(f"计算失败: {error}")

import time
from collections import namedtuple
from dataclasses import dataclass

# 定义不同的返回类型
PointTuple = namedtuple('PointTuple', ['x', 'y', 'z'])
@dataclass
class PointDataClass:
    x: float
    y: float
    z: float

def return_tuple():
    """返回元组"""
    return (1.0, 2.0, 3.0)

def return_namedtuple():
    """返回命名元组"""
    return PointTuple(1.0, 2.0, 3.0)

def return_dict():
    """返回字典"""
    return {'x': 1.0, 'y': 2.0, 'z': 3.0}

def return_dataclass():
    """返回数据类"""
    return PointDataClass(1.0, 2.0, 3.0)

def return_list():
    """返回列表"""
    return [1.0, 2.0, 3.0]

# 性能测试函数
def performance_test(func, iterations=1000000):
    """测试函数性能"""
    start_time = time.time()
    for _ in range(iterations):
        result = func()
    end_time = time.time()
    return end_time - start_time

# 运行性能测试
functions = [
    ('元组', return_tuple),
    ('命名元组', return_namedtuple),
    ('字典', return_dict),
    ('数据类', return_dataclass),
    ('列表', return_list)
]

print("性能测试结果 (100万次调用):")
print("-" * 40)
for name, func in functions:
    elapsed_time = performance_test(func)
    print(f"{name:8}: {elapsed_time:.4f} 秒")

def query_user_profile(user_id):
    """
    查询用户资料
    返回: (用户对象, 是否存在, 错误信息)
    """
    # 模拟数据库查询
    users_db = {
        1: {'name': 'Alice', 'email': 'alice@example.com', 'age': 25},
        2: {'name': 'Bob', 'email': 'bob@example.com', 'age': 30}
    }
    
    try:
        user_data = users_db.get(user_id)
        if user_data:
            return user_data, True, None
        else:
            return None, False, "用户不存在"
    except Exception as e:
        return None, False, f"查询错误: {str(e)}"

# 使用示例
user, exists, error = query_user_profile(1)
if exists:
    print(f"找到用户: {user['name']}")
elif error:
    print(f"查询失败: {error}")
else:
    print("用户不存在")

import os

def process_file(file_path):
    """
    处理文件并返回处理结果
    返回: (处理成功, 文件大小, 行数, 错误信息)
    """
    try:
        # 检查文件是否存在
        if not os.path.exists(file_path):
            return False, 0, 0, "文件不存在"
        
        # 获取文件大小
        file_size = os.path.getsize(file_path)
        
        # 统计行数
        line_count = 0
        with open(file_path, 'r', encoding='utf-8') as f:
            for line in f:
                line_count += 1
        
        return True, file_size, line_count, None
        
    except PermissionError:
        return False, 0, 0, "没有权限访问文件"
    except UnicodeDecodeError:
        return False, 0, 0, "文件编码错误"
    except Exception as e:
        return False, 0, 0, f"处理文件时出错: {str(e)}"

# 创建测试文件
test_content = """第一行
第二行
第三行
第四行"""

with open('test.txt', 'w', encoding='utf-8') as f:
    f.write(test_content)

# 使用示例
success, size, lines, error = process_file('test.txt')
if success:
    print(f"文件处理成功!")
    print(f"文件大小: {size} 字节")
    print(f"行数: {lines}")
else:
    print(f"文件处理失败: {error}")

# 清理测试文件
os.remove('test.txt')

import json
from typing import Tuple, Dict, Any, Optional

def parse_api_response(response_text: str) -> Tuple[bool, Optional[Dict], str]:
    """
    解析API响应
    返回: (解析成功, 数据, 错误信息)
    """
    try:
        data = json.loads(response_text)
        
        # 检查API响应格式
        if 'status' not in data:
            return False, None, "响应缺少status字段"
        
        if data['status'] != 'success':
            error_msg = data.get('message', 'API调用失败')
            return False, None, error_msg
        
        return True, data.get('data'), "解析成功"
        
    except json.JSONDecodeError as e:
        return False, None, f"JSON解析错误: {str(e)}"
    except Exception as e:
        return False, None, f"未知错误: {str(e)}"

# 使用示例
# 成功响应
success_response = '{"status": "success", "data": {"user_id": 123, "username": "john"}}'
success, data, message = parse_api_response(success_response)
if success:
    print(f"API调用成功: {data}")
else:
    print(f"API调用失败: {message}")

# 失败响应
error_response = '{"status": "error", "message": "用户未找到"}'
success, data, message = parse_api_response(error_response)
if success:
    print(f"API调用成功: {data}")
else:
    print(f"API调用失败: {message}")

# 错误JSON
invalid_response = '{"status": "success", "data": }'  # 语法错误
success, data, message = parse_api_response(invalid_response)
if success:
    print(f"API调用成功: {data}")
else:
    print(f"API调用失败: {message}")

from functools import wraps
from typing import Callable, Any

def add_metadata(func: Callable) -> Callable:
    """装饰器：为函数返回值添加元数据"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        metadata = {
            'function_name': func.__name__,
            'arguments': {'args': args, 'kwargs': kwargs},
            'timestamp': __import__('time').time()
        }
        return result, metadata
    return wrapper

@add_metadata
def calculate_area(length, width):
    """计算矩形面积"""
    return length * width

# 使用示例
area, meta = calculate_area(10, 5)
print(f"面积: {area}")
print(f"调用函数: {meta['function_name']}")
print(f"参数: {meta['arguments']}")
print(f"时间戳: {meta['timestamp']}")

class DatabaseConnection:
    """模拟数据库连接"""
    def __init__(self):
        self.connected = False
        self.connection_id = None
    
    def connect(self):
        """连接数据库"""
        self.connected = True
        self.connection_id = id(self)
        return self.connected, self.connection_id, "连接成功"
    
    def disconnect(self):
        """断开连接"""
        self.connected = False
        return self.connected, "断开连接成功"
    
    def execute_query(self, sql):
        """执行查询"""
        if not self.connected:
            return None, False, "未连接到数据库"
        
        # 模拟查询结果
        result = f"查询结果: {sql}"
        return result, True, "查询成功"

# 使用示例
db = DatabaseConnection()

# 连接数据库
connected, conn_id, msg = db.connect()
print(f"连接状态: {connected}, ID: {conn_id}, 消息: {msg}")

# 执行查询
result, success, message = db.execute_query("SELECT * FROM users")
if success:
    print(f"查询结果: {result}")
else:
    print(f"查询失败: {message}")

# 断开连接
disconnected, msg = db.disconnect()
print(f"断开状态: {disconnected}, 消息: {msg}")

import asyncio
from typing import Tuple

async def fetch_user_data(user_id: int) -> Tuple[bool, dict, str]:
    """异步获取用户数据"""
    try:
        # 模拟网络请求延迟
        await asyncio.sleep(1)
        
        # 模拟用户数据
        user_data = {
            'id': user_id,
            'name': f'User_{user_id}',
            'email': f'user{user_id}@example.com'
        }
        
        return True, user_data, "获取成功"
        
    except Exception as e:
        return False, {}, f"获取失败: {str(e)}"

async def main():
    """主函数"""
    print("开始获取用户数据...")
    
    # 同时获取多个用户数据
    tasks = [
        fetch_user_data(1),
        fetch_user_data(2),
        fetch_user_data(3)
    ]
    
    results = await asyncio.gather(*tasks)
    
    for i, (success, data, message) in enumerate(results, 1):
        if success:
            print(f"用户{i}: {data['name']} - {message}")
        else:
            print(f"用户{i}: {message}")

# 运行异步函数
# asyncio.run(main())

# 对于简单、固定数量的值，使用元组
def get_coordinates():
    return 10, 20, 30

# 对于有明确含义的值，使用命名元组或数据类
from collections import namedtuple
UserStats = namedtuple('UserStats', ['login_count', 'last_login', 'is_active'])

def get_user_stats(user_id):
    # ... 处理逻辑
    return UserStats(login_count=100, last_login='2023-01-01', is_active=True)

# 对于复杂或动态的数据结构，使用字典
def get_detailed_report():
    return {
        'summary': '报告摘要',
        'details': [...],
        'metadata': {...}
    }

# 好的做法：所有数据库相关函数都返回相同格式
def find_user_by_id(user_id):
    """返回: (用户对象, 是否找到, 错误信息)"""
    pass

def find_user_by_email(email):
    """返回: (用户对象, 是否找到, 错误信息)"""
    pass

def update_user(user_id, data):
    """返回: (更新后的用户, 更新成功, 错误信息)"""
    pass

def complex_calculation(input_data):
    """
    执行复杂计算
    
    Args:
        input_data (dict): 输入数据
        
    Returns:
        tuple: 包含以下元素的元组:
            - bool: 计算是否成功
            - float: 计算结果
            - str: 状态消息
            - dict: 详细信息
            
    Example:
        >>> success, result, message, details = complex_calculation(data)
        >>> if success:
        ...     print(f"结果: {result}")
    """
    # 实现逻辑
    pass