Hey there! Let's break down your question about Python nested functions (and that specific code example you shared) clearly.

The snippet you showed is the basic structure of a Python decorator—one of the most common use cases for nested functions. Decorators let you wrap another function to add extra behavior without modifying the original function's code directly.

You can find authoritative information directly in Python's official resources:

• The Python Tutorial has a dedicated section on Decorators under the Classes chapter, which covers nested functions and their use in decorators.
• The Function Definitions section of the Python Language Reference explains how nested functions work, including variable scoping (like how inner functions access outer function variables).
• PEP 318 (Decorators for Functions and Methods) is the original proposal that introduced decorator syntax, and it’s a great deep dive into the design and use cases.
• The functools module documentation (specifically the wraps function) is essential for writing clean, production-ready decorators that preserve original function metadata.

Nested functions shine in several scenarios:

• Decorators: As your example shows—adding pre/post processing logic like logging, performance tracking, permission checks, or caching to functions. For instance, you could write a decorator that times how long a function takes to run, or one that verifies a user is authenticated before executing a function.
• Closures: Nested functions can "remember" variables from their outer enclosing function, even after the outer function has finished executing. This is useful for creating stateful functions, like a counter that increments every time it’s called, or a configuration function that generates specialized helper functions based on input parameters.
• Namespace Isolation: By nesting helper functions inside another function, you keep those helpers from cluttering the global namespace. Only the outer function is exposed to the rest of your code, keeping things clean and modular.
• Context-Aware Callbacks: In async code or event-driven systems, nested functions can carry context (like user data or configuration) when passed as callbacks, avoiding the need to use global variables or complex parameter passing.

Let’s walk through using the code you shared:

Step 1: Understand the code structure #

Your example is a decorator that adds before/after print statements to any function:

def une_fonction(fonction):
    def autre_fonction(*param, **param2):
        print "Action avant .............. "
        fonction(*param, **param2)
        print "Action après .............."
    return autre_fonction

• une_fonction: A higher-order function that takes another function (fonction) as input.
• autre_fonction: The nested inner function that wraps the original function. It accepts any positional (*param) and keyword (**param2) arguments to match the original function’s signature.
• When you call the returned autre_fonction, it runs the pre-action print, executes the original function with its arguments, then runs the post-action print.

Step 2: Use the decorator #

You can apply it two ways:

Option 1: Manual wrapping

# Define a function to wrap
def salut():
    print "Salut tout le monde!"

# Wrap it with your decorator
salut = une_fonction(salut)

# Call the wrapped function
salut()

Output:

Action avant .............. 
Salut tout le monde!
Action après ..............

Option 2: Use Python’s decorator syntax sugar (@)

This is the cleaner, more common way:

@une_fonction
def salut():
    print "Salut tout le monde!"

salut()

This does exactly the same thing as the manual wrapping—Python handles assigning the wrapped function back to the original name for you.

Step 3: Improve the decorator (best practice) #

A key improvement is using functools.wraps to preserve the original function’s metadata (like its name, docstring, and parameters). Without this, tools that inspect your function will see the inner function’s metadata instead of the original’s:

from functools import wraps

def une_fonction(fonction):
    @wraps(fonction)  # Preserve original function metadata
    def autre_fonction(*param, **param2):
        print "Action avant .............. "
        result = fonction(*param, **param2)  # Capture the original function's result
        print "Action après .............."
        return result  # Return the result so the caller gets it
    return autre_fonction

Now if you check salut.__name__, it will still be "salut" instead of "autre_fonction", and any docstring you added to salut will be preserved.

内容的提问来源于stack exchange，提问作者Pat. ANDRIA