Python嵌套函数全面精讲教程-专业级

十一剑的CS_DN博客

已于 2025-07-23 22:21:12 修改

阅读量861

点赞数 35

CC 4.0 BY-SA版权

分类专栏： python 文章标签： python 开发语言

于 2025-07-23 22:18:04 首次发布

本文链接：https://blog.csdn.net/cultivationman/article/details/149583831

python 专栏收录该内容

43 篇文章

订阅专栏

Python嵌套函数全面精讲教程

一、嵌套函数基础概念

嵌套函数（Nested Function）是指在一个函数内部定义另一个函数。Python中函数是一等公民，可以作为参数传递、作为返回值返回，也可以在其他函数内部定义。

1.1 基本嵌套函数示例

def outer():
    print("这是外部函数")
    
    def inner():
        print("这是内部函数")
    
    inner()  # 在外部函数内部调用内部函数

outer()

输出:

这是外部函数

这是内部函数

关键点：

内部函数只能在外部函数的作用域内访问

内部函数可以访问外部函数的变量（闭包特性）

外部函数可以将内部函数作为返回值返回

二、多重函数嵌套

多重嵌套是指函数内部嵌套多层函数，形成层级结构。

2.1 三层嵌套示例

def level1():
    print("层级1")
    
    def level2():
        print("层级2")
        
        def level3():
            print("层级3")
            
            def level4():
                print("层级4")
            
            return level4
        
        return level3
    
    return level2


# 调用方式1：逐步调用
l2 = level1()
l3 = l2()
l4 = l3()
l4()  # 输出: 层级4

# 调用方式2：链式调用
level1()()()()  # 输出: 层级1 层级2 层级3 层级4

2.2 多层嵌套的实际应用：权限验证

def require_auth(level):
    print(f"验证权限级别: {level}")
    
    def decorator1(func):
        print(f"装饰器1处理函数: {func.__name__}")
        
        def decorator2(*args, **kwargs):
            print("装饰器2预处理")
            
            def wrapper(*args, **kwargs):
                print("包装器执行前")
                result = func(*args, **kwargs)
                print("包装器执行后")
                return result
            
            return wrapper(*args, **kwargs)
        
        return decorator2
    
    return decorator1

@require_auth(level="admin")
def sensitive_operation():
    print("执行敏感操作")

sensitive_operation()

三、复杂函数嵌套

复杂嵌套通常涉及多个内部函数之间的交互和外部变量的共享。

3.1 计数器工厂示例

def counter_factory(initial=0):
    count = initial
    counters = []
    
    def current():
        return count
    
    def increment(step=1):
        nonlocal count
        count += step
        return count
    
    def decrement(step=1):
        nonlocal count
        count -= step
        return count
    
    def create_child():
        child_counter = counter_factory(count)
        counters.append(child_counter)
        return child_counter
    
    def get_counters():
        return counters
    
    # 返回一个包含所有内部函数的字典
    return {
        'current': current,
        'increment': increment,
        'decrement': decrement,
        'create_child': create_child,
        'get_counters': get_counters
    }


# 使用示例


counter = counter_factory(10)
print(counter['current']())  # 10
print(counter['increment'](5))  # 15
child = counter['create_child']()
print(child['current']())  # 15
print(child['increment'](3))  # 18
print(counter['current']())  # 15 (父计数器不受影响)

3.2 复杂嵌套的数学计算器

def math_processor():
    operations = {}
    history = []
    
    def register(name):
        def decorator(func):
            operations[name] = func
            
            def wrapper(*args, **kwargs):
                result = func(*args, **kwargs)
                history.append((name, args, kwargs, result))
                return result
            
            return wrapper
        return decorator
    
    def get_operation(name):
        return operations.get(name)
    
    def get_history():
        return history.copy()
    
    def execute_pipeline(steps):
        def pipeline_runner(initial_value):
            current_value = initial_value
            for step in steps:
                op_name, *args = step
                if op_name in operations:
                    current_value = operations[op_name](current_value, *args)
                else:
                    raise ValueError(f"未知操作: {op_name}")
            return current_value
        return pipeline_runner
    
    return {
        'register': register,
        'get_operation': get_operation,
        'get_history': get_history,
        'execute_pipeline': execute_pipeline
    }


# 使用示例


processor = math_processor()

@processor['register']('add')
def add(a, b):
    return a + b

@processor['register']('mul')
def mul(a, b):
    return a * b

@processor['register']('square')
def square(a):
    return a * a

print(processor['get_operation']('add')(2, 3))  # 5

pipeline = processor['execute_pipeline']([
    ('add', 5),
    ('mul', 3),
    ('square',)
])

print(pipeline(10))  # ((10 + 5) * 3)^2 = 2025
print(processor['get_history']())

四、引用函数嵌套（闭包）

闭包是指内部函数引用了外部函数的变量，即使外部函数已经执行完毕。

4.1 基本闭包示例

def outer(msg):
    def inner():
        print(msg)  # 引用了外部函数的变量msg
    return inner

closure = outer("Hello, Closure!")
closure()  # 输出: Hello, Closure!

4.2 闭包的高级应用：状态保持

def create_account(initial_balance):
    balance = initial_balance
    
    def deposit(amount):
        nonlocal balance
        balance += amount
        return balance
    
    def withdraw(amount):
        nonlocal balance
        if amount > balance:
            raise ValueError("余额不足")
        balance -= amount
        return balance
    
    def get_balance():
        return balance
    
    def transfer_to(other_account, amount):
        nonlocal balance
        if amount > balance:
            raise ValueError("余额不足")
        balance -= amount
        other_account['deposit'](amount)
        return balance
    
    return {
        'deposit': deposit,
        'withdraw': withdraw,
        'get_balance': get_balance,
        'transfer_to': transfer_to
    }


# 使用示例


account1 = create_account(1000)
account2 = create_account(500)

print(account1['deposit'](200))  # 1200
print(account1['withdraw'](300))  # 900
account1['transfer_to'](account2, 400)
print(account1['get_balance']())  # 500
print(account2['get_balance']())  # 900

五、回调函数嵌套

回调函数是指作为参数传递给其他函数的函数，常用于异步编程和事件处理。

5.1 基本回调示例

def process_data(data, callback):
    print("处理数据...")
    result = data.upper()  # 模拟数据处理
    callback(result)  # 调用回调函数

def save_result(result):
    print(f"保存结果: {result}")

process_data("hello world", save_result)

5.2 复杂回调嵌套：事件处理器

def event_dispatcher():
    handlers = {}
    
    def register(event_type):
        def decorator(handler):
            if event_type not in handlers:
                handlers[event_type] = []
            handlers[event_type].append(handler)
            return handler
        return decorator
    
    def unregister(event_type, handler):
        if event_type in handlers and handler in handlers[event_type]:
            handlers[event_type].remove(handler)
    
    def dispatch(event_type, *args, **kwargs):
        if event_type in handlers:
            for handler in handlers[event_type]:
                handler(*args, **kwargs)
    
    def chain_handlers(*event_types):
        def decorator(main_handler):
            def wrapped(*args, **kwargs):
                for event_type in event_types:
                    dispatch(event_type, *args, **kwargs)
                return main_handler(*args, **kwargs)
            return wrapped
        return decorator
    
    return {
        'register': register,
        'unregister': unregister,
        'dispatch': dispatch,
        'chain_handlers': chain_handlers
    }


# 使用示例


dispatcher = event_dispatcher()

@dispatcher['register']('pre_process')
def log_pre_process(data):
    print(f"预处理日志: {data}")

@dispatcher['register']('pre_process')
def validate_data(data):
    print(f"验证数据: {data}")

@dispatcher['chain_handlers']('pre_process', 'post_process')
def process_order(order):
    print(f"处理订单: {order}")
    return f"已处理订单: {order}"

@dispatcher['register']('post_process')
def send_confirmation(result):
    print(f"发送确认: {result}")

result = process_order("订单12345")
print(result)

六、嵌套函数的高级应用模式

6.1 函数柯里化

def curry(func):
    def curried(*args, **kwargs):
        if len(args) + len(kwargs) >= func.__code__.co_argcount:
            return func(*args, **kwargs)
        
        def partial(*more_args, **more_kwargs):
            new_args = args + more_args
            new_kwargs = {**kwargs, **more_kwargs}
            return curried(*new_args, **new_kwargs)
        
        return partial
    return curried

@curry
def add_three_numbers(a, b, c):
    return a + b + c

print(add_three_numbers(1)(2)(3))  # 6
print(add_three_numbers(1, 2)(3))  # 6
print(add_three_numbers(1)(2, 3))  # 6

6.2 函数记忆化（Memoization）

def memoize(func):
    cache = {}
    
    def wrapper(*args):
        if args not in cache:
            print(f"计算并缓存结果: {args}")
            cache[args] = func(*args)
        else:
            print(f"使用缓存结果: {args}")
        return cache[args]
    
    return wrapper

@memoize
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # 55

6.3 上下文管理器

def file_manager(filename, mode):
    def opener():
        print(f"打开文件: {filename}")
        file = open(filename, mode)
        
        def closer():
            print(f"关闭文件: {filename}")
            file.close()
        
        return file, closer
    
    def decorator(func):
        def wrapper(*args, **kwargs):
            file, close_fn = opener()
            try:
                result = func(file, *args, **kwargs)
                return result
            finally:
                close_fn()
        return wrapper
    
    return decorator

@file_manager("example.txt", "w")
def write_to_file(file):
    file.write("Hello, World!")

write_to_file()