2025年Python新手入门：函数完全指南

def 函数名(参数1, 参数2, ...):
    """文档字符串（可选）"""
    # 函数体
    return 返回值  # 可选

# 定义一个简单的函数，用于打招呼
def greet():
    """打印问候语"""
    print("Hello, Python!")

# 定义一个带有参数的函数
def greet_person(name):
    """向指定的人打招呼
    
    参数:
        name: 字符串，要打招呼的人的名字
    """
    print(f"Hello, {name}!")

# 定义一个带有返回值的函数
def add(a, b):
    """计算两个数的和并返回结果
    
    参数:
        a: 第一个数
        b: 第二个数
        
    返回:
        两个数的和
    """
    return a + b

# 调用函数

# 调用不带参数和返回值的函数
greet()  # 输出: Hello, Python!

# 调用带参数的函数
greet_person("Alice")  # 输出: Hello, Alice!

greet_person("Bob")  # 输出: Hello, Bob!

# 调用带返回值的函数
result = add(3, 5)
print(result)  # 输出: 8

# 直接使用函数的返回值
print(add(10, 20))  # 输出: 30

# 查看函数的文档字符串

# 使用help()函数
help(greet)
# 输出:
# Help on function greet in module __main__:
# 
# greet()
#     打印问候语

# 直接访问__doc__属性
print(greet_person.__doc__)
# 输出:
# 向指定的人打招呼
#     
#     参数:
#         name: 字符串，要打招呼的人的名字

# 位置参数示例
def describe_pet(animal_type, pet_name):
    """描述宠物的信息
    
    参数:
        animal_type: 宠物类型
        pet_name: 宠物名字
    """
    print(f"我有一只{animal_type}。")
    print(f"我的{animal_type}叫{pet_name}。")

# 按照位置顺序传递参数
describe_pet("狗", "小白")
# 输出:
# 我有一只狗。
# 我的狗叫小白。

# 参数顺序很重要
describe_pet("小黑", "猫")  # 这样会导致语义错误
# 输出:
# 我有一只小黑。
# 我的小黑叫猫。

# 关键字参数示例
def describe_pet(animal_type, pet_name):
    """描述宠物的信息"""
    print(f"我有一只{animal_type}。")
    print(f"我的{animal_type}叫{pet_name}。")

# 使用关键字参数
describe_pet(animal_type="猫", pet_name="小黑")
# 输出:
# 我有一只猫。
# 我的猫叫小黑。

# 可以改变参数顺序
describe_pet(pet_name="小白", animal_type="狗")
# 输出:
# 我有一只狗。
# 我的狗叫小白。

# 默认参数示例
def describe_pet(pet_name, animal_type="狗"):
    """描述宠物的信息，默认宠物类型是狗"""
    print(f"我有一只{animal_type}。")
    print(f"我的{animal_type}叫{pet_name}。")

# 不提供默认参数，使用默认值
describe_pet(pet_name="小白")
# 输出:
# 我有一只狗。
# 我的狗叫小白。

# 提供默认参数，覆盖默认值
describe_pet(pet_name="小黑", animal_type="猫")
# 输出:
# 我有一只猫。
# 我的猫叫小黑。

# 可变参数示例
def sum_numbers(*args):
    """计算任意数量数字的和
    
    参数:
        *args: 任意数量的数字
        
    返回:
        所有数字的和
    """
    total = 0
    for num in args:
        total += num
    return total

# 传递不同数量的参数
print(sum_numbers(1, 2, 3))  # 输出: 6
print(sum_numbers(1, 2, 3, 4, 5))  # 输出: 15
print(sum_numbers())  # 输出: 0（没有传递参数）

# 传递列表作为可变参数
numbers = [1, 2, 3, 4, 5]
print(sum_numbers(*numbers))  # 在列表前加*，将列表元素作为单独的参数传递 输出: 15

# 关键字可变参数示例
def print_info(**kwargs):
    """打印任意数量的关键字参数
    
    参数:
        **kwargs: 任意数量的关键字参数
    """
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# 传递不同数量的关键字参数
print_info(name="Alice", age=25, city="New York")
# 输出:
# name: Alice
# age: 25
# city: New York

print_info(product="手机", price=999.99, brand="Apple")
# 输出:
# product: 手机
# price: 999.99
# brand: Apple

# 传递字典作为关键字可变参数
person = {"name": "Bob", "age": 30, "city": "Boston"}
print_info(**person)  # 在字典前加**，将字典的键值对作为关键字参数传递
# 输出:
# name: Bob
# age: 30
# city: Boston

# 参数组合使用示例
def mixed_params(a, b, *args, c=10, **kwargs):
    """混合使用不同类型的参数
    
    参数:
        a, b: 位置参数
        *args: 可变参数
        c: 默认参数
        **kwargs: 关键字可变参数
    """
    print(f"a = {a}")
    print(f"b = {b}")
    print(f"args = {args}")
    print(f"c = {c}")
    print(f"kwargs = {kwargs}")

# 调用函数
mixed_params(1, 2, 3, 4, 5, c=20, x=100, y=200)
# 输出:
# a = 1
# b = 2
# args = (3, 4, 5)
# c = 20
# kwargs = {'x': 100, 'y': 200}

# 返回单个值示例
def square(x):
    """计算一个数的平方
    
    参数:
        x: 一个数字
        
    返回:
        x的平方
    """
    return x * x

result = square(5)
print(result)  # 输出: 25

# 返回多个值示例
def get_person_info():
    """返回一个人的信息
    
    返回:
        包含姓名、年龄和城市的元组
    """
    name = "Alice"
    age = 25
    city = "New York"
    return name, age, city  # 多个返回值会被打包成元组

# 接收多个返回值
person_name, person_age, person_city = get_person_info()  # 解包元组
print(f"姓名: {person_name}")  # 输出: 姓名: Alice
print(f"年龄: {person_age}")  # 输出: 年龄: 25
print(f"城市: {person_city}")  # 输出: 城市: New York

# 也可以用一个变量接收所有返回值
person_info = get_person_info()
print(person_info)  # 输出: ('Alice', 25, 'New York')

# 提前返回示例
def is_positive(number):
    """判断一个数是否为正数
    
    参数:
        number: 一个数字
        
    返回:
        如果number是正数，返回True；否则返回False
    """
    if number > 0:
        return True
    return False  # 如果number <= 0，执行到这里

print(is_positive(5))  # 输出: True
print(is_positive(-3))  # 输出: False
print(is_positive(0))  # 输出: False

# 另一个提前返回的例子
def find_first_negative(numbers):
    """找到列表中的第一个负数
    
    参数:
        numbers: 数字列表
        
    返回:
        第一个负数，如果没有找到，返回None
    """
    for num in numbers:
        if num < 0:
            return num  # 找到第一个负数就返回
    return None  # 如果没有找到负数，执行到这里

numbers = [1, 2, -3, 4, -5]
first_negative = find_first_negative(numbers)
print(f"第一个负数是: {first_negative}")  # 输出: 第一个负数是: -3

# 没有return语句的函数示例
def say_hello():
    """打印问候语，没有返回值"""
    print("Hello!")

result = say_hello()
print(result)  # 输出: None

# return语句后面没有值
def do_nothing():
    """什么都不做，返回None"""
    return

result = do_nothing()
print(result)  # 输出: None

# 函数嵌套示例
def outer_function(x):
    """外部函数
    
    参数:
        x: 一个数字
    """
    def inner_function(y):
        """内部函数
        
        参数:
            y: 一个数字
            
        返回:
            y的平方加上外部函数的x
    """
        return y * y + x  # 内部函数可以访问外部函数的变量
    
    result = inner_function(5)
    print(f"内部函数的结果: {result}")
    
    # 外部函数不能访问内部函数的变量
    # print(y)  # 这行代码会引发错误
    
    return result

# 调用外部函数
outer_result = outer_function(10)
print(f"外部函数的返回值: {outer_result}")
# 输出:
# 内部函数的结果: 35
# 外部函数的返回值: 35

# 不能直接调用内部函数
# inner_function(5)  # 这行代码会引发错误

# 局部作用域示例
def my_function():
    """演示局部变量"""
    local_var = "我是局部变量"
    print(local_var)  # 在函数内部可以访问局部变量

my_function()  # 输出: 我是局部变量

# 不能在函数外部访问局部变量
# print(local_var)  # 这行代码会引发错误

# 嵌套作用域示例
def outer_function():
    """外部函数"""
    outer_var = "我是外部变量"
    
    def inner_function():
        """内部函数"""
        # 内部函数可以访问外部函数的变量
        print(outer_var)
        
        # 但不能修改外部函数的变量（除非使用nonlocal关键字）
        # outer_var = "修改外部变量"  # 这行代码会创建一个新的局部变量，而不是修改外部变量
    
    inner_function()
    print(outer_var)  # 输出原始的外部变量值

outer_function()
# 输出:
# 我是外部变量
# 我是外部变量

# 全局作用域示例
global_var = "我是全局变量"  # 在模块级别定义的全局变量

def my_function():
    """演示全局变量"""
    # 在函数内部可以访问全局变量
    print(global_var)
    
    # 但不能直接修改全局变量（除非使用global关键字）
    # global_var = "修改全局变量"  # 这行代码会创建一个新的局部变量，而不是修改全局变量

my_function()  # 输出: 我是全局变量
print(global_var)  # 输出: 我是全局变量

# 使用global关键字修改全局变量
counter = 0  # 全局变量

def increment_counter():
    """使用global关键字修改全局变量"""
    global counter  # 声明counter是全局变量
    counter += 1
    print(f"计数器的值: {counter}")

increment_counter()  # 输出: 计数器的值: 1
increment_counter()  # 输出: 计数器的值: 2
print(f"全局计数器的值: {counter}")  # 输出: 全局计数器的值: 2

# 使用nonlocal关键字修改外部函数的变量
def outer_function():
    """外部函数"""
    outer_var = "我是外部变量"
    
    def inner_function():
        """内部函数"""
        nonlocal outer_var  # 声明outer_var是外部函数的变量
        outer_var = "修改后的外部变量"
        print(f"内部函数中的outer_var: {outer_var}")
    
    inner_function()
    print(f"外部函数中的outer_var: {outer_var}")

outer_function()
# 输出:
# 内部函数中的outer_var: 修改后的外部变量
# 外部函数中的outer_var: 修改后的外部变量

lambda 参数1, 参数2, ...: 表达式

# Lambda函数基本用法

# 定义一个简单的lambda函数，计算两个数的和
sum_lambda = lambda x, y: x + y
print(sum_lambda(3, 5))  # 输出: 8

# 定义一个lambda函数，计算一个数的平方
square_lambda = lambda x: x * x
print(square_lambda(4))  # 输出: 16

# 定义一个lambda函数，检查一个数是否为偶数
is_even_lambda = lambda x: x % 2 == 0
print(is_even_lambda(6))  # 输出: True
print(is_even_lambda(7))  # 输出: False

# Lambda函数与内置函数一起使用

# 与map()函数一起使用，将列表中的每个元素平方
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x * x, numbers))
print(squared_numbers)  # 输出: [1, 4, 9, 16, 25]

# 与filter()函数一起使用，过滤出列表中的偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出: [2, 4, 6, 8, 10]

# 与sorted()函数一起使用，根据指定的键进行排序
students = [
    {"name": "Alice", "score": 90},
    {"name": "Bob", "score": 85},
    {"name": "Charlie", "score": 95},
    {"name": "David", "score": 80}
]

# 按分数降序排序
sorted_students = sorted(students, key=lambda student: student["score"], reverse=True)
for student in sorted_students:
    print(f"{student['name']}: {student['score']}")
# 输出:
# Charlie: 95
# Alice: 90
# Bob: 85
# David: 80

# 与reduce()函数一起使用，计算列表中所有元素的和
from functools import reduce
numbers = [1, 2, 3, 4, 5]
sum_result = reduce(lambda x, y: x + y, numbers)
print(sum_result)  # 输出: 15

# Lambda函数作为函数参数传递
def apply_operation(x, y, operation):
    """对两个数应用指定的操作
    
    参数:
        x: 第一个数
        y: 第二个数
        operation: 要应用的操作（函数）
        
    返回:
        操作的结果
    """
    return operation(x, y)

# 使用lambda函数作为参数
addition = apply_operation(5, 3, lambda x, y: x + y)
subtraction = apply_operation(5, 3, lambda x, y: x - y)
multiplication = apply_operation(5, 3, lambda x, y: x * y)
division = apply_operation(5, 3, lambda x, y: x / y)

print(f"加法结果: {addition}")  # 输出: 加法结果: 8
print(f"减法结果: {subtraction}")  # 输出: 减法结果: 2
print(f"乘法结果: {multiplication}")  # 输出: 乘法结果: 15
print(f"除法结果: {division}")  # 输出: 除法结果: 1.6666666666666667

# 递归函数基本用法

def factorial(n):
    """计算n的阶乘（递归实现）
    
    参数:
        n: 非负整数
        
    返回:
        n的阶乘
    """
    # 基本情况（递归终止条件）
    if n == 0 or n == 1:
        return 1
    # 递归调用
    return n * factorial(n - 1)

# 测试函数
print(factorial(0))  # 输出: 1
print(factorial(1))  # 输出: 1
print(factorial(5))  # 输出: 120
print(factorial(10))  # 输出: 3628800

# 递归的两个要素示例
def fibonacci(n):
    """计算斐波那契数列的第n项（递归实现）
    
    参数:
        n: 正整数
        
    返回:
        斐波那契数列的第n项
    """
    # 基本情况
    if n == 1 or n == 2:
        return 1
    # 递归调用
    return fibonacci(n - 1) + fibonacci(n - 2)

# 测试函数
print(fibonacci(1))  # 输出: 1
print(fibonacci(2))  # 输出: 1
print(fibonacci(3))  # 输出: 2
print(fibonacci(4))  # 输出: 3
print(fibonacci(5))  # 输出: 5
print(fibonacci(10))  # 输出: 55

# 尾递归示例
def factorial_tail(n, accumulator=1):
    """计算n的阶乘（尾递归实现）
    
    参数:
        n: 非负整数
        accumulator: 累加器，用于存储中间结果
        
    返回:
        n的阶乘
    """
    if n == 0:
        return accumulator
    return factorial_tail(n - 1, n * accumulator)

# 测试函数
print(factorial_tail(0))  # 输出: 1
print(factorial_tail(1))  # 输出: 1
print(factorial_tail(5))  # 输出: 120

# 函数注解基本用法
def greet(name: str) -> str:
    """向指定的人打招呼
    
    参数:
        name: 字符串，要打招呼的人的名字
        
    返回:
        包含问候语的字符串
    """
    return f"Hello, {name}!"

# 调用函数
message = greet("Alice")
print(message)  # 输出: Hello, Alice!

# 复杂函数注解示例
from typing import List, Dict, Tuple, Optional

def process_data(data: List[int], threshold: int = 10) -> Dict[str, List[int]]:
    """处理数据列表
    
    参数:
        data: 整数列表
        threshold: 阈值，默认值为10
        
    返回:
        包含处理结果的字典
    """
    result = {
        "below_threshold": [],
        "above_or_equal_threshold": []
    }
    
    for num in data:
        if num < threshold:
            result["below_threshold"].append(num)
        else:
            result["above_or_equal_threshold"].append(num)
    
    return result

# 测试函数
data = [5, 10, 15, 20, 2, 8, 12]
processed_data = process_data(data)
print(processed_data)
# 输出:
# {
#     'below_threshold': [5, 2, 8], 
#     'above_or_equal_threshold': [10, 15, 20, 12]
# }

# 带有可选参数的函数注解
def find_item(items: List[str], target: str) -> Optional[int]:
    """在列表中查找指定的元素
    
    参数:
        items: 字符串列表
        target: 要查找的目标字符串
        
    返回:
        目标元素的索引，如果未找到则返回None
    """
    if target in items:
        return items.index(target)
    return None

# 测试函数
fruits = ["apple", "banana", "orange", "grape"]
index = find_item(fruits, "orange")
print(f"orange的索引: {index}")  # 输出: orange的索引: 2

index = find_item(fruits, "watermelon")
print(f"watermelon的索引: {index}")  # 输出: watermelon的索引: None

# 生成器函数基本用法
def count_up_to(n):
    """生成从1到n的数字
    
    参数:
        n: 上限
        
    生成:
        从1到n的整数
    """
    i = 1
    while i <= n:
        yield i  # 使用yield语句产生值
        i += 1

# 创建生成器对象
counter = count_up_to(5)

# 使用next()函数获取生成器产生的值
print(next(counter))  # 输出: 1
print(next(counter))  # 输出: 2
print(next(counter))  # 输出: 3
print(next(counter))  # 输出: 4
print(next(counter))  # 输出: 5
# print(next(counter))  # 这行代码会引发StopIteration异常

# 使用for循环迭代生成器对象
for num in count_up_to(5):
    print(num, end=" ")
# 输出: 1 2 3 4 5

# 生成器函数的特点示例
def fibonacci_generator(n):
    """生成斐波那契数列的前n项
    
    参数:
        n: 项数
        
    生成:
        斐波那契数列的前n项
    """
    a, b = 0, 1
    count = 0
    while count < n:
        yield b
        a, b = b, a + b
        count += 1

# 使用生成器函数生成斐波那契数列
print("斐波那契数列的前10项:")
for num in fibonacci_generator(10):
    print(num, end=" ")
# 输出: 1 1 2 3 5 8 13 21 34 55

# 生成器表达式（类似于列表推导式，但使用圆括号）
squares = (x * x for x in range(10))
print("0到9的平方:")
for square in squares:
    print(square, end=" ")
# 输出: 0 1 4 9 16 25 36 49 64 81

# 装饰器基本用法
def my_decorator(func):
    """一个简单的装饰器
    
    参数:
        func: 要装饰的函数
        
    返回:
        装饰后的函数
    """
    def wrapper():
        """装饰器的包装函数"""
        print("在函数调用之前执行的代码")
        func()  # 调用原函数
        print("在函数调用之后执行的代码")
    return wrapper

# 使用装饰器
@my_decorator  # 这等同于 greet = my_decorator(greet)
def greet():
    """打印问候语"""
    print("Hello, Python!")

# 调用装饰后的函数
greet()
# 输出:
# 在函数调用之前执行的代码
# Hello, Python!
# 在函数调用之后执行的代码

# 带参数的装饰器
import time

def timing_decorator(func):
    """计算函数执行时间的装饰器
    
    参数:
        func: 要装饰的函数
        
    返回:
        装饰后的函数
    """
    def wrapper(*args, **kwargs):
        """装饰器的包装函数"""
        start_time = time.time()  # 记录开始时间
        result = func(*args, **kwargs)  # 调用原函数
        end_time = time.time()  # 记录结束时间
        print(f"函数{func.__name__}执行时间: {end_time - start_time:.6f}秒")
        return result
    return wrapper

# 使用装饰器
@timing_decorator
def calculate_sum(n):
    """计算从1到n的和"""
    total = 0
    for i in range(1, n + 1):
        total += i
    return total

# 调用装饰后的函数
result = calculate_sum(1000000)
print(f"计算结果: {result}")
# 输出类似:
# 函数calculate_sum执行时间: 0.046875秒
# 计算结果: 500000500000