# 最简单的函数
def greet():
    print("Hello, World!")

greet()  # 调用函数

# 带参数的函数
def greet_person(name):
    print(f"Hello, {name}!")

greet_person("Alice")

# 返回单个值
def add(a, b):
    return a + b

result = add(3, 5)  # result = 8

# 返回多个值（实际上是返回元组）
def calculate(a, b):
    sum_result = a + b
    diff = a - b
    product = a * b
    return sum_result, diff, product

s, d, p = calculate(10, 3)  # 元组解包
print(f"和: {s}, 差: {d}, 积: {p}")

def describe_person(name, age, city):
    print(f"{name} is {age} years old and lives in {city}")

describe_person("Alice", 30, "New York")  # 必须按顺序传参

# 调用时使用参数名
describe_person(age=30, city="New York", name="Alice")

# 混合使用（位置参数必须在关键字参数之前）
describe_person("Alice", age=30, city="New York")

def describe_person(name, age=30, city="Unknown"):
    print(f"{name} is {age} years old and lives in {city}")

describe_person("Bob")  # 使用默认值
describe_person("Charlie", 25, "London")  # 覆盖默认值

# 注意：默认参数值在函数定义时计算一次！
def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item("apple"))  # ['apple']
print(add_item("banana"))  # ['apple', 'banana'] - 注意items保留了之前的值！

# 正确做法：使用None作为默认值
def add_item_correct(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

# 接收任意数量的位置参数
def sum_all(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_all(1, 2, 3))  # 6
print(sum_all(1, 2, 3, 4, 5))  # 15

# 与其他参数结合
def make_pizza(size, *toppings):
    print(f"Making a {size} pizza with:")
    for topping in toppings:
        print(f"- {topping}")

make_pizza("large", "cheese", "pepperoni", "mushrooms")

def build_profile(**kwargs):
    profile = {}
    for key, value in kwargs.items():
        profile[key] = value
    return profile

user = build_profile(name="Alice", age=30, city="New York", job="Engineer")
print(user)  # {'name': 'Alice', 'age': 30, 'city': 'New York', 'job': 'Engineer'}

# 综合使用所有参数类型
def complete_function(required, optional="default", *args, **kwargs):
    print(f"Required: {required}")
    print(f"Optional: {optional}")
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

complete_function("required_value", "custom", "arg1", "arg2", key1="val1", key2="val2")

# 函数可以赋值给变量
def square(x):
    return x ** 2

func = square
print(func(5))  # 25

# 函数作为参数传递
def apply_function(func, values):
    results = []
    for value in values:
        results.append(func(value))
    return results

numbers = [1, 2, 3, 4, 5]
squares = apply_function(square, numbers)
print(squares)  # [1, 4, 9, 16, 25]

# 函数作为返回值
def create_multiplier(n):
    def multiplier(x):
        return x * n
    return multiplier

double = create_multiplier(2)
triple = create_multiplier(3)

print(double(5))  # 10
print(triple(5))  # 15

# 基本语法：lambda 参数: 表达式
square = lambda x: x ** 2
print(square(4))  # 16

# 与内置函数配合使用
numbers = [1, 2, 3, 4, 5]

# map: 对每个元素应用函数
squares = list(map(lambda x: x**2, numbers))
print(squares)  # [1, 4, 9, 16, 25]

# filter: 过滤元素
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4]

# sorted: 自定义排序
people = [("Alice", 30), ("Bob", 25), ("Charlie", 35)]
sorted_by_age = sorted(people, key=lambda x: x[1])
print(sorted_by_age)  # [('Bob', 25), ('Alice', 30), ('Charlie', 35)]

# 基础装饰器
def timer_decorator(func):
    import time
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} 执行时间: {end_time - start_time:.4f}秒")
        return result
    return wrapper

@timer_decorator
def slow_function():
    import time
    time.sleep(1)
    return "完成"

slow_function()

# 带参数的装饰器
def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

say_hello()  # 打印3次Hello!

# 类装饰器
class Logger:
    def __init__(self, func):
        self.func = func
    
    def __call__(self, *args, **kwargs):
        print(f"调用函数: {self.func.__name__}")
        result = self.func(*args, **kwargs)
        print(f"函数返回: {result}")
        return result

@Logger
def add(a, b):
    return a + b

add(3, 4)

def fibonacci_generator(n):
    """生成斐波那契数列的前n个数字"""
    a, b = 0, 1
    count = 0
    while count < n:
        yield a
        a, b = b, a + b
        count += 1

# 使用生成器
for num in fibonacci_generator(10):
    print(num, end=" ")
# 输出: 0 1 1 2 3 5 8 13 21 34

# 生成器表达式
squares = (x**2 for x in range(10))
print(list(squares))  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# abs: 绝对值
print(abs(-10))  # 10

# all: 所有元素为True
print(all([True, 1, "hello"]))  # True
print(all([True, 0, "hello"]))  # False

# any: 任意元素为True
print(any([False, 0, "hello"]))  # True

# enumerate: 带索引的迭代
fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits, start=1):
    print(f"{index}. {fruit}")

# zip: 并行迭代
names = ["Alice", "Bob", "Charlie"]
ages = [30, 25, 35]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")

# len: 获取长度
print(len("Hello"))  # 5
print(len([1, 2, 3]))  # 3

# max/min: 最大值/最小值
print(max([1, 5, 3, 9, 2]))  # 9
print(min([1, 5, 3, 9, 2]))  # 1

# sum: 求和
print(sum([1, 2, 3, 4, 5]))  # 15

# range: 生成数字序列
print(list(range(5)))  # [0, 1, 2, 3, 4]
print(list(range(1, 6)))  # [1, 2, 3, 4, 5]
print(list(range(0, 10, 2)))  # [0, 2, 4, 6, 8]

# round: 四舍五入
print(round(3.14159, 2))  # 3.14

# sorted: 排序
print(sorted([3, 1, 4, 1, 5]))  # [1, 1, 3, 4, 5]

# 阶乘函数
def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))  # 120

# 斐波那契数列
def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

print([fibonacci(i) for i in range(10)])  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# 目录遍历（递归示例）
import os

def list_files(startpath):
    for root, dirs, files in os.walk(startpath):
        level = root.replace(startpath, '').count(os.sep)
        indent = ' ' * 4 * level
        print(f'{indent}{os.path.basename(root)}/')
        subindent = ' ' * 4 * (level + 1)
        for file in files:
            print(f'{subindent}{file}')

from typing import List, Dict, Optional, Union, Tuple

def process_data(
    numbers: List[int],
    multiplier: float = 1.0
) -> List[float]:
    """处理数字列表，返回乘以系数的结果"""
    return [num * multiplier for num in numbers]

def get_user_info(
    user_id: int,
    include_details: bool = False
) -> Dict[str, Union[str, int, None]]:
    """获取用户信息"""
    # 函数实现...
    return {"name": "Alice", "age": 30}

# 可选的返回值
def find_item(items: List[str], target: str) -> Optional[int]:
    """在列表中查找元素，返回索引或None"""
    try:
        return items.index(target)
    except ValueError:
        return None

def calculate_bmi(weight: float, height: float) -> float:
    """
    计算身体质量指数(BMI)
    
    参数:
        weight (float): 体重，单位千克
        height (float): 身高，单位米
        
    返回:
        float: BMI值
        
    示例:
        >>> calculate_bmi(70, 1.75)
        22.86
    """
    if height <= 0:
        raise ValueError("身高必须大于0")
    
    bmi = weight / (height ** 2)
    return round(bmi, 2)

def safe_divide(a: float, b: float) -> float:
    """安全除法，处理除零错误"""
    try:
        result = a / b
    except ZeroDivisionError:
        print("错误：除数不能为零")
        return 0.0
    except TypeError:
        print("错误：参数必须是数字")
        return 0.0
    else:
        return result
    finally:
        print("除法操作完成")

def validate_input(value, min_val=0, max_val=100):
    """验证输入值是否在范围内"""
    if not isinstance(value, (int, float)):
        raise TypeError("输入必须是数字")
    
    if not min_val <= value <= max_val:
        raise ValueError(f"值必须在{min_val}和{max_val}之间")
    
    return value

def process_data_pipeline(data):
    """数据处理流水线"""
    # 1. 数据清洗
    cleaned = clean_data(data)
    
    # 2. 数据转换
    transformed = transform_data(cleaned)
    
    # 3. 数据分析
    analysis_result = analyze_data(transformed)
    
    return analysis_result

def clean_data(data):
    """数据清洗"""
    # 移除空值
    data = [item for item in data if item is not None]
    
    # 转换数据类型
    data = [float(item) for item in data if isinstance(item, (int, float, str))]
    
    return data

def transform_data(data):
    """数据转换"""
    # 标准化
    if len(data) > 0:
        mean_val = sum(data) / len(data)
        std_val = (sum((x - mean_val) ** 2 for x in data) / len(data)) ** 0.5
        if std_val > 0:
            data = [(x - mean_val) / std_val for x in data]
    
    return data

def analyze_data(data):
    """数据分析"""
    stats = {
        "count": len(data),
        "mean": sum(data) / len(data) if data else 0,
        "min": min(data) if data else None,
        "max": max(data) if data else None
    }
    return stats

# 使用示例
sample_data = [1, 2, None, 3, "4", 5, 6]
result = process_data_pipeline(sample_data)
print(result)

def create_operation(operation_type):
    """工厂函数：根据类型创建不同的操作函数"""
    operations = {
        "add": lambda x, y: x + y,
        "subtract": lambda x, y: x - y,
        "multiply": lambda x, y: x * y,
        "divide": lambda x, y: x / y if y != 0 else None
    }
    
    return operations.get(operation_type, lambda x, y: None)

# 使用工厂函数
add_func = create_operation("add")
print(add_func(10, 5))  # 15

multiply_func = create_operation("multiply")
print(multiply_func(10, 5))  # 50

def cache_decorator(func):
    """缓存装饰器，避免重复计算"""
    cache = {}
    
    def wrapper(*args):
        if args in cache:
            print(f"从缓存获取结果: {args}")
            return cache[args]
        
        result = func(*args)
        cache[args] = result
        print(f"计算并缓存结果: {args} -> {result}")
        return result
    
    return wrapper

@cache_decorator
def expensive_computation(n):
    """模拟耗时的计算"""
    import time
    time.sleep(1)  # 模拟耗时操作
    return n * n

# 第一次调用会计算，第二次从缓存获取
print(expensive_computation(5))  # 计算并返回25
print(expensive_computation(5))  # 从缓存返回25