If you don't want to rewrite your recursive function, you could also decorate it in a function that counts it using a counter of some sort. Example of an implementation:
UPDATE: I've changed the answer, but the old answer is kept at the end of the answer //UPDATE
Assume here that you have some recursion functions in some_module.py:
# From some_module.py def factorial(x): return factorial(x-1)*x if x > 1 else 1 def cumsum(x): return cumsum(x-1) + x if x > 1 else 1 def loopBST(root): # ... your code
And you want to apply the decorator to count how many recursions ran. Here, the code is performed inside some_function() to show that you don't have to keep the count variable(s) in the global scope. (See comments) (Also, the recursive functions are still in global space)
# Main file: from functools import wraps, partial from collections import defaultdict # import the two recursion functions from some_module.py from some_module import cumsum, factorial, loopBST def some_function(): global factorial, cumsum, loopBST def counting_recursion(fn, counter): @wraps(fn) def wrapper(*args, **kwargs): counter[fn.__name__] += 1 return fn(*args, **kwargs) return wrapper counters = defaultdict(int) my_deco = partial(counting_recursion, counter=counters) factorial = my_deco(factorial) cumsum = my_deco(cumsum) loopBST = my_deco(loopBST) print(factorial(3)) # 6 print(cumsum(5)) # 15 factorial_count = counters[factorial.__name__] cumsum_count = counters[cumsum.__name__] loopBST_count = counters[loopBST.__name__] # Equals 0: were not called in my example print('The "{}" function ran {} times'.format(factorial.__name__, factorial_count)) print('The "{}" function ran {} times'.format(cumsum.__name__, cumsum_count)) # The "factorial" function ran 3 times # The "cumsum" function ran 5 times
A few modifications/variations:
Instead of using my_deco = partial(counting_recursion, counter=counters), the recursive functions could be decorated directly:
cumsum = counting_recursion(cumsum, counter=counters) factorial = counting_recursion(factorial, counter=counters) loopBST = counting_recursion(loopBST, counter=counters)
Instead of using fn.__name__ to identify the called function, the counting_recursion-function could be rewritten as:
def counting_recursion(fn, counter): @wraps(fn) def wrapper(*args, **kwargs): counter[wrapper] += 1 return fn(*args, **kwargs) return wrapper
Then, to read the number from the counters dictionary:
factorial_count = counters[factorial] cumsum_count = counters[cumsum] loopBST_count = counters[loopBST]
If you want to read more about wrapping functions, check out https://stackoverflow.com/a/25827070/1144382 and the docs on wraps
OLD EXAMPLE:
from functools import wraps, partial class Counter: def __init__(self, start_count=0): self._counter = start_count def __repr__(self): return str(self._counter) def count(self): self._counter += 1 counter = Counter() def counting_recursion(fn, counter): @wraps(fn) def wrapper(*args, **kwargs): counter.count() return fn(*args, **kwargs) return wrapper my_deco = partial(counting_recursion, counter=counter) @my_deco def factorial(x): return factorial(x-1)*x if x > 1 else 1 print(factorial(3)) # 6 print('The {} function ran {} times'.format(factorial.__name__, counter)) # The factorial function ran 3 times
To implement this in your case, just make some counter and decorate your function:
@my_deco def loopBST(root): # ... print(counter._counter) # prints number of counts
Of course, you don't have to make a Counter-class to call counter.count() on, you could also have a dictionary of counters, e.g. counts[loopBST] += 1 or just an array with a single element count_list[0] += 1. (see the code example at top of this answer) (The entire point is to "hide" the value in a reference that is not rewritten when the variable is reassigned, which is why just an integer count count += 1 won't work.)
