Understanding Python Decorators: A Beginner's Guide with Examples

Python Decorators: Beginner’s Guide and Examples

Python decorators are powerful and versatile tools for modifying the behavior of functions or methods. They allow you to add functionality to existing code without changing its structure. This article takes an in-depth look at decorators and provides simple examples to help you understand and use them effectively.

---

What is a decorator?

A decorator in Python is essentially a function that receives another function as an argument and extends or changes its behavior. Decorators are typically used to add functionality such as logging, access control, memoization, or validation to an existing function or method.

Decorators in Python are applied on function definitions using the @decorator_name syntax.

---

Structure of decorator

A basic decorator function has the following structure:

<code class="language-python">def decorator_function(original_function):
    def wrapper_function(*args, **kwargs):
        # 在原始函数执行之前的代码
        result = original_function(*args, **kwargs)
        # 在原始函数执行之后的代码
        return result
    return wrapper_function</code>

Apply Decorator

You can apply decorators to functions using the @decorator_name syntax or manually:

<code class="language-python">@decorator_function
def some_function():
    print("这是原始函数。")

# 等同于：
# some_function = decorator_function(some_function)</code>

---

Example 1: Basic Decorator

Let's create a simple decorator that prints a message before and after the function runs.

<code class="language-python">def simple_decorator(func):
    def wrapper():
        print("函数调用之前。")
        func()
        print("函数调用之后。")
    return wrapper

@simple_decorator
def say_hello():
    print("Hello, World!")

say_hello()</code>

Output:

<code>函数调用之前。
Hello, World!
函数调用之后。</code>

---

Example 2: Decorator with parameters

You can create a decorator that accepts a parameter by wrapping it in another function.

<code class="language-python">def repeat_decorator(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat_decorator(3)
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")</code>

Output:

<code>Hello, Alice!
Hello, Alice!
Hello, Alice!</code>

---

Practical application of decorators

Decorators are widely used in practical scenarios. Here are some simplified practical examples:

1. Record user operations

You can use decorators to record every time the user performs an action.

<code class="language-python">def log_action(func):
    def wrapper(*args, **kwargs):
        print(f"操作：正在执行 {func.__name__}。")
        return func(*args, **kwargs)
    return wrapper

@log_action
def upload_file(filename):
    print(f"正在上传 {filename}...")

upload_file("report.pdf")</code>

Output:

<code>操作：正在执行 upload_file。
正在上传 report.pdf...</code>

---

2. Track execution time

Track the time it takes for a task to execute, which is useful for performance monitoring.

<code class="language-python">import time

def track_time(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} 执行耗时 {end - start:.2f} 秒。")
        return result
    return wrapper

@track_time
def download_file(file_size):
    time.sleep(file_size / 10)  # 模拟下载时间
    print("下载完成。")

download_file(50)</code>

Output:

<code>下载完成。
download_file 执行耗时 5.00 秒。</code>

---

3. Add user greeting

Decorators can personalize greetings by adding dynamic elements.

<code class="language-python">def add_greeting(func):
    def wrapper(name):
        print("您好，欢迎！")
        func(name)
    return wrapper

@add_greeting
def show_user_profile(name):
    print(f"用户资料：{name}")

show_user_profile("Alice")</code>

Output:

<code>您好，欢迎！
用户资料：Alice</code>

---

Key Points

• Decorators are a powerful way to modify the behavior of a function or method.
• They simplify repetitive tasks such as logging, timing, or personalization.
• They can be easily applied using the @decorator syntax.
• Decorators can accept parameters and be nested to enhance flexibility.

By mastering decorators, you will acquire a valuable tool for writing concise and efficient Python code. Start trying out the provided examples to get familiar with the concept!

The above is the detailed content of Understanding Python Decorators: A Beginner's Guide with Examples. For more information, please follow other related articles on the PHP Chinese website!