Perché Python non ha variabili statiche?

Question

C'è un questions asking how to simulate static variables in python.

Inoltre, sul Web si possono trovare molte soluzioni diverse per creare variabili statiche. (Anche se non ne ho visto uno che mi piace ancora.)

Perché Python non supporta variabili statiche nei metodi? È considerato unpitonico o ha qualcosa a che fare con la sintassi di Python?

Edit:

ho chiesto specificamente del perché della decisione di progettazione e non ho fornito alcun esempio di codice perché volevo evitare di spiegazione per simulare variabili statiche.

Answer 1

L'idea alla base di questa omissione è che le variabili statiche sono utili solo in due situazioni: quando si dovrebbe realmente usare una classe e quando si dovrebbe usare un generatore.

Se si desidera allegare informazioni di stato a una funzione, ciò di cui si ha bisogno è una classe. Una classe banalmente semplice, forse, ma una classe comunque:

def foo(bar): 
    static my_bar # doesn't work 

    if not my_bar: 
     my_bar = bar 

    do_stuff(my_bar) 

foo(bar) 
foo() 

# -- becomes -> 

class Foo(object): 
    def __init__(self, bar): 
     self.bar = bar 

    def __call__(self): 
     do_stuff(self.bar) 

foo = Foo(bar) 
foo() 
foo() 

Se si desidera il comportamento del vostro funzione per cambiare ogni volta che si chiama, quello che ti serve è un generatore:

def foo(bar): 
    static my_bar # doesn't work 

    if not my_bar: 
     my_bar = bar 

    my_bar = my_bar * 3 % 5 

    return my_bar 

foo(bar) 
foo() 

# -- becomes -> 

def foogen(bar): 
    my_bar = bar 

    while True: 
     my_bar = my_bar * 3 % 5 
     yield my_bar 

foo = foogen(bar) 
foo.next() 
foo.next() 

Naturalmente, statica le variabili sono utili per script veloci e sporchi in cui non si desidera gestire la seccatura di grandi strutture per piccole attività. Ma c'è, non si ha realmente bisogno di qualcosa di più di global - se può sembrare un ma kludgy, ma va bene per i piccoli, una tantum script:

def foo(): 
    global bar 
    do_stuff(bar) 

foo() 
foo() 

Answer 2

Penso che la maggior parte degli usi delle variabili statiche locali sia di simulare i generatori, cioè di avere una funzione che esegue l'iterazione di un processo, restituisce il risultato, ma mantiene lo stato per la successiva chiamata. Python lo gestisce in modo molto elegante usando il comando yield, quindi sembra che non ci sia così tanto bisogno di variabili statiche.

Answer 3

È una scelta di design.

Sto assumendo Guido pensa che tu non hai bisogno di loro molto spesso, e non avete mai realmente bisogno di loro: si può sempre e solo utilizzare una variabile globale e dire a tutti di mantenere la loro zampe grassa offa' la variabile; -)

Answer 4

La risposta è più o meno lo stesso motivo per cui nessuno usa statica metodi (anche se esistono). Hai uno spazio dei nomi a livello di modulo che serve allo stesso scopo di una classe.

Answer 5

Per gli scopi di memorizzazione nella cache o memoization, i decoratori possono essere utilizzati come soluzione elegante e generale.

Answer 6

Un'alternativa a una classe è un attributo funzione:

def foo(arg): 
    if not hasattr(foo, 'cache'): 
     foo.cache = get_data_dict() 
    return foo.cache[arg] 

Mentre una classe è probabilmente più pulito, questa tecnica può essere utile e più bello è, a mio parere, quindi a livello globale.

Answer 7

Un mal consigliato alternativa:

È inoltre possibile utilizzare gli effetti collaterali della valutazione momento definizione di default funzione:

def func(initial=0, my_static=[]) 
    if not my_static: 
    my_static.append(initial) 

    my_static[0] += 1 
    return my_static[0] 

print func(0), func(0), func(0) 

sua davvero brutto e facilmente sovvertito, ma funziona. Usare global sarebbe più pulito di questo, imo.

Answer 8

da uno dei vostri commenti: "Mi piacerebbe usarli per memorizzare nella cache le cose caricati da disco Penso che ingombra l'istanza di meno, se potessi assegnare alla funzione"

utilizzare una classe di caching quindi, come un attributo di classe o istanza per l'altra classe. In questo modo, puoi utilizzare l'intero set di classi di funzioni senza ingombrare altre cose. Inoltre, si ottiene uno strumento riutilizzabile.

Questo mostra che su SO si paga sempre per enunciare il proprio problema invece di chiedere una soluzione specifica di basso livello (ad esempio per una caratteristica della lingua mancante). In questo modo, invece di infiniti dibattiti sulla simulazione di "statico" (una caratteristica deprecata da un linguaggio antico, secondo me) qualcuno avrebbe potuto dare una buona risposta al problema prima.

Answer 9

In Python 3, vorrei usare una chiusura:

def makefoo(): 
    x = 0 
    def foo(): 
     nonlocal x 
     x += 1 
     return x 
    return foo 

foo = makefoo() 

print(foo()) 
print(foo())