python装饰的数据类方法为所有实例共享

Question

I'm implementing a python decorator with an internal memory (represented by counter below).

It seams the decorator variables are shared across instances of a dataclass while being different for instances of a common class .

Why is so? And is there a cleaner/easier solution other than checking if f belongs to a class or not and if so, if the class is a dataclass ?

import dataclasses

def decorator(f):
    counter = {}
    def wrapper(*args, **kwargs):
        key = repr([f.__name__, args, kwargs])
        counter[key] = counter.setdefault(key, 0)+1
        result = f(*args, **kwargs)
        print(f"{counter[key]}", end=" ")
        return result
    return wrapper

@dataclasses.dataclass
class D:
    @decorator
    def foo(self):
        pass

class C:
    @decorator
    def foo(self):
        pass

Despide C and D being very similar, the code below shows that the instances of normal object have different counter each:

>>> for i in range(5):
...     c = C()
...     c.foo()
1 1 1 1 1

While when using the dataclass instead, the counter is shared:

>>> for i in range(5):
...     c = D()
...     c.foo()
1 2 3 4 5

Answer 1

Decorator syntax is a shortcut for function application, so each use of @decorator is a separate call to decorator , each of which creates a new dict associated with the decorated function.

So it's one counter per decorated function, and there is one decorated function per class in your example.

But then there's another problem. Your key depends on each class's __repr__ function, as *args includes the object itself.

For C , __repr__ is not defined, so object.__repr__ is used, producing a unique key for each instance.

For D , D.__repr__ returns a generic string 'D()' for every instance, so you aren't getting unique keys for instances of D .

The solution is to be more explicit in constructing the key. Perhaps something like

from collections import Counter


def decorator(f):
    counter = Counter()
    def wrapper(*args, **kwargs):
        key = repr([id(f.__name__), [id(x) for x in args], [id(x) for x in kwargs.items()]])
        counter[key] += 1
        result = f(*args, **kwargs)
        # print(f"{counter[key]}", end=" ")
        return result
    return wrapper

Answer 2

As you're decorating methods rather than functions, the value of *args in wrapper(*args, **kwargs) will be a one element tuple containing the implicit self .

Your key value would then look like this ['foo', (<__main__.C object at 0x7fe8945403c8>,), {}] .

As those instances of C and D get garbage collected, sometimes Python will reuse the same memory address and sometimes not, leading to different keys.

I'm not sure why Python would reuse dataclass addresses more than for regular classes.

If you change wrapper to expect self , you should get consistent results.

def decorator(f):
    counter = {}
    def wrapper(self, *args, **kwargs):
        key = repr([f.__name__, args, kwargs])
        counter[key] = counter.setdefault(key, 0)+1
        result = f(self, *args, **kwargs)
        print(f"{counter[key]}", end=" ")
        return result
    return wrapper