¿Hay alguna manera de rastrear el número de veces que se llama una función?

Así que estoy tratando de hacer una función que haga un seguimiento de cuántas veces se llama un método. por ejemplo:

a = [1,2,3,4] a.pop() 

Quiero saber cuántas veces se llamó un.pop () hasta el momento, así que para este ejemplo, obtendría 1. ¿Hay alguna manera de hacerlo?

Esto no funciona para funciones integradas, pero un enfoque interesante sería:

 def myfunction(): myfunction.counter += 1 myfunction.counter = 0 

Le está dando a la función un atributo, por lo que cada llamada de ese atributo se actualiza. No se necesitan variables globales

Los built-in son de solo lectura. No pueden ser modificados.

Podría usar un decorador que rastrea cuántas veces se llama a la función. Como la list está integrada, no puede decorar o reemplazar su método pop , por lo que tendría que usar su propia clase de lista, por ejemplo.

 def counted(f): def wrapped(*args, **kwargs): wrapped.calls += 1 return f(*args, **kwargs) wrapped.calls = 0 return wrapped class MyList(list): @counted def pop(self, *args, **kwargs): return list.pop(self, *args, **kwargs) x = MyList([1, 2, 3, 4, 5]) for i in range(3): x.pop() print x.pop.calls # prints 3 

Utilicé el siguiente truco para rastrear cuántas veces se llamó la función

 def myfun(s,i=[0]): print(s) i[0]+=1 # mutable variable get evaluated ONCE return i[0] >>> myfun('aaa') aaa 1 >>> myfun('bbb') bbb 2 
 counter = 0 def pop(): counter += 1 print counter #other function code a = [1,2,3,4] a.pop() 

esto debería resolver su problema y debería poder ver lo que se cuenta. + cada vez que llame a la función, el contador se incrementará y se imprimirá con cada pasada de la función.

SI ESTÁ CONSTRUIDO:

  counter = 0 def newfunction(): a = [1,2,3,4] a.pop() counter += 1 print counter 

La lógica en esto es que llamará a su nueva función a la función preprogtwigda, luego saldrá de la función incorporada y luego marcará el contador como incrementado. la salida de tu contador.

Para las patadas, escribí una respuesta usando un decorador:

 class counter: #wraps a function, to keep a running count of how many #times it's been called def __init__(self, func): self.func = func self.count = count def __call__(self, *args, **kwargs): self.count += 1 return self.func(*args, **kwargs) 

Para usarlo, simplemente decora una función. A continuación, puede verificar cuántas veces se ha ejecutado esa función examinando el atributo “recuento”. Hacerlo de esta manera es bueno porque:

1.) Sin variables globales. El conteo está asociado directamente con la función.

2.) Puede envolver funciones incorporadas fácilmente, llamando a la clase directamente:

 sum_wrapped = counter(sum) sum_wrapped([1, 2 ,3, 4]) #outputs 10 print sum_wrapped.count #outputs 1 

Por supuesto, esto podría mejorarse utilizando el módulo Decorators para mantener las cadenas de documentos y otras cosas buenas intactas. Además, para obtener una descripción general excelente de lo que son los decoradores y cómo funcionan, consulte esta respuesta de stackoverflow .

Un enfoque es crear un proxy de la instancia para la que desea contar el acceso de atributo:

 from collections import Counter class CountingProxy(): def __init__(self, instance): self._instance = instance self.count = Counter() def __getattr__(self, key): if hasattr(self._instance, key): self.count[key] += 1 return getattr(self._instance, key) >>> l = [1,2,3,4,5] >>> cl = CountingProxy(l) >>> cl.pop() 5 >>> cl.append(10) >>> cl.index(3) 2 >>> cl.reverse() >>> cl.reverse() >>> cl.count Counter({'reverse': 2, 'pop': 1, 'append': 1, 'index': 1}) 

Una forma simple de hacerlo es incrementar una variable global cada vez que llame a la función.

 counter = 0 a = [1,2,3,4] a.pop() counter += 1 

Simplemente defina una variable global e increméntela dentro de la función.

 a = 0 def some_function(): global a a+=1 <..Your code.> 

Esto se incrementará automáticamente a medida que se utilice la función y podrá acceder a ella globalmente.