需要更多解释如何实现这个 function 计数器

Question

From The number of times a function gets called .

Let's say, this function is called from outside the file, and I don't have access to it. I am building the function, and I just want to be able to count how many times it has been called from some other part of the program.

I can't use the actual code that calls the function. I do not have access to it. I know normally I should, but for testing purposes, I am not supposed to alter the code that calls the function. So I need to count how many times it is being called without accessing the program that calls the function.

I have tried copy and paste into the file with the function being used like so...

def counted_calls(f):
    @functools.wraps(f)
    def count_wrapper(*args, **kwargs):
        count_wrapper.count += 1
        return f(*args, **kwargs)
    count_wrapper.count = 0
    return count_wrapper

def myfunction(a, b, c, d)
    wrapped = counted_calls(counted_calls)
    integrate.quad(wrapped, 0, 1)
    print(wrapped)
    ****more of my code *****

    return something

First I get this error: Unresolved reference 'f' .

But I get this warning:

Expected type 'Union[function, LowLevelCallable]', got '(args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> Any' instead

Then when I run it, of course, f is not defined.

How do I get this to work so I can count how many times myfunction() is called?

I can't call my function, another part of the program calls this function whenever it wants to. I just need to track how many times it does. I can't go put this in that part of the program and make it call the function this way. I don't have access to it.
so like this?

def counted_calls(f):
    @functools.wraps(f)
    def count_wrapper(*args, **kwargs):
        count_wrapper.count += 1
        return f(*args, **kwargs)
    count_wrapper.count = 0
    return count_wrapper

wrapped = counted_calls(myfunction)
integrate.quad(wrapped, 0, 1)
print(wrapped)


def myfunction(a, b, c, d)
    code code
return something

This returns the error:

TypeError: myfunction() missing 3 required positional arguments: 
'b', 'c', and 'd'

---

I tried this, but still wants more arguments or something?

import functools


def counted_calls(f):
    @functools.wraps(f)
    def count_wrapper(*args, **kwargs):
        count_wrapper.count += 1
        return f(*args, **kwargs)
    count_wrapper.count = 0
    return count_wrapper


@counted_calls  # <-- Apply decorator.
def myfunction(a, b, c, d):
    ...
    return something

integrate.quad(myfunction, 0, 1)
print(myfunction.count)

TypeError: myfunction() missing 3 required positional arguments: b, c, d

So I changed it to what was recommended, however, I'm assuming b , c , and d should be something specific, I just don't know what. I tried as recommended:

import functools


def counted_calls(f):
    @functools.wraps(f)
    def count_wrapper(*args, **kwargs):
        count_wrapper.count += 1
        return f(*args, **kwargs)
    count_wrapper.count = 0
    return count_wrapper


@counted_calls  # <-- Apply decorator.
def myfunction(a, b, c, d):
    ...
    return something

integrate.quad(myfunction, 0, 1, 2, 3) # these need to be variables of some 
                                       # kind? Not sure what to put in this 
                                       # line to make it work
print(myfunction.count)

Still missing 2 required positional arguments: 'c' and 'd'.

I hover over the 2 and it says this:

Expected type 'Union[Iterable, tuple, None]', got 'int' instead 

Answer 1

You need to apply the decorator to the function whose calls you want to count by prefixing its name with a @ and putting it on the line before the function to be decorated definition. Afterwards you can use the function's original name to refer to the wrapped version because using the decorator that way is just "syntactic sugar" (see glossary ) for:

myfunction = counted_calls(myfunction)

Fixed code:

import functools


def counted_calls(f):
    @functools.wraps(f)
    def count_wrapper(*args, **kwargs):
        count_wrapper.count += 1
        return f(*args, **kwargs)
    count_wrapper.count = 0
    return count_wrapper


@counted_calls  # <-- Apply decorator.
def myfunction(a, b, c, d):
    ...
    return something

integrate.quad(myfunction, 0, 1)
print(myfunction.count)

Answer 2

You should be wrapping myfunction . You do this outside the function, not inside the function you want to wrap.

def myfunction(a, b, c, d)
    # ****more of my code *****

    return something

myfunction = counted_calls(myfunction)
# call the other part of your code that uses myfunction
print(myfunction.count)

Answer 3

You can define the decorator as a class that wraps the function. By implementing the __call__ method of the class, its instance can be called like functions which allows the decorator to simply return the instance as the replacement for the declared function:

class CallCounter:
    def __init__(self,func):
        self.func  = func
        self.count = 0
        
    def __call__(self,*args,**kwargs):
        self.count += 1
        return self.func(*args,**kwargs)

usage:

@CallCounter
def myFunction(a,b,c):
    print(a,b,c)

@CallCounter
def myOtherFunction(x):
    return x*5

for i in range(3):
    myFunction(*map(myOtherFunction,(i,i+i,i*i)))
"""
0 0 0
5 10 5
10 20 20
"""

print(myFunction.count)      # 3
print(myOtherFunction.count) # 9

In order to make it work with classes, there would be two methods to add to the CallCounter class:

    def methodCaller(self,obj):
        def withObject(*args,**kwargs):       
            return self(obj,*args,**kwargs)  # inject object instance
        return withObject

    def __get__(self,obj,objtype=None):   # return method call or CallCounter
        return self.methodCaller(obj) if obj else self 

Within a class, the CallCounter behaves like a property object which is accessed through the __get__ method. The __get__ method can apply to the class or to a specific object instance (obj parameter). When an instance is provided in obj, the CallCounter must inject the object in the method call otherwise there will be a missing parameter. This is why it returns a methodCaller function that captures and inserts the obj parameter. When __get__ pertains to the class itself, then the ClassCounter object is returned directly (which allows access to its count).

usage:

class MyClass:

    @CallCounter
    def method1(self,s):
        print("method1",s)

x = MyClass()
for i in range(3): x.method1(i**3)

print(MyClass.method1.count) # 3