Python Decorators — From Simple Functions to Class-Based & Parameterised

The Story That Explains Decorators 🎁Decorators समझाने वाली कहानी 🎁一个讲清装饰器的故事 🎁

In Python, functions are first-class objects. You can pass them to other functions, return them from functions and store them in variables. A decorator is simply a function (or a class) that takes a function and returns a new one. The new one usually calls the original, with something extra added before, after or around it.

Python में functions first-class objects हैं। आप उन्हें दूसरे functions को दे सकते हैं, functions से लौटा सकते हैं और variables में रख सकते हैं। Decorator बस एक function (या class) है जो एक function लेता है और नया लौटाता है। नया वाला आमतौर पर मूल को ही बुलाता है, बस उसके पहले, बाद में या चारों ओर कुछ अतिरिक्त जोड़कर।

在 Python 中，函数是 一等对象（first-class objects）。你可以把它们传给别的函数、从函数中返回它们、把它们存进变量。装饰器 就是一个接收函数并返回新函数的函数（或类）。新函数通常会调用原函数，只是在它之前、之后或周围加了点额外的东西。

The Foundation — Functions Are Objects 🧱नींव — Functions भी Objects हैं 🧱基础 — 函数也是对象 🧱

Before decorators make sense, accept one fact: in Python a function is just another object. You can give it a new name, put it in a list, pass it as an argument or return it from another function.

Decorators समझने से पहले एक बात मान लीजिए: Python में function भी बस एक object है। आप उसे नया नाम दे सकते हैं, list में रख सकते हैं, argument की तरह भेज सकते हैं या दूसरे function से लौटा सकते हैं।

在理解装饰器之前，先接受一个事实：在 Python 中，函数也只是一个对象。你可以给它起新名字、放进列表、作为参数传递，或者从另一个函数中返回它。

def greet(name):
    return f"Hello, {name}!"

# 1. Assign the function to a new name (no parentheses!)
say_hi = greet
print(say_hi("Mohit"))          # -> Hello, Mohit!

# 2. Pass a function as an argument
def shout(fn, name):
    return fn(name).upper()

print(shout(greet, "Mohit"))    # -> HELLO, MOHIT!

# 3. Return a function from another function
def make_multiplier(n):
    def multiplier(x):
        return x * n
    return multiplier

double = make_multiplier(2)
print(double(7))                # -> 14

Your First Decorator — Written by Hand ✍️आपका पहला Decorator — हाथ से लिखा ✍️你的第一个装饰器 — 手写版 ✍️

Let us build a decorator that prints a message before and after any function runs. First without the @ syntax, so you see what really happens.

चलिए एक decorator बनाते हैं जो किसी भी function के चलने से पहले और बाद में message print करे। पहले @ syntax के बिना, ताकि आप देखें असल में क्या होता है।

我们来写一个装饰器，在任何函数运行前后各打印一条消息。先不用 @ 语法，这样你能看清到底发生了什么。

def announce(fn):                  # takes a function
    def wrapper():                 # builds a new function
        print("-- before --")
        result = fn()              # call the original
        print("-- after  --")
        return result
    return wrapper                 # returns the wrapper

def say_hello():
    print("Hello!")

# Manually wrap it
say_hello = announce(say_hello)
say_hello()

Now the same thing with the @ syntax. It is syntactic sugar for say_hello = announce(say_hello). The last line shows that the name say_hello now points to wrapper:

अब वही काम @ syntax से। यह say_hello = announce(say_hello) का syntactic sugar है। आख़िरी line दिखाती है कि नाम say_hello अब wrapper की ओर इशारा करता है:

现在用 @ 语法做同样的事。它是 say_hello = announce(say_hello) 的 语法糖。最后一行显示，名字 say_hello 现在指向的是 wrapper：

def announce(fn):
    def wrapper():
        print("-- before --")
        result = fn()
        print("-- after  --")
        return result
    return wrapper

@announce                          # the magic line
def say_hello():
    print("Hello!")

say_hello()
print(say_hello.__name__)          # the name now points to wrapper

def deco(fn):
    print("2. deco() runs, it receives", fn.__name__)
    return fn

def pick():
    print("1. the decorator expression is evaluated first")
    return deco

@pick()
def task():
    pass

print("3. task is ready")

Handling Arguments — *args and **kwargs 📦Arguments सँभालना — *args और **kwargs 📦处理参数 — *args 与 **kwargs 📦

Real functions take arguments. To make your decorator work with any function, whatever its parameters, use *args, **kwargs in the wrapper. It collects every positional and keyword argument and passes them on unchanged.

असली functions arguments लेते हैं। अपने decorator को किसी भी function के साथ चलाने के लिए, चाहे उसके parameters कुछ भी हों, wrapper में *args, **kwargs लिखिए। यह हर positional और keyword argument इकट्ठा करके बिना बदले आगे भेज देता है।

真实的函数都有参数。要让装饰器适用于 任何 函数（不管参数是什么），就在 wrapper 中使用 *args, **kwargs。它会收集所有位置参数和关键字参数，并原样转发。

def announce(fn):
    def wrapper(*args, **kwargs):
        print(f"Calling {fn.__name__} with {args} {kwargs}")
        result = fn(*args, **kwargs)
        print(f"{fn.__name__} returned {result!r}")
        return result
    return wrapper

@announce
def add(a, b):
    return a + b

@announce
def greet(name, greeting="Hi"):
    return f"{greeting}, {name}!"

add(3, 4)
greet("Mohit", greeting="Namaste")

Keeping the Name and Docstring — functools.wraps 🏷️नाम और Docstring बचाना — functools.wraps 🏷️保留名字和文档 — functools.wraps 🏷️

When you decorate a function, the name now points to the wrapper. So __name__, __doc__ and the signature you see are the wrapper's, not the original's. This confuses debuggers, IDEs, help() and documentation tools. The fix is one line: @functools.wraps(fn).

Function को decorate करने पर नाम अब wrapper की ओर इशारा करता है। इसलिए जो __name__, __doc__ और signature दिखते हैं, वे wrapper के हैं, मूल के नहीं। इससे debuggers, IDEs, help() और documentation tools भ्रमित होते हैं। इलाज एक line है: @functools.wraps(fn)।

装饰一个函数后，这个名字指向的是 wrapper。因此你看到的 __name__、__doc__ 和函数签名都是 wrapper 的，而不是原函数的。这会让调试器、IDE、help() 和文档工具产生混乱。解决办法只要一行：@functools.wraps(fn)。

from functools import wraps

def announce(fn):
    @wraps(fn)                     # preserves metadata
    def wrapper(*args, **kwargs):
        print(f"Calling {fn.__name__}")
        return fn(*args, **kwargs)
    return wrapper

@announce
def add(a, b):
    """Add two numbers."""
    return a + b

print(add.__name__)                # -> add (not 'wrapper')
print(add.__doc__)                 # -> Add two numbers.
print(add.__wrapped__)             # the original, undecorated add

🏷️ Simulator: @wraps Lab🏷️ Simulator: @wraps Lab🏷️ 模拟器：@wraps 实验室

Switch @wraps off and on. Every value below was printed by real Python for the same add function.

@wraps को बंद और चालू कीजिए। नीचे की हर value उसी add function के लिए असली Python ने print की है।

把 @wraps 关掉再打开。下面每个值都是真实 Python 针对同一个 add 函数打印出来的。

Picture It — How a Decorator Wraps a Function 🖼️तस्वीर में — Decorator Function को कैसे लपेटता है 🖼️图解 — 装饰器如何包裹函数 🖼️

Here is the mental model. The original function is the gift; the decorator is the wrapping paper. Once wrapped, every call goes through the wrapper: it does its "before" work, calls the inner function, does its "after" work and returns the result.

यह रहा मन का चित्र। मूल function gift है; decorator wrapping paper है। लपेटने के बाद हर call wrapper से होकर जाती है: वह अपना "पहले" वाला काम करता है, अंदर का function बुलाता है, "बाद" वाला काम करता है और नतीजा लौटाता है।

这是心智模型：原函数是礼物，装饰器是包装纸。包好以后，每次调用都经过 wrapper：它先做"之前"的工作，再调用里面的函数，然后做"之后"的工作，最后返回结果。

Definition Time vs Call TimeDefinition Time बनाम Call Time定义时 vs 调用时

👣 Simulator: Decorator Step by Step👣 Simulator: Decorator क़दम-दर-क़दम👣 模拟器：装饰器逐步演示

Walk through a real run, one step at a time. Watch the global name change from ƒ say_hello to ƒ wrapper during definition time, and watch fn inside the wrapper still point to the original. Every step was recorded from Python with sys.settrace. (These examples skip @wraps so the names stay easy to tell apart.)

एक असली run को क़दम-दर-क़दम देखिए। Definition time में global नाम को ƒ say_hello से ƒ wrapper बनते देखिए, और देखिए कि wrapper के अंदर fn अब भी मूल की ओर इशारा करता है। हर क़दम Python से sys.settrace द्वारा रिकॉर्ड किया गया। (इन examples में @wraps नहीं है ताकि नाम आसानी से पहचाने जा सकें।)

一步一步地看一次真实运行。观察在定义时全局名字如何从 ƒ say_hello 变成 ƒ wrapper，并观察 wrapper 里的 fn 仍然指向原函数。每一步都是用 sys.settrace 从 Python 中记录的。（这些例子没用 @wraps，方便区分名字。）

Decorators That Take Arguments 🎚️Arguments लेने वाले Decorators 🎚️带参数的装饰器 🎚️

What if you want @repeat(3) to run a function three times, or @retry(times=5) to try again on failure? Now the decorator itself needs arguments. That needs three levels of nested functions:

अगर आप चाहें कि @repeat(3) किसी function को तीन बार चलाए, या @retry(times=5) fail होने पर दोबारा कोशिश करे? अब decorator को ख़ुद arguments चाहिए। इसके लिए nested functions के तीन स्तर चाहिए:

如果你想让 @repeat(3) 把函数运行三次，或者让 @retry(times=5) 在失败时重试呢？这时装饰器本身需要参数。这就需要 三层 嵌套函数：

from functools import wraps

def repeat(times):                         # Layer 1 - takes decorator args
    def decorator(fn):                     # Layer 2 - real decorator
        @wraps(fn)
        def wrapper(*args, **kwargs):      # Layer 3 - runtime
            result = None
            for _ in range(times):
                result = fn(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)                                 # note: @repeat(3), not @repeat
def greet(name):
    print(f"Hi, {name}!")

greet("Mohit")

Practical Examples — @timer, @retry, @cache 🧰काम के Examples — @timer, @retry, @cache 🧰实用示例 — @timer、@retry、@cache 🧰

⏱️ @timer — measure how long a call takes⏱️ @timer — call में कितना समय लगा⏱️ @timer — 测量调用耗时

import time
from functools import wraps

def timer(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = fn(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{fn.__name__} took {elapsed*1000:.2f} ms")
        return result
    return wrapper

@timer
def slow_sum(n):
    return sum(range(n))

slow_sum(1_000_000)

🔁 @retry — try again after an exception (takes arguments)🔁 @retry — exception के बाद दोबारा कोशिश (arguments लेता है)🔁 @retry — 出现异常后重试（带参数）

import time, random
from functools import wraps

def retry(times=3, delay=1.0):
    def decorator(fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            last_error = None
            for attempt in range(1, times + 1):
                try:
                    return fn(*args, **kwargs)
                except Exception as e:
                    last_error = e
                    print(f"[attempt {attempt}] failed: {e}")
                    time.sleep(delay)
            raise last_error
        return wrapper
    return decorator

@retry(times=3, delay=0.5)
def flaky_api_call():
    if random.random() < 0.7:          # fails 70% of the time
        raise ConnectionError("server busy")
    return "OK"

random.seed(11)                        # fixed seed, so you see the same run as below
print(flaky_api_call())

🗄️ @cache — remember expensive results🗄️ @cache — महँगे नतीजे याद रखें🗄️ @cache — 记住代价高的结果

from functools import wraps

def cache(fn):
    stored = {}
    @wraps(fn)
    def wrapper(*args):
        if args not in stored:
            stored[args] = fn(*args)
        return stored[args]
    return wrapper

@cache
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

print(fib(50))      # instant with the cache

import time

def fib(n):                       # NO cache
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

start = time.perf_counter()
fib(30)
sec = time.perf_counter() - start
print(f"fib(30) without cache: {sec:.2f} s")

# fib(n) makes 2*fib(n+1) - 1 calls when there is no cache
calls = lambda n: 2 * ((((1 + 5**0.5) / 2)**(n + 1)) / 5**0.5) - 1
est = sec * calls(50) / calls(30) / 60
print(f"fib(50) would make {calls(50):,.0f} calls")
print(f"fib(50) without cache: about {est:.0f} minutes")

🏁 Simulator: Cache Race🏁 Simulator: Cache Race🏁 模拟器：缓存赛跑

Pick n and switch the cache on or off. For small n you see the whole call tree grow; green nodes were answered from the cache without running the body. The counts were checked against Python for n = 0 to 25.

n चुनिए और cache चालू या बंद कीजिए। छोटे n पर आप पूरा call tree बढ़ता देखेंगे; हरे nodes का जवाब cache से मिला, body चलाए बिना। गिनतियाँ n = 0 से 25 तक Python से जाँची गईं।

选择 n，打开或关闭缓存。n 较小时可以看到整棵调用树逐渐长出来；绿色节点直接从缓存拿到答案，没有运行函数体。n = 0 到 25 的计数都已与 Python 核对。

Class-Based Decorators 🏛️Class-Based Decorators 🏛️基于类的装饰器 🏛️

A decorator does not have to be a function — anything callable works. A class becomes a decorator with __init__ (receives the function) and __call__ (runs when the decorated function is called).

Decorator का function होना ज़रूरी नहीं — कोई भी callable चलेगा। Class __init__ (function लेता है) और __call__ (decorated function बुलाने पर चलता है) से decorator बन जाती है।

装饰器不一定是函数 — 任何可调用对象都行。一个类只要有 __init__（接收函数）和 __call__（被装饰函数被调用时运行），就能当装饰器。

CountCalls — a class-based decorator with stateCountCalls — state वाला class-based decoratorCountCalls — 带状态的基于类的装饰器

from functools import wraps

class CountCalls:
    def __init__(self, fn):
        wraps(fn)(self)                # preserve metadata
        self.fn = fn
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"{self.fn.__name__} call #{self.count}")
        return self.fn(*args, **kwargs)

    def reset(self):
        self.count = 0

@CountCalls
def say_hi(name):
    print(f"Hi, {name}!")

say_hi("Mohit")
say_hi("Aarav")
say_hi("Priya")
print(f"Total: {say_hi.count} calls")    # -> 3
say_hi.reset()
print(f"After reset: {say_hi.count}")    # -> 0

A class-based decorator that takes argumentsArguments लेने वाला class-based decorator带参数的基于类的装饰器

from functools import wraps

class Repeat:
    def __init__(self, times):             # Layer 1 - receives args
        self.times = times

    def __call__(self, fn):                # Layer 2 - receives fn
        @wraps(fn)
        def wrapper(*args, **kwargs):      # Layer 3 - runtime
            result = None
            for _ in range(self.times):
                result = fn(*args, **kwargs)
            return result
        return wrapper

@Repeat(2)
def shout(msg):
    print(msg.upper())

shout("hello")

Function vs Class — When to Use Which ⚖️Function बनाम Class — कब कौन-सा ⚖️函数 vs 类 — 何时用哪个 ⚖️

Stacking Several Decorators 🥞कई Decorators एक के ऊपर एक 🥞叠加多个装饰器 🥞

You can stack decorators. They are applied bottom-up: the one closest to the function wraps it first, then the next one wraps that, and so on. But when you call the function, the wrappers run top-down.

आप decorators एक के ऊपर एक लगा सकते हैं। वे नीचे से ऊपर लगते हैं: function के सबसे पास वाला उसे पहले लपेटता है, फिर अगला उसे लपेटता है, और आगे भी ऐसे ही। पर function बुलाने पर wrappers ऊपर से नीचे चलते हैं।

装饰器可以叠加。它们 从下往上应用：离函数最近的那个先包住它，接着下一个再包住这一层，依此类推。但调用函数时，各层 wrapper 从上往下执行。

def bold(fn):
    def wrapper(*a, **k):
        return f"<b>{fn(*a, **k)}</b>"
    return wrapper

def italic(fn):
    def wrapper(*a, **k):
        return f"<i>{fn(*a, **k)}</i>"
    return wrapper

@bold                              # applied SECOND - outermost
@italic                            # applied FIRST  - innermost
def say(msg):
    return msg

print(say("hello"))
# Equivalent to: say = bold(italic(say))

🥞 Simulator: Stack Lab🥞 Simulator: Stack Lab🥞 模拟器：堆叠实验室

Build your own stack of up to three decorators and call say("hello"). Watch the wrapping order, then the call go down through the layers and the return values come back up. Every one of the 85 possible stacks was checked against Python.

तीन तक decorators का अपना stack बनाइए और say("hello") बुलाइए। लपेटने का क्रम देखिए, फिर call को परतों में नीचे जाते और return values को ऊपर लौटते देखिए। सभी 85 संभव stacks Python से जाँचे गए।

自己搭一个最多三层的装饰器栈，然后调用 say("hello")。先看包装顺序，再看调用如何一层层往下走、返回值如何一层层往上回。全部 85 种可能的组合都已与 Python 核对。

The four decorators used in the lab are as simple as bold and italic above:

Lab में इस्तेमाल हुए चारों decorators ऊपर वाले bold और italic जितने ही सरल हैं:

实验室里用到的四个装饰器和上面的 bold、italic 一样简单：

def bold(fn):
    def wrapper(*a, **k):
        r = fn(*a, **k)
        return f"<b>{r}</b>"
    return wrapper

def italic(fn):
    def wrapper(*a, **k):
        r = fn(*a, **k)
        return f"<i>{r}</i>"
    return wrapper

def upper(fn):
    def wrapper(*a, **k):
        r = fn(*a, **k)
        return r.upper()
    return wrapper

def exclaim(fn):
    def wrapper(*a, **k):
        r = fn(*a, **k)
        return r + "!"
    return wrapper

Real-World Example — @login_required 🔐असली Example — @login_required 🔐真实案例 — @login_required 🔐

Now let us build the classic login decorator. In web frameworks, @login_required is the best-known use of decorators — it guards view functions so only logged-in users can call them.

अब classic login decorator बनाते हैं। Web frameworks में @login_required decorators का सबसे जाना-माना इस्तेमाल है — यह view functions की रखवाली करता है ताकि सिर्फ़ logged-in users उन्हें बुला सकें।

现在来写经典的登录装饰器。在 Web 框架中，@login_required 是装饰器最有名的用法 — 它守护视图函数，只有已登录的用户才能调用。

Version 1 — a simple @login_requiredVersion 1 — सरल @login_required版本 1 — 简单的 @login_required

from functools import wraps

# Fake session - in a real app this comes from Flask/Django
current_session = {"user": None}

def login_required(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        user = current_session.get("user")
        if user is None:
            raise PermissionError("Login required")
        return fn(*args, **kwargs)
    return wrapper

@login_required
def view_dashboard():
    return f"Welcome, {current_session['user']['name']}!"

# --- Try it without logging in ---
try:
    view_dashboard()
except PermissionError as e:
    print(f"Blocked: {e}")

# --- Log in and try again ---
current_session["user"] = {"name": "Mohit", "role": "admin"}
print(view_dashboard())

Version 2 — @requires_role("admin") with argumentsVersion 2 — Arguments के साथ @requires_role("admin")版本 2 — 带参数的 @requires_role("admin")

Now we add arguments. We want @requires_role("admin") to allow only users with a matching role. This uses the three-layer pattern from Section 07.

अब arguments जोड़ते हैं। हम चाहते हैं कि @requires_role("admin") सिर्फ़ मेल खाने वाले role वाले users को आने दे। इसमें Section 07 का तीन-परत वाला pattern लगता है।

现在加入参数。我们希望 @requires_role("admin") 只放行角色匹配的用户。这里用的就是第 07 节的三层模式。

from functools import wraps

current_session = {"user": None}

def requires_role(*allowed_roles):         # Layer 1 - decorator args
    def decorator(fn):                     # Layer 2 - real decorator
        @wraps(fn)
        def wrapper(*args, **kwargs):      # Layer 3 - runtime
            user = current_session.get("user")
            if user is None:
                raise PermissionError("Login required")
            if user["role"] not in allowed_roles:
                raise PermissionError(
                    f"Role '{user['role']}' not in {allowed_roles}"
                )
            return fn(*args, **kwargs)
        return wrapper
    return decorator

@requires_role("admin")
def delete_all_users():
    return "All users deleted!"

@requires_role("admin", "editor")
def publish_article(title):
    return f"Published: {title}"

# --- Editor tries admin-only action ---
current_session["user"] = {"name": "Priya", "role": "editor"}
try:
    delete_all_users()
except PermissionError as e:
    print(f"Blocked: {e}")
print(publish_article("Python Decorators"))

# --- Admin can do both ---
current_session["user"] = {"name": "Mohit", "role": "admin"}
print(delete_all_users())

Version 3 — class-based @LoginRequired with an audit logVersion 3 — Audit log के साथ class-based @LoginRequired版本 3 — 带审计日志的基于类的 @LoginRequired

A class keeps state between calls, so it can log every attempt and report statistics.

Class calls के बीच state रखती है, इसलिए वह हर कोशिश का log रख सकती है और statistics बता सकती है।

类能在多次调用之间保存状态，所以它可以记录每一次尝试并给出统计。

from functools import wraps
from datetime import datetime

current_session = {"user": None}

class LoginRequired:
    def __init__(self, fn):
        wraps(fn)(self)
        self.fn = fn
        self.granted = 0
        self.denied = 0
        self.log = []

    def __call__(self, *args, **kwargs):
        user = current_session.get("user")
        ts = datetime.now().strftime("%H:%M:%S")
        if user is None:
            self.denied += 1
            self.log.append((ts, "DENIED", self.fn.__name__))
            raise PermissionError("Login required")
        self.granted += 1
        self.log.append((ts, "GRANTED", user["name"]))
        return self.fn(*args, **kwargs)

    def stats(self):
        return {"granted": self.granted, "denied": self.denied}

@LoginRequired
def view_profile():
    return f"Profile of {current_session['user']['name']}"

# Simulate a mix of logged-in and logged-out attempts
for user in [None, {"name": "Mohit"}, None, {"name": "Aarav"}]:
    current_session["user"] = user
    try:
        view_profile()
    except PermissionError:
        pass

print(view_profile.stats())
for entry in view_profile.log:
    print(entry)

🔐 Simulator: Login Gate🔐 Simulator: Login Gate🔐 模拟器：登录关卡

Choose who is logged in and which protected function to call, then send the request through the gate. The results were produced by running the Version 1 and Version 2 decorators in Python; the audit log counts attempts like Version 3.

चुनिए कौन logged-in है और कौन-सा protected function बुलाना है, फिर request को gate से भेजिए। नतीजे Version 1 और Version 2 वाले decorators को Python में चलाकर बने हैं; audit log Version 3 की तरह कोशिशें गिनता है।

选择谁已登录、要调用哪个受保护的函数，然后把请求送过关卡。结果是在 Python 中运行版本 1 和版本 2 的装饰器得到的；审计日志像版本 3 一样统计每次尝试。

Built-in Decorators You Should Know 📚Built-in Decorators जो आपको पता होने चाहिए 📚你应该知道的内置装饰器 📚

class User:
    def __init__(self, first, last):
        self._first = first
        self._last = last

    @property                          # access as attribute
    def full_name(self):
        return f"{self._first} {self._last}"

    @classmethod                       # alternative constructor
    def from_string(cls, s):
        first, last = s.split(" ", 1)
        return cls(first, last)

    @staticmethod                      # utility, no self/cls
    def is_valid_name(s):
        return len(s.split()) >= 2

u = User.from_string("Mohit Kumar")
print(u.full_name)                     # -> Mohit Kumar (no parens!)
print(User.is_valid_name("Mohit Kumar"))

Common Pitfalls (and Good Habits) 🩹आम ग़लतियाँ (और अच्छी आदतें) 🩹常见陷阱（与好习惯）🩹

from functools import wraps

class CountCalls:
    def __init__(self, fn):
        wraps(fn)(self)
        self.fn = fn
        self.count = 0
    def __call__(self, *args, **kwargs):
        self.count += 1
        return self.fn(*args, **kwargs)

class Greeter:
    @CountCalls
    def hello(self):
        return "hello"

try:
    Greeter().hello()
except TypeError as e:
    print("TypeError:", e)

A function decorator on the same kind of method works, and you can see self arrive as the first item of args:

उसी तरह के method पर function decorator चलता है, और आप self को args के पहले item के रूप में आते देख सकते हैं:

同样的方法换成函数装饰器就能正常工作，还能看到 self 作为 args 的第一个元素传进来：

from functools import wraps

def announce(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        print("args =", args)          # self is args[0]
        return fn(*args, **kwargs)
    return wrapper

class Greeter:
    @announce
    def hello(self, name):
        return f"hello, {name}"

print(Greeter().hello("Mohit"))

🩺 Simulator: Bug Doctor🩺 Simulator: Bug Doctor🩺 模拟器：Bug 医生

Six real decorator mistakes. Buggy code on the left, fixed code on the right, changed lines marked. Every output is from a real run.

Decorators की छह असली ग़लतियाँ। बाईं ओर buggy code, दाईं ओर ठीक किया हुआ, बदली lines चिह्नित। हर output असली run से है।

六个真实的装饰器错误。左边是有 bug 的代码，右边是修正后的代码，改动的行已标出。每个输出都来自真实运行。

Golden Rules and Quiz 🏆सुनहरे नियम और Quiz 🏆黄金法则与小测验 🏆

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题