1. 为什么要用函数？

函数的作用：封装代码，提高复用性，减少重复，提高可读性。

没有函数，代码可能会很冗长：

print("欢迎 Alice！")
print("欢迎 Bob！")
print("欢迎 Charlie！")

使用函数，代码更优雅：

def greet(name):
    print(f"欢迎 {name}！")

greet("Alice")
greet("Bob")
greet("Charlie")

减少重复，提高代码质量！

2. 如何定义函数？

Python 使用 def 关键字定义函数：

def 函数名(参数):
    代码块
    return 返回值

示例：计算两个数的和

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

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

return 返回结果，默认返回 None！

3. 深入理解函数参数

Python 函数支持多种参数传递方式，让代码更灵活！

位置参数（Positional Arguments）

按照 参数顺序 传递：

def greet(name, age):
    print(f"{name} 今年 {age} 岁")

greet("Alice", 25)  #  正确
greet(25, "Alice")  #  参数顺序错误

顺序重要，必须一一对应！

关键字参数（Keyword Arguments）

显式指定参数名，不受顺序影响：

greet(age=25, name="Alice")  #  直接指定参数

提高可读性，避免顺序错误！

默认参数（Default Arguments）

给参数设置默认值，可选传参：

def greet(name, age=18):  # 默认 age=18
    print(f"{name} 今年 {age} 岁")

greet("Bob")        # Bob 今年 18 岁
greet("Alice", 25)  # Alice 今年 25 岁

减少调用时的参数传递，提高灵活性！

可变参数：*args（任意个位置参数）

适用于 不确定数量的参数：

def add(*numbers):
    return sum(numbers)

print(add(1, 2, 3))      # 输出 6
print(add(10, 20, 30, 40))  # 输出 100

所有参数会打包成元组 args，可按需处理！

关键字可变参数：**kwargs（任意个键值对参数）

适用于 不定数量的命名参数：

def info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

info(name="Alice", age=25, city="Beijing")

kwargs 以字典形式存储，适用于动态参数！

4. return语句的妙用

函数可以返回单个值、多值或 None。

返回单个值

def square(x):
    return x ** 2

print(square(4))  # 输出 16

return 结束函数并返回值！

返回多个值

def get_user():
    return "Alice", 25  # 返回元组

name, age = get_user()
print(name, age)  # Alice 25

可以用多个变量接收，简洁方便！

return省略的情况

如果 return 省略，函数默认返回 None：

def say_hello():
    print("Hello!")

print(say_hello())  # 输出 Hello!，但返回 None

如果不需要返回值，可省略 return！

5. lambda表达式：一行代码实现函数！

lambda 是 匿名函数，适用于 简单操作，格式：

lambda 参数: 返回值

示例 1：快速计算平方

square = lambda x: x ** 2
print(square(4))  # 输出 16

示例 2：排序时自定义规则

students = [("Alice", 25), ("Bob", 20), ("Charlie", 23)]
students.sort(key=lambda x: x[1])  # 按年龄排序
print(students)

lambda 适用于简短逻辑，但不适合复杂操作！

6. lambdaVS def，该用哪个？

简单操作 → lambda
复杂逻辑 → def

7. 进阶技巧，让函数更强大！

1. 函数嵌套

def outer():
    def inner():
        print("我是内部函数")
    inner()

outer()

函数可以嵌套，隐藏内部逻辑！

2. 闭包（Closure）

def outer(x):
    def inner(y):
        return x + y
    return inner

add_5 = outer(5)  # add_5 是一个新函数
print(add_5(10))  # 输出 15

闭包可以保存外部变量，提升灵活性！