Qual è l'equivalente Python delle variabili statiche all'interno di una funzione?

Qual è l'equivalente Python idiomatico di questo codice C / C ++?

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

in particolare, come si implementa il membro statico a livello di funzione, a differenza del livello di classe? E inserendo la funzione in una classe cambia qualcosa?

Un po 'invertito, ma questo dovrebbe funzionare:

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

Se si desidera il codice di inizializzazione del contatore in alto anziché in basso, è possibile creare un decoratore:

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

Quindi utilizzare il codice in questo modo:

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

foo.Sfortunatamente ti richiederà comunque di usare il prefisso.

^{(Credito: @ony )}

È possibile aggiungere attributi a una funzione e usarla come variabile statica.

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

# attribute must be initialized
myfunc.counter = 0

In alternativa, se non si desidera impostare la variabile all'esterno della funzione, è possibile utilizzare hasattr()per evitare AttributeErrorun'eccezione:

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

Le variabili statiche sono comunque piuttosto rare e dovresti trovare un posto migliore per questa variabile, molto probabilmente all'interno di una classe.

Si potrebbe anche considerare:

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

Ragionamento:

• molto pitone ("chiedi perdono, non permesso")
• usa l'eccezione (generata una sola volta) invece del iframo (pensa l' eccezione StopIteration )

Altre risposte hanno dimostrato il modo in cui dovresti farlo. Ecco un modo non dovresti:

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

I valori predefiniti vengono inizializzati solo quando la funzione viene valutata per la prima volta, non ogni volta che viene eseguita, quindi è possibile utilizzare un elenco o qualsiasi altro oggetto mutabile per memorizzare valori statici.

Molte persone hanno già suggerito di provare 'hasattr', ma c'è una risposta più semplice:

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

Nessun tentativo / tranne, nessun test hasattr, solo getattr con un valore predefinito.

Ecco una versione completamente incapsulata che non richiede una chiamata di inizializzazione esterna:

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

In Python, le funzioni sono oggetti e possiamo semplicemente aggiungere, o patch scimmia, variabili membro ad esse tramite l'attributo speciale __dict__. Il built-in vars()restituisce l'attributo speciale__dict__ .

EDIT: Nota, a differenza della try:except AttributeErrorrisposta alternativa , con questo approccio la variabile sarà sempre pronta per la logica del codice dopo l'inizializzazione. Penso che l' try:except AttributeErroralternativa alla seguente sarà meno ASCIUTTA e / o avrà un flusso imbarazzante:

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: raccomando l'approccio sopra solo quando la funzione verrà chiamata da più posizioni. Se invece la funzione viene chiamata solo in un posto, è meglio usare 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 non ha variabili statiche ma puoi falsificarlo definendo un oggetto classe richiamabile e quindi utilizzandolo come funzione. Vedi anche questa risposta .

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

Si noti che __call__rende un'istanza di una classe (oggetto) richiamabile con il proprio nome. Ecco perché chiamare foo()sopra chiama il __call__metodo della classe . Dalla documentazione :

Le istanze di classi arbitrarie possono essere richiamate definendo un __call__()metodo nella loro classe.

Utilizzare una funzione del generatore per generare un iteratore.

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

Quindi usalo come

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

Se vuoi un limite superiore:

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

Se l'iteratore termina (come nell'esempio sopra), puoi anche passare direttamente su di esso, ad esempio

for i in foo_gen(20):
    print i

Naturalmente, in questi semplici casi è meglio usare xrange :)

Ecco la documentazione sulla dichiarazione di rendimento .

Altre soluzioni associano un attributo counter alla funzione, generalmente con logica contorta per gestire l'inizializzazione. Questo non è appropriato per il nuovo codice.

In Python 3, il modo giusto è usare nonlocalun'istruzione:

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

Vedere PEP 3104 per le specifiche nonlocaldell'istruzione.

Se il contatore è destinato a essere privato per il modulo, dovrebbe _counterinvece essere nominato .

L'uso di un attributo di una funzione come variabile statica presenta alcuni potenziali svantaggi:

• Ogni volta che si desidera accedere alla variabile, è necessario scrivere il nome completo della funzione.
• Il codice esterno può accedere facilmente alla variabile e pasticciare con il valore.

Python idiomatico per il secondo problema probabilmente darebbe un nome alla variabile con un carattere di sottolineatura iniziale per segnalare che non si intende accedervi, mantenendolo accessibile dopo il fatto.

Un'alternativa sarebbe un modello che utilizza chiusure lessicali, che sono supportate con la nonlocalparola chiave in python 3.

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

Purtroppo non so come incapsulare questa soluzione in un decoratore.

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)

Proprio come il codice di vincent sopra, questo sarebbe usato come decoratore di funzioni e si dovrebbe accedere alle variabili statiche con il nome della funzione come prefisso. Il vantaggio di questo codice (anche se è vero che chiunque potrebbe essere abbastanza intelligente da capirlo) è che puoi avere più variabili statiche e inizializzarle in un modo più convenzionale.

Un po 'più leggibile, ma più dettagliato (Zen of Python: esplicito è meglio che implicito):

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

Vedi qui per una spiegazione di come funziona.

_counter = 0
def foo ():
   _counter globale
   _counter + = 1
   stampa 'counter is', _counter

Python usa abitualmente caratteri di sottolineatura per indicare variabili private. L'unico motivo in C per dichiarare la variabile statica all'interno della funzione è nasconderla al di fuori della funzione, che in realtà non è Python idiomatica.

Dopo aver provato diversi approcci, finisco per usare una versione migliorata della risposta di @ warvariuc:

import types

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

Il modo idiomatico è usare una classe , che può avere attributi. Se è necessario che le istanze non siano separate, utilizzare un singleton.

Esistono diversi modi in cui è possibile falsificare o confondere variabili "statiche" in Python (una non menzionata finora è avere un argomento predefinito mutabile), ma questo non è il modo idiomatico di Pythonic per farlo. Usa solo una lezione.

O forse un generatore, se il tuo modello di utilizzo si adatta.

Spinto da questa domanda , posso presentare un'altra alternativa che potrebbe essere un po 'più piacevole da usare e che sembrerà la stessa sia per i metodi che per le funzioni:

@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    

Se ti piace l'utilizzo, ecco l'implementazione:

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

Un'altra svolta (non consigliata!) Sull'oggetto richiamabile come https://stackoverflow.com/a/279598/916373 , se non ti dispiace usare una firma di chiamata funky, sarebbe fare

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

Invece di creare una funzione con una variabile locale statica, è sempre possibile creare quello che viene chiamato un "oggetto funzione" e assegnargli una variabile membro standard (non statica).

Dato che hai dato un esempio scritto in C ++, spiegherò innanzitutto che cos'è un "oggetto funzione" in C ++. Un "oggetto funzione" è semplicemente qualsiasi classe con un sovraccarico operator(). Le istanze della classe si comporteranno come funzioni. Ad esempio, puoi scrivere int x = square(5);anche se squareè un oggetto (con sovraccarico operator()) e non tecnicamente non è una "funzione". È possibile assegnare a un oggetto funzione una delle caratteristiche che è possibile assegnare a un oggetto 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;

In Python, possiamo anche sovraccaricare, operator()tranne per il fatto che il metodo è invece chiamato __call__:

Ecco una definizione di 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

Ecco un esempio della classe utilizzata:

from foo import foo

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

L'output stampato sulla console è:

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

Se vuoi che la tua funzione accetti argomenti di input, puoi aggiungerli __call__anche a:

# 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

Una dichiarazione globale fornisce questa funzionalità. Nell'esempio seguente (python 3.5 o versioni successive per utilizzare la "f"), la variabile contatore è definita al di fuori della funzione. Definirlo come globale nella funzione significa che la versione "globale" al di fuori della funzione dovrebbe essere resa disponibile per la funzione. Quindi ogni volta che la funzione viene eseguita, modifica il valore all'esterno della funzione, preservandolo oltre la funzione.

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"

Una variabile statica all'interno di un metodo 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

Personalmente preferisco quanto segue ai decoratori. A ognuno il suo.

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)

Questa risposta si basa sulla risposta di @claudiu.

Ho scoperto che il mio codice stava diventando meno chiaro quando dovevo sempre anteporre il nome della funzione, ogni volta che ho intenzione di accedere a una variabile statica.

Vale a dire, nel mio codice funzione preferirei scrivere:

print(statics.foo)

invece di

print(my_function_name.foo)

Quindi, la mia soluzione è:

1. aggiungi un staticsattributo alla funzione
2. nell'ambito della funzione, aggiungere una variabile locale staticscome alias amy_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))

osservazione

Il mio metodo utilizza una classe denominata Bunch, che è un dizionario che supporta l'accesso in stile attributo, come JavaScript (vedere l' articolo originale al riguardo, intorno al 2000)

Può essere installato tramite pip install bunch

Può anche essere scritto a mano in questo modo:

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

Sulla base della risposta di Daniel (aggiunte):

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)

Il motivo per cui volevo aggiungere questa parte è che le variabili statiche vengono utilizzate non solo per incrementare di un valore, ma anche per verificare se la var statica è uguale a un valore, come un esempio di vita reale.

La variabile statica è ancora protetta e utilizzata solo nell'ambito della funzione use_foo ()

In questo esempio, call to foo () funziona esattamente come (rispetto al corrispondente equivalente c ++):

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

se la classe Foo è definita restrittivamente come una classe singleton, sarebbe l'ideale. Ciò renderebbe più pitonico.

Certo, questa è una vecchia domanda, ma penso che potrei fornire qualche aggiornamento.

Sembra che l'argomento delle prestazioni sia obsoleto. La stessa suite di test sembra fornire risultati simili per siInt_try e isInt_re2. Naturalmente i risultati variano, ma questa è una sessione sul mio computer con Python 3.4.4 sul kernel 4.3.01 con Xeon W3550. L'ho eseguito più volte e i risultati sembrano essere simili. Ho spostato il regex globale in funzione statica, ma la differenza di prestazioni è trascurabile.

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

Con il problema delle prestazioni fuori mano, sembra che try / catch produca il codice più a prova di futuro e maiuscolo, quindi forse basta avvolgerlo in funzione