为何部分Python代码中包装器与被包装函数相同？GAN代码wraps用法疑问

Great question—this is a clever use of functools.wraps that's easy to miss if you're only used to seeing it in standard decorator patterns. Let's break this down clearly.

First, a quick refresher: functools.wraps is a decorator that copies critical metadata (like function name, docstring, parameter annotations, and module info) from a "source" function to the function it's decorating. Normally, this is used when you write a decorator that wraps a function—without wraps, the wrapped function would lose all its original metadata, which breaks things like auto-completion, docstring tools, or code that checks function attributes.

Now, looking at your code snippet:

@functools.wraps(Model.get_lr_scalers)
def get_lr_scalers(self):
    # Custom subclass implementation

Why use wraps here? #

This is a subclass overriding a parent Model method, and wraps is being used to inherit the parent method's metadata. Here's why that's useful:

• Preserve helpful documentation: If the parent Model.get_lr_scalers has a detailed docstring explaining its purpose, parameters, or return values, wraps copies that docstring to the subclass method. This keeps your code's documentation consistent and saves you from retyping the same docs in every subclass.
• Keep metadata-dependent code working: Some frameworks, testing tools, or custom scripts rely on checking attributes like __name__ or __annotations__. Without wraps, the subclass method's metadata would only reflect its own definition (e.g., an empty docstring if you didn't write one), which could cause unexpected bugs.
• Signal intent clearly: It's a visual cue to other developers that this method is intentionally overriding Model.get_lr_scalers, and we want to retain the parent method's metadata alongside our custom logic.

Why would a wrapper and wrapped function share the same name? #

In this case, it's because we're overriding a parent class method—so the subclass method must have the same name to properly replace the parent's behavior. Here, the "wrapped" function is the parent Model.get_lr_scalers, and the "wrapper" is the subclass's own get_lr_scalers implementation. We're not replacing the parent method; we're writing a new version that inherits the parent's metadata via wraps.

To put it in context: if the parent class had this:

class Model:
    def get_lr_scalers(self):
        """Returns learning rate scaling factors for each model parameter."""
        # Parent logic here

Without wraps, running help(MySubclass.get_lr_scalers) would show no docstring. With wraps, it would show the parent's docstring, making your subclass much easier to use and understand.

内容的提问来源于stack exchange，提问作者fnosdy