6、函数function

def function_name(parameter1, parameter2, ...):
    """函数文档注释"""
    # 函数体
    return 返回值

# 1. 无参数无返回值的函数
def say_hello():
    print("Hello, World!")

say_hello()  # 输出: Hello, World!

# 2. 有参数有返回值的函数
def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # 输出: 8

def calculate_area(length, width):
    """计算矩形面积
    
    Args:
        length (float): 矩形的长
        width (float): 矩形的宽
    
    Returns:
        float: 矩形的面积
    """
    return length * width

# 查看函数文档
print(calculate_area.__doc__)

def greet(name, message="Hello"):
    return f"{message}, {name}!"

# 位置参数
print(greet("Python"))  # 输出: Hello, Python!

# 关键字参数
print(greet(message="Hi", name="Python"))  # 输出: Hi, Python!

def power(x, n=2):
    """计算x的n次方"""
    return x ** n

print(power(3))     # 输出: 9 (使用默认值 n=2)
print(power(3, 3))  # 输出: 27 (指定 n=3)

# 1. *args - 位置参数可变
def sum_numbers(*args):
    return sum(args)

print(sum_numbers(1, 2, 3))     # 输出: 6
print(sum_numbers(1, 2, 3, 4))  # 输出: 10

# 2. **kwargs - 关键字参数可变
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Python", age=30)  # 输出: name: Python\nage: 30

# 3. 参数顺序示例
def complex_function(frag, *nums, **words):
    print(f"frag: {frag}")           # 普通参数
    print(f"nums: {nums}")           # 位置参数元组
    print(f"words: {words}")         # 关键字参数字典

# 调用函数
complex_function(
    "hello",                # frag参数
    1, 2, 3,               # 被*nums收集
    x="a", y="b", z="c"    # 被**words收集
)

# 输出:
# frag: hello
# nums: (1, 2, 3)
# words: {'x': 'a', 'y': 'b', 'z': 'c'}

# 4. 参数顺序规则
def standard_arg_order(a, b=None, *args, **kwargs):
    """标准参数顺序示例
    1. 普通参数 (a)
    2. 默认参数 (b=None)
    3. 可变位置参数 (*args)
    4. 可变关键字参数 (**kwargs)
    """
    pass

# 注意：参数顺序必须严格按照上述顺序
# 下面的定义是错误的
def wrong_order(*args, a, b=None, **kwargs):  # 错误！
    pass

def apply_operation(x, operation):
    return operation(x)

def square(x):
    return x ** 2

def cube(x):
    return x ** 3

print(apply_operation(3, square))  # 输出: 9
print(apply_operation(3, cube))    # 输出: 27

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

add_5 = outer_function(5)
print(add_5(3))  # 输出: 8

def timer(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"函数{func.__name__}执行时间: {end - start}秒")
        return result
    return wrapper

@timer
def slow_function():
    import time
    time.sleep(1)
    return "Done!"

print(slow_function())  # 输出函数执行时间和"Done!"

# 1. 可变对象的参数传递
def modify_list(lst):
    lst.append(4)

my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)  # 输出: [1, 2, 3, 4] (原列表被修改)

# 2. 不可变对象的参数传递
def modify_number(n):
    n += 1
    return n

x = 5
y = modify_number(x)
print(x)  # 输出: 5 (原数字不变)
print(y)  # 输出: 6

# 1. 全局变量和局部变量
global_var = 10

def test_scope():
    local_var = 20
    print(global_var)  # 可以访问全局变量
    print(local_var)   # 可以访问局部变量

test_scope()
# print(local_var)  # 错误！不能访问函数内的局部变量

# 2. 修改全局变量
def modify_global():
    global global_var
    global_var = 30

modify_global()
print(global_var)  # 输出: 30

# 1. 返回多个值
def get_coordinates():
    return 3, 4  # 返回元组

x, y = get_coordinates()
print(f"x: {x}, y: {y}")  # 输出: x: 3, y: 4

# 2. 条件返回
def get_absolute(n):
    if n >= 0:
        return n
    return -n

print(get_absolute(-5))  # 输出: 5