Quel est l'équivalent Python des variables statiques à l'intérieur d'une fonction?

Quel est l'équivalent Python idiomatique de ce code C / C ++?

void foo()
{
    static int counter = 0;
    counter++;
    printf("counter is %d\n", counter);
}

en particulier, comment implémenter le membre statique au niveau de la fonction, par opposition au niveau de la classe? Et le fait de placer la fonction dans une classe change-t-il quelque chose?

Un peu inversé, mais cela devrait fonctionner:

def foo():
    foo.counter += 1
    print "Counter is %d" % foo.counter
foo.counter = 0

Si vous voulez que le code d'initialisation du compteur soit en haut plutôt qu'en bas, vous pouvez créer un décorateur:

def static_vars(**kwargs):
    def decorate(func):
        for k in kwargs:
            setattr(func, k, kwargs[k])
        return func
    return decorate

Utilisez ensuite le code comme ceci:

@static_vars(counter=0)
def foo():
    foo.counter += 1
    print "Counter is %d" % foo.counter

foo.Malheureusement, il vous faudra encore utiliser le préfixe.

^{(Crédit: @ony )}

Vous pouvez ajouter des attributs à une fonction et l'utiliser comme variable statique.

def myfunc():
  myfunc.counter += 1
  print myfunc.counter

# attribute must be initialized
myfunc.counter = 0

Alternativement, si vous ne souhaitez pas configurer la variable en dehors de la fonction, vous pouvez utiliser hasattr()pour éviter une AttributeErrorexception:

def myfunc():
  if not hasattr(myfunc, "counter"):
     myfunc.counter = 0  # it doesn't exist yet, so initialize it
  myfunc.counter += 1

Quoi qu'il en soit, les variables statiques sont plutôt rares, et vous devriez trouver un meilleur endroit pour cette variable, très probablement à l'intérieur d'une classe.

On pourrait également envisager:

def foo():
    try:
        foo.counter += 1
    except AttributeError:
        foo.counter = 1

Raisonnement:

• beaucoup pythonique ("demander pardon et non permission")
• utiliser l'exception (levée une seule fois) au lieu de la ifbranche (pensez à l' exception StopIteration )

D'autres réponses ont démontré la façon dont vous devez procéder. Voici un moyen que vous ne devriez pas:

>>> def foo(counter=[0]):
...   counter[0] += 1
...   print("Counter is %i." % counter[0]);
... 
>>> foo()
Counter is 1.
>>> foo()
Counter is 2.
>>> 

Les valeurs par défaut ne sont initialisées que lors de la première évaluation de la fonction, et non à chaque exécution, vous pouvez donc utiliser une liste ou tout autre objet modifiable pour stocker des valeurs statiques.

Beaucoup de gens ont déjà suggéré de tester 'hasattr', mais il existe une réponse plus simple:

def func():
    func.counter = getattr(func, 'counter', 0) + 1

Aucun essai / sauf, aucun test hasattr, juste getattr avec un défaut.

Voici une version entièrement encapsulée qui ne nécessite pas d'appel d'initialisation externe:

def fn():
    fn.counter=vars(fn).setdefault('counter',-1)
    fn.counter+=1
    print (fn.counter)

En Python, les fonctions sont des objets et nous pouvons simplement leur ajouter, ou patcher des singes, des variables membres via l'attribut spécial __dict__. La fonction intégrée vars()renvoie l'attribut spécial __dict__.

EDIT: Notez, contrairement à la try:except AttributeErrorréponse alternative , avec cette approche, la variable sera toujours prête pour la logique du code après l'initialisation. Je pense que l' try:except AttributeErroralternative aux suivantes sera moins sèche et / ou aura un flux maladroit:

def Fibonacci(n):
   if n<2: return n
   Fibonacci.memo=vars(Fibonacci).setdefault('memo',{}) # use static variable to hold a results cache
   return Fibonacci.memo.setdefault(n,Fibonacci(n-1)+Fibonacci(n-2)) # lookup result in cache, if not available then calculate and store it

EDIT2: Je ne recommande l'approche ci-dessus que lorsque la fonction sera appelée à partir de plusieurs emplacements. Si à la place la fonction n'est appelée qu'à un seul endroit, il vaut mieux utiliser nonlocal:

def TheOnlyPlaceStaticFunctionIsCalled():
    memo={}
    def Fibonacci(n):
       nonlocal memo  # required in Python3. Python2 can see memo
       if n<2: return n
       return memo.setdefault(n,Fibonacci(n-1)+Fibonacci(n-2))
    ...
    print (Fibonacci(200))
    ...

Python n'a pas de variables statiques mais vous pouvez le simuler en définissant un objet de classe appelable puis en l'utilisant comme fonction. Voir également cette réponse .

class Foo(object):
  # Class variable, shared by all instances of this class
  counter = 0

  def __call__(self):
    Foo.counter += 1
    print Foo.counter

# Create an object instance of class "Foo," called "foo"
foo = Foo()

# Make calls to the "__call__" method, via the object's name itself
foo() #prints 1
foo() #prints 2
foo() #prints 3

Notez que __call__rend une instance d'une classe (objet) appelable par son propre nom. C'est pourquoi appeler foo()ci-dessus appelle la __call__méthode de la classe . De la documentation :

Les instances de classes arbitraires peuvent être rendues appelables en définissant une __call__()méthode dans leur classe.

Utilisez une fonction de générateur pour générer un itérateur.

def foo_gen():
    n = 0
    while True:
        n+=1
        yield n

Ensuite, utilisez-le comme

foo = foo_gen().next
for i in range(0,10):
    print foo()

Si vous souhaitez une limite supérieure:

def foo_gen(limit=100000):
    n = 0
    while n < limit:
       n+=1
       yield n

Si l'itérateur se termine (comme dans l'exemple ci-dessus), vous pouvez également le boucler directement, comme

for i in foo_gen(20):
    print i

Bien sûr, dans ces cas simples, il vaut mieux utiliser xrange :)

Voici la documentation sur la déclaration de rendement .

D'autres solutions attachent un attribut de compteur à la fonction, généralement avec une logique alambiquée pour gérer l'initialisation. Ceci est inapproprié pour le nouveau code.

En Python 3, la bonne façon est d'utiliser une nonlocalinstruction:

counter = 0
def foo():
    nonlocal counter
    counter += 1
    print(f'counter is {counter}')

Voir PEP 3104 pour la spécification de l' nonlocalinstruction.

Si le compteur est destiné à être privé du module, il doit être nommé à la _counterplace.

L'utilisation d'un attribut d'une fonction en tant que variable statique présente certains inconvénients potentiels:

• Chaque fois que vous souhaitez accéder à la variable, vous devez écrire le nom complet de la fonction.
• Le code extérieur peut accéder facilement à la variable et jouer avec la valeur.

Un python idiomatique pour le deuxième problème serait probablement de nommer la variable avec un trait de soulignement de tête pour signaler qu'elle n'est pas destinée à être accédée, tout en la gardant accessible après coup.

Une alternative serait un modèle utilisant des fermetures lexicales, qui sont prises en charge avec le nonlocalmot - clé en python 3.

def make_counter():
    i = 0
    def counter():
        nonlocal i
        i = i + 1
        return i
    return counter
counter = make_counter()

Malheureusement, je ne connais aucun moyen d'encapsuler cette solution dans un décorateur.

def staticvariables(**variables):
    def decorate(function):
        for variable in variables:
            setattr(function, variable, variables[variable])
        return function
    return decorate

@staticvariables(counter=0, bar=1)
def foo():
    print(foo.counter)
    print(foo.bar)

Tout comme le code de vincent ci-dessus, il serait utilisé comme décorateur de fonction et les variables statiques doivent être accédées avec le nom de la fonction comme préfixe. L'avantage de ce code (bien que tout le monde puisse être assez intelligent pour le comprendre) est que vous pouvez avoir plusieurs variables statiques et les initialiser de manière plus conventionnelle.

Un peu plus lisible, mais plus verbeux (Zen of Python: explicite vaut mieux qu'implicite):

>>> def func(_static={'counter': 0}):
...     _static['counter'] += 1
...     print _static['counter']
...
>>> func()
1
>>> func()
2
>>>

Voir ici pour une explication de comment cela fonctionne.

_counter = 0
def foo ():
   _counter global
   _counter + = 1
   imprimer «le compteur est», _counter

Python utilise habituellement des traits de soulignement pour indiquer des variables privées. La seule raison en C pour déclarer la variable statique à l'intérieur de la fonction est de la cacher en dehors de la fonction, ce qui n'est pas vraiment du Python idiomatique.

Après avoir essayé plusieurs approches, je finis par utiliser une version améliorée de la réponse de @ warvariuc:

import types

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

La manière idiomatique est d'utiliser une classe , qui peut avoir des attributs. Si vous avez besoin que les instances ne soient pas séparées, utilisez un singleton.

Il existe un certain nombre de façons de simuler ou de fusionner des variables "statiques" dans Python (une qui n'est pas mentionnée jusqu'à présent est d'avoir un argument par défaut modifiable), mais ce n'est pas la manière idiomatique Pythonique de le faire. Utilisez simplement une classe.

Ou éventuellement un générateur, si votre modèle d'utilisation convient.

Invité par cette question , puis-je présenter une autre alternative qui pourrait être un peu plus agréable à utiliser et qui se ressemblera pour les méthodes et les fonctions:

@static_var2('seed',0)
def funccounter(statics, add=1):
    statics.seed += add
    return statics.seed

print funccounter()       #1
print funccounter(add=2)  #3
print funccounter()       #4

class ACircle(object):
    @static_var2('seed',0)
    def counter(statics, self, add=1):
        statics.seed += add
        return statics.seed

c = ACircle()
print c.counter()      #1
print c.counter(add=2) #3
print c.counter()      #4
d = ACircle()
print d.counter()      #5
print d.counter(add=2) #7
print d.counter()      #8    

Si vous aimez l'utilisation, voici l'implémentation:

class StaticMan(object):
    def __init__(self):
        self.__dict__['_d'] = {}

    def __getattr__(self, name):
        return self.__dict__['_d'][name]
    def __getitem__(self, name):
        return self.__dict__['_d'][name]
    def __setattr__(self, name, val):
        self.__dict__['_d'][name] = val
    def __setitem__(self, name, val):
        self.__dict__['_d'][name] = val

def static_var2(name, val):
    def decorator(original):
        if not hasattr(original, ':staticman'):    
            def wrapped(*args, **kwargs):
                return original(getattr(wrapped, ':staticman'), *args, **kwargs)
            setattr(wrapped, ':staticman', StaticMan())
            f = wrapped
        else:
            f = original #already wrapped

        getattr(f, ':staticman')[name] = val
        return f
    return decorator

Une autre torsion (non recommandée!) Sur l'objet appelable comme https://stackoverflow.com/a/279598/916373 , si cela ne vous dérange pas d'utiliser une signature d'appel géniale, serait de faire

class foo(object):
    counter = 0;
    @staticmethod
    def __call__():
        foo.counter += 1
        print "counter is %i" % foo.counter

>>> foo()()
counter is 1
>>> foo()()
counter is 2

Au lieu de créer une fonction ayant une variable locale statique, vous pouvez toujours créer ce qu'on appelle un "objet fonction" et lui donner une variable membre standard (non statique).

Puisque vous avez donné un exemple écrit en C ++, je vais d'abord expliquer ce qu'est un "objet fonction" en C ++. Un "objet fonction" est simplement n'importe quelle classe avec une surcharge operator(). Les instances de la classe se comporteront comme des fonctions. Par exemple, vous pouvez écrire int x = square(5);même s'il squares'agit d'un objet (surchargé operator()) et non techniquement pas une "fonction". Vous pouvez donner à un objet-fonction n'importe laquelle des fonctionnalités que vous pourriez donner à un objet de classe.

# C++ function object
class Foo_class {
    private:
        int counter;     
    public:
        Foo_class() {
             counter = 0;
        }
        void operator() () {  
            counter++;
            printf("counter is %d\n", counter);
        }     
   };
   Foo_class foo;

En Python, nous pouvons également surcharger operator()sauf que la méthode est nommée à la place __call__:

Voici une définition de classe:

class Foo_class:
    def __init__(self): # __init__ is similair to a C++ class constructor
        self.counter = 0
        # self.counter is like a static member
        # variable of a function named "foo"
    def __call__(self): # overload operator()
        self.counter += 1
        print("counter is %d" % self.counter);
foo = Foo_class() # call the constructor

Voici un exemple de la classe utilisée:

from foo import foo

for i in range(0, 5):
    foo() # function call

La sortie imprimée sur la console est:

counter is 1
counter is 2
counter is 3
counter is 4
counter is 5

Si vous souhaitez que votre fonction accepte des arguments d'entrée, vous pouvez également les ajouter à __call__:

# FILE: foo.py - - - - - - - - - - - - - - - - - - - - - - - - -

class Foo_class:
    def __init__(self):
        self.counter = 0
    def __call__(self, x, y, z): # overload operator()
        self.counter += 1
        print("counter is %d" % self.counter);
        print("x, y, z, are %d, %d, %d" % (x, y, z));
foo = Foo_class() # call the constructor

# FILE: main.py - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

from foo import foo

for i in range(0, 5):
    foo(7, 8, 9) # function call

# Console Output - - - - - - - - - - - - - - - - - - - - - - - - - - 

counter is 1
x, y, z, are 7, 8, 9
counter is 2
x, y, z, are 7, 8, 9
counter is 3
x, y, z, are 7, 8, 9
counter is 4
x, y, z, are 7, 8, 9
counter is 5
x, y, z, are 7, 8, 9

Soulution n + = 1

def foo():
  foo.__dict__.setdefault('count', 0)
  foo.count += 1
  return foo.count

Une déclaration globale fournit cette fonctionnalité. Dans l'exemple ci-dessous (python 3.5 ou supérieur pour utiliser le "f"), la variable compteur est définie en dehors de la fonction. Le définir comme global dans la fonction signifie que la version "globale" en dehors de la fonction doit être mise à la disposition de la fonction. Ainsi, chaque fois que la fonction s'exécute, elle modifie la valeur en dehors de la fonction, la préservant au-delà de la fonction.

counter = 0

def foo():
    global counter
    counter += 1
    print("counter is {}".format(counter))

foo() #output: "counter is 1"
foo() #output: "counter is 2"
foo() #output: "counter is 3"

Une variable statique à l'intérieur d'une méthode Python

class Count:
    def foo(self):
        try: 
            self.foo.__func__.counter += 1
        except AttributeError: 
            self.foo.__func__.counter = 1

        print self.foo.__func__.counter

m = Count()
m.foo()       # 1
m.foo()       # 2
m.foo()       # 3

Personnellement, je préfère ce qui suit aux décorateurs. À chacun son bonheur.

def staticize(name, factory):
    """Makes a pseudo-static variable in calling function.

    If name `name` exists in calling function, return it. 
    Otherwise, saves return value of `factory()` in 
    name `name` of calling function and return it.

    :param name: name to use to store static object 
    in calling function
    :type name: String
    :param factory: used to initialize name `name` 
    in calling function
    :type factory: function
    :rtype: `type(factory())`

    >>> def steveholt(z):
    ...     a = staticize('a', list)
    ...     a.append(z)
    >>> steveholt.a
    Traceback (most recent call last):
    ...
    AttributeError: 'function' object has no attribute 'a'
    >>> steveholt(1)
    >>> steveholt.a
    [1]
    >>> steveholt('a')
    >>> steveholt.a
    [1, 'a']
    >>> steveholt.a = []
    >>> steveholt.a
    []
    >>> steveholt('zzz')
    >>> steveholt.a
    ['zzz']

    """
    from inspect import stack
    # get scope enclosing calling function
    calling_fn_scope = stack()[2][0]
    # get calling function
    calling_fn_name = stack()[1][3]
    calling_fn = calling_fn_scope.f_locals[calling_fn_name]
    if not hasattr(calling_fn, name):
        setattr(calling_fn, name, factory())
    return getattr(calling_fn, name)

Cette réponse s'appuie sur la réponse de @claudiu.

J'ai trouvé que mon code devenait moins clair quand je devais toujours ajouter le nom de la fonction, chaque fois que j'avais l'intention d'accéder à une variable statique.

À savoir, dans mon code de fonction, je préférerais écrire:

print(statics.foo)

au lieu de

print(my_function_name.foo)

Donc, ma solution est de:

1. ajouter un staticsattribut à la fonction
2. dans l'étendue de la fonction, ajoutez une variable locale staticscomme alias àmy_function.statics

from bunch import *

def static_vars(**kwargs):
    def decorate(func):
        statics = Bunch(**kwargs)
        setattr(func, "statics", statics)
        return func
    return decorate

@static_vars(name = "Martin")
def my_function():
    statics = my_function.statics
    print("Hello, {0}".format(statics.name))

Remarque

Ma méthode utilise une classe nommée Bunch, qui est un dictionnaire qui prend en charge l'accès de style attribut, à la JavaScript (voir l' article d'origine à ce sujet, vers 2000)

Il peut être installé via pip install bunch

Il peut également être écrit à la main comme suit:

class Bunch(dict):
    def __init__(self, **kw):
        dict.__init__(self,kw)
        self.__dict__ = self

S'appuyant sur la réponse de Daniel (ajouts):

class Foo(object): 
    counter = 0  

def __call__(self, inc_value=0):
    Foo.counter += inc_value
    return Foo.counter

foo = Foo()

def use_foo(x,y):
    if(x==5):
        foo(2)
    elif(y==7):
        foo(3)
    if(foo() == 10):
        print("yello")


use_foo(5,1)
use_foo(5,1)
use_foo(1,7)
use_foo(1,7)
use_foo(1,1)

La raison pour laquelle j'ai voulu ajouter cette partie est que les variables statiques sont utilisées non seulement pour incrémenter d'une certaine valeur, mais aussi pour vérifier si la var statique est égale à une certaine valeur, comme exemple réel.

La variable statique est toujours protégée et utilisée uniquement dans le cadre de la fonction use_foo ()

Dans cet exemple, l'appel à foo () fonctionne exactement comme (par rapport à l'équivalent c ++ correspondant):

stat_c +=9; // in c++
foo(9)  #python equiv

if(stat_c==10){ //do something}  // c++

if(foo() == 10):      # python equiv
  #add code here      # python equiv       

Output :
yello
yello

si la classe Foo est définie de manière restrictive comme une classe singleton, ce serait idéal. Cela le rendrait plus pythonique.

Bien sûr, c'est une vieille question, mais je pense que je pourrais fournir une mise à jour.

Il semble que l'argument de la performance soit obsolète. La même suite de tests semble donner des résultats similaires pour siInt_try et isInt_re2. Bien sûr, les résultats varient, mais il s'agit d'une session sur mon ordinateur avec python 3.4.4 sur le noyau 4.3.01 avec Xeon W3550. Je l'ai exécuté plusieurs fois et les résultats semblent similaires. J'ai déplacé l'expression régulière globale en fonction statique, mais la différence de performances est négligeable.

isInt_try: 0.3690
isInt_str: 0.3981
isInt_re: 0.5870
isInt_re2: 0.3632

Avec un problème de performance à l'écart, il semble que try / catch produirait le code le plus futur et le plus à l'épreuve des coins, alors peut-être simplement l'envelopper dans la fonction