Python函数基础教程：定义、调用与参数传递指南

def function_name(parameters):
    """文档字符串 - 描述函数功能"""
    # 函数体
    return result  # 可选

def authenticate_user(username, password):
    """
    用户认证函数 - 验证用户名和密码
    
    Args:
        username: 用户名
        password: 密码
        
    Returns:
        bool: 认证成功返回True，失败返回False
    """
    # 模拟数据库查询
    valid_users = {
        "admin": "123456",
        "user1": "password1"
    }
    
    return username in valid_users and valid_users[username] == password
 
# 在TRAE IDE中，智能提示会显示参数类型和文档说明
result = authenticate_user("admin", "123456")
print(f"认证结果: {result}")  # 输出: 认证结果: True

# 使用类型注解增强代码可读性
def calculate_discount(price: float, discount_rate: float = 0.1) -> float:
    """计算折扣价格"""
    if price < 0 or discount_rate < 0 or discount_rate > 1:
        raise ValueError("价格和折扣率必须有效")
    
    return price * (1 - discount_rate)
 
# 在TRAE IDE中，类型注解会触发智能类型检查
total = calculate_discount(100.0, 0.2)  # IDE会提示参数类型

def process_data(data, operation="sum"):
    """数据处理函数"""
    if operation == "sum":
        return sum(data)
    elif operation == "avg":
        return sum(data) / len(data)
    elif operation == "max":
        return max(data)
    else:
        raise ValueError(f"不支持的操作: {operation}")
 
# 位置参数调用
numbers = [1, 2, 3, 4, 5]
print(process_data(numbers))           # 默认求和
print(process_data(numbers, "avg"))    # 计算平均值
print(process_data(numbers, "max"))    # 找出最大值

# 关键字参数让调用更加清晰
result = process_data(data=numbers, operation="avg")
 
# 混合使用位置和关键字参数
def create_user(name, age, city="北京", country="中国"):
    return {
        "name": name,
        "age": age,
        "city": city,
        "country": country
    }
 
# 灵活调用方式
user1 = create_user("张三", 25)
user2 = create_user("李四", 30, city="上海")
user3 = create_user("王五", 28, city="深圳", country="中国")

def logging_decorator(func):
    """日志装饰器 - 在TRAE IDE中可实时查看函数调用日志"""
    def wrapper(*args, **kwargs):
        print(f"[LOG] 调用函数: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"[LOG] 函数 {func.__name__} 执行完成")
        return result
    return wrapper
 
@logging_decorator
def complex_calculation(x, y):
    """复杂计算函数"""
    return x ** 2 + y ** 2
 
# 函数赋值和传递
calc_func = complex_calculation
result = calc_func(3, 4)  # 输出日志信息

def flexible_function(*args, **kwargs):
    """
    灵活参数函数 - 处理任意数量的参数
    
    *args: 接收任意数量的位置参数
    **kwargs: 接收任意数量的关键字参数
    """
    print(f"位置参数: {args}")
    print(f"关键字参数: {kwargs}")
    
    # 统计参数信息
    total_args = len(args) + len(kwargs)
    return total_args
 
# 不同调用方式
print(flexible_function(1, 2, 3))  # 只有位置参数
print(flexible_function(a=1, b=2))  # 只有关键字参数
print(flexible_function(1, 2, x=3, y=4))  # 混合参数

def advanced_math(a, b, c, d):
    """高级数学运算"""
    return a + b * c - d
 
# 列表解包
data_list = [1, 2, 3, 4]
result1 = advanced_math(*data_list)  # 等价于 advanced_math(1, 2, 3, 4)
 
# 字典解包
data_dict = {"a": 1, "b": 2, "c": 3, "d": 4}
result2 = advanced_math(**data_dict)  # 关键字参数解包
 
print(f"列表解包结果: {result1}")
print(f"字典解包结果: {result2}")

def demonstrate_mutation(mutable_list, immutable_value):
    """
    演示可变对象和不可变对象的参数传递差异
    
    在TRAE IDE中，可以通过调试模式观察内存地址变化
    """
    print(f"函数内 - 列表ID: {id(mutable_list)}")
    print(f"函数内 - 值ID: {id(immutable_value)}")
    
    # 修改可变对象
    mutable_list.append(100)
    
    # 重新绑定不可变对象
    immutable_value = 999
    
    return mutable_list, immutable_value
 
# 测试参数传递
original_list = [1, 2, 3]
original_value = 42
 
print(f"函数外 - 列表ID: {id(original_list)}")
print(f"函数外 - 值ID: {id(original_value)}")
 
new_list, new_value = demonstrate_mutation(original_list, original_value)
 
print(f"原列表: {original_list}")      # 被修改: [1, 2, 3, 100]
print(f"原值: {original_value}")        # 未改变: 42
print(f"返回值 - 列表: {new_list}")     # [1, 2, 3, 100]
print(f"返回值 - 值: {new_value}")       # 999

def validate_email(email):
    """验证邮箱格式"""
    import re
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return re.match(pattern, email) is not None
 
def send_notification(user_email, message):
    """发送通知 - 专注于单一功能"""
    if not validate_email(user_email):
        raise ValueError("无效的邮箱地址")
    
    # 模拟发送逻辑
    print(f"发送通知到 {user_email}: {message}")
    return True

# 不好的设计 - 参数过多
def create_order_bad(user_id, product_id, quantity, price, discount, tax, shipping, payment_method, address, phone):
    pass
 
# 好的设计 - 使用对象或字典封装
def create_order_good(order_data):
    """
    创建订单 - 参数封装
    
    Args:
        order_data: 包含订单信息的字典或对象
    """
    required_fields = ['user_id', 'product_id', 'quantity', 'price']
    
    # 参数验证
    for field in required_fields:
        if field not in order_data:
            raise ValueError(f"缺少必要参数: {field}")
    
    # 订单处理逻辑
    print(f"创建订单 - 用户: {order_data['user_id']}, 商品: {order_data['product_id']}")
    return {"order_id": 12345, "status": "created"}
 
# 使用示例
order_info = {
    "user_id": 1001,
    "product_id": 2001,
    "quantity": 2,
    "price": 99.99,
    "discount": 0.1,
    "payment_method": "alipay"
}
 
result = create_order_good(order_info)

def safe_divide(dividend, divisor, default_value=None):
    """
    安全的除法运算 - 优雅的错误处理
    
    在TRAE IDE中，异常断点可以帮助快速定位问题
    """
    try:
        if divisor == 0:
            if default_value is not None:
                return default_value
            raise ValueError("除数不能为零")
        
        result = dividend / divisor
        return result
        
    except TypeError as e:
        print(f"类型错误: {e}")
        return None
    except Exception as e:
        print(f"未知错误: {e}")
        return None
 
# 测试不同场景
print(safe_divide(10, 2))        # 正常: 5.0
print(safe_divide(10, 0))        # 异常: None
print(safe_divide(10, 0, 0))   # 默认值: 0
print(safe_divide("10", 2))      # 类型错误处理

# 输入函数名时，IDE会自动建议参数名和类型
def calculate_compound_interest(principal, rate, time, frequency=1):
    """
    计算复利 - TRAE IDE会自动补全文档模板
    
    Args:
        principal: 本金
        rate: 年利率
        time: 时间(年)
        frequency: 复利频率(默认1次/年)
        
    Returns:
        float: 复利终值
    """
    # IDE会提示math模块的导入
    amount = principal * (1 + rate/frequency) ** (frequency * time)
    return amount
 
# 调用时，IDE显示参数提示
result = calculate_compound_interest(10000, 0.05, 5, 4)  # 季度复利

def process_user_data(users):
    """
    处理用户数据 - TRAE IDE会实时检测潜在问题
    
    潜在问题检测：
    1. 未处理的空值情况
    2. 可能的类型错误
    3. 性能优化建议
    """
    # IDE会警告：users可能为None或空列表
    if not users:  # TRAE建议添加空值检查
        return []
    
    processed = []
    for user in users:
        # IDE提示：检查user是否为字典类型
        if isinstance(user, dict) and 'name' in user:
            processed.append(user['name'].upper())
    
    return processed
 
# TRAE IDE会建议使用列表推导式优化
def optimized_process(users):
    """优化版本 - TRAE IDE建议的改进"""
    if not isinstance(users, list):
        return []
    
    return [user.get('name', '').upper() 
            for user in users 
            if isinstance(user, dict) and user.get('name')]

def complex_business_logic(data, config):
    """
    复杂业务逻辑 - TRAE IDE集成调试功能
    
    调试技巧：
    1. 设置条件断点
    2. 查看变量状态变化
    3. 性能分析工具
    """
    # TRAE IDE可以在这里设置断点，观察data结构
    if not data:
        raise ValueError("数据不能为空")
    
    # 单步调试，观察每一步的转换
    processed_data = preprocess(data)
    validated_data = validate(processed_data, config)
    result = calculate(validated_data)
    
    return format_output(result)
 
# TRAE IDE内置测试运行器
def test_complex_logic():
    """单元测试 - 直接在IDE中运行"""
    test_data = {"value": 100, "type": "premium"}
    config = {"min_value": 50, "max_value": 200}
    
    result = complex_business_logic(test_data, config)
    assert result is not None
    assert isinstance(result, dict)

import time
from functools import wraps
 
def performance_timer(func):
    """性能计时装饰器 - TRAE IDE性能分析工具"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        
        execution_time = end_time - start_time
        print(f"{func.__name__} 执行时间: {execution_time:.4f}秒")
        
        # TRAE IDE可以集成更详细的性能报告
        return result
    return wrapper
 
@performance_timer
def fibonacci_recursive(n):
    """递归斐波那契 - 性能较差"""
    if n <= 1:
        return n
    return fibonacci_recursive(n-1) + fibonacci_recursive(n-2)
 
@performance_timer
def fibonacci_iterative(n):
    """迭代斐波那契 - 性能优化"""
    if n <= 1:
        return n
    
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b
 
# 性能对比
print("递归版本:")
fibonacci_recursive(30)
print("迭代版本:")
fibonacci_iterative(30)

import sys
 
def memory_efficient_generator(data):
    """
    内存高效的生成器函数
    
    TRAE IDE内存分析工具可以监控内存使用情况
    """
    for item in data:
        # 惰性计算，节省内存
        yield process_item(item)
 
def process_large_dataset():
    """处理大数据集"""
    # 假设有百万级数据
    large_data = range(1000000)
    
    # 使用生成器避免内存溢出
    processed_generator = memory_efficient_generator(large_data)
    
    # 逐个处理，不占用大量内存
    count = 0
    for result in processed_generator:
        if result:  # 只处理有效数据
            count += 1
        if count >= 1000:  # 限制处理数量
            break
    
    return count
 
def process_item(item):
    """模拟数据处理"""
    return item % 100 == 0  # 简单的条件判断