estáticas - ¿Miembro estático de una función en Python?

variables estaticas python

Question

Posible duplicado:
Variables de clase estáticas en Python
¿Cuál es el equivalente de Python de las variables estáticas dentro de una función?

¿Cómo puedo usar campos estáticos en Python?

por ejemplo, quiero contar cuántas veces se ha llamado a la función. ¿Cómo puedo hacer esto?

Answer 1

Aquí hay un decorador que agrega contar a una función.

import functools

def count_calls(func):
    @functools.wraps(func)
    def decor(*args, **kwargs):
        decor.count += 1
        return func(*args, **kwargs)
    decor.count = 0
    return decor

Uso:

>>> @count_calls
... def foo():
...     pass
...
>>> foo.count
0
>>> foo()
>>> foo.count
1

Answer 2

Aquí hay un ejemplo que cuenta el número de llamadas de todos los objetos de la misma clase:

class Swallow():
    i = 0 # will be used for counting calls of fly()
    def fly(self):
        Swallow.i += 1

Y esta es la prueba:

>>> a = Swallow()
>>> b = Swallow()
>>> a.fly()
>>> a.i
1
>>> Swallow.i
1
>>> b.fly()
>>> b.i
2
>>> Swallow.i
2

para que puedas leerlo dando el nombre del objeto o el nombre de la clase.

Answer 3

Aquí hay una forma simplista de hacerlo:

def func():
    if not hasattr(func, ''counter''):
        func.counter = 0
    func.counter += 1
    counter = 0 # Not the same as `func.counter`
    print(func.counter)

O si no te gusta el si se ejecuta en cada llamada, puedes hacer:

def func():
    func.counter += 1
    print(func.counter)
func.counter = 0

Answer 4

Si desea contar cuántas veces se ha llamado a un método, sin importar a qué instancia lo haya llamado, podría usar un miembro de la clase como este:

class Foo(object):
    calls=0            # <--- call is a class member
    def baz(self):
        Foo.calls+=1

foo=Foo()
bar=Foo()
for i in range(100): 
    foo.baz()
    bar.baz()
print(''Foo.baz was called {n} times''.format(n=foo.calls))
# Foo.baz was called 200 times

Cuando definas calls esta manera:

class Foo(object):
    calls=0            

Python coloca el par clave-valor (''calls'', 0) en Foo.__dict__ .

Se puede acceder con Foo.calls . Las instancias de Foo , como foo=Foo() , también pueden acceder con foo.calls .

Para asignar nuevos valores a Foo.calls debes usar Foo.calls = ... Las instancias no pueden usar foo.calls = ... porque eso hace que Python coloque un par nuevo y diferente de clave-valor en foo.__dict__ , donde se guardan los miembros de la instancia.