parola chiave non locale in Python 2.x

Sto cercando di implementare una chiusura in Python 2.6 e ho bisogno di accedere a una variabile non locale ma sembra che questa parola chiave non sia disponibile in python 2.x. Come si accede alle variabili non locali nelle chiusure in queste versioni di python?

Le funzioni interne possono leggere variabili non locali in 2.x, ma non riassociarle . Questo è fastidioso, ma puoi aggirarlo. Basta creare un dizionario e memorizzare i dati come elementi al suo interno. Funzioni interne non sono vietate dalla mutando gli oggetti che le variabili non locali riferiscono.

Per utilizzare l'esempio di Wikipedia:

def outer():
    d = {'y' : 0}
    def inner():
        d['y'] += 1
        return d['y']
    return inner

f = outer()
print(f(), f(), f()) #prints 1 2 3

La seguente soluzione si ispira alla risposta di Elias Zamaria , ma contrariamente a quella risposta gestisce correttamente più chiamate della funzione esterna. La "variabile"inner.y è locale alla chiamata corrente di outer. Solo che non è una variabile, dato che è proibito, ma un attributo di oggetto (l'oggetto è la funzione innerstessa). Questo è molto brutto (nota che l'attributo può essere creato solo dopo che la innerfunzione è stata definita) ma sembra efficace.

def outer():
    def inner():
        inner.y += 1
        return inner.y
    inner.y = 0
    return inner

f = outer()
g = outer()
print(f(), f(), g(), f(), g()) #prints (1, 2, 1, 3, 2)

Piuttosto che un dizionario, c'è meno confusione in una classe non locale . La modifica di @ ChrisB esempio :

def outer():
    class context:
        y = 0
    def inner():
        context.y += 1
        return context.y
    return inner

Poi

f = outer()
assert f() == 1
assert f() == 2
assert f() == 3
assert f() == 4

Ogni chiamata outer () crea una nuova e distinta classe chiamata context (non semplicemente una nuova istanza). Quindi evita che @ Nathaniel faccia attenzione al contesto condiviso.

g = outer()
assert g() == 1
assert g() == 2

assert f() == 5

Penso che la chiave qui sia cosa intendi per "accesso". Non dovrebbero esserci problemi con la lettura di una variabile al di fuori dell'ambito di chiusura, ad es.

x = 3
def outer():
    def inner():
        print x
    inner()
outer()

dovrebbe funzionare come previsto (stampa 3). Tuttavia, l'override del valore di x non funziona, ad es.

x = 3
def outer():
    def inner():
        x = 5
    inner()
outer()
print x

stamperà ancora 3. Dalla mia comprensione di PEP-3104 questo è ciò che la parola chiave non locale intende coprire. Come accennato nel PEP, puoi usare una classe per ottenere la stessa cosa (un po 'disordinato):

class Namespace(object): pass
ns = Namespace()
ns.x = 3
def outer():
    def inner():
        ns.x = 5
    inner()
outer()
print ns.x

C'è un altro modo per implementare variabili non locali in Python 2, nel caso in cui una qualsiasi delle risposte qui non sia desiderabile per qualsiasi motivo:

def outer():
    outer.y = 0
    def inner():
        outer.y += 1
        return outer.y
    return inner

f = outer()
print(f(), f(), f()) #prints 1 2 3

È ridondante usare il nome della funzione nell'istruzione di assegnazione della variabile, ma mi sembra più semplice e pulito che mettere la variabile in un dizionario. Il valore viene ricordato da una chiamata all'altra, proprio come nella risposta di Chris B.

Ecco qualcosa ispirato da un suggerimento di Alois Mahdal in un commento riguardante un'altra risposta :

class Nonlocal(object):
    """ Helper to implement nonlocal names in Python 2.x """
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)


def outer():
    nl = Nonlocal(y=0)
    def inner():
        nl.y += 1
        return nl.y
    return inner

f = outer()
print(f(), f(), f()) # -> (1 2 3)

Aggiornare

Dopo aver ripensato a questo di recente, sono rimasto colpito da quanto fosse simile a un decoratore - quando mi sono reso conto che implementarlo come se fosse uno lo avrebbe reso più generico e utile (anche se così facendo degrada in una certa misura la sua leggibilità).

# Implemented as a decorator.

class Nonlocal(object):
    """ Decorator class to help implement nonlocal names in Python 2.x """
    def __init__(self, **kwargs):
        self._vars = kwargs

    def __call__(self, func):
        for k, v in self._vars.items():
            setattr(func, k, v)
        return func


@Nonlocal(y=0)
def outer():
    def inner():
        outer.y += 1
        return outer.y
    return inner


f = outer()
print(f(), f(), f()) # -> (1 2 3)

Nota che entrambe le versioni funzionano sia in Python 2 che in 3.

C'è una verruca nelle regole di scoping di Python: l'assegnazione rende una variabile locale al suo ambito di funzione che lo racchiude immediatamente. Per una variabile globale, risolveresti questo problema con la globalparola chiave.

La soluzione è introdurre un oggetto condiviso tra i due ambiti, che contenga variabili mutabili, ma a cui si faccia riferimento tramite una variabile non assegnata.

def outer(v):
    def inner(container = [v]):
        container[0] += 1
        return container[0]
    return inner

Un'alternativa è rappresentata dall'hackery di alcuni ambiti:

def outer(v):
    def inner(varname = 'v', scope = locals()):
        scope[varname] += 1
        return scope[varname]
    return inner

Potresti essere in grado di escogitare qualche trucco per ottenere il nome del parametro outere quindi passarlo come varname, ma senza fare affidamento sul nome outervorresti che fosse necessario utilizzare un combinatore Y.

Un altro modo per farlo (anche se è troppo prolisso):

import ctypes

def outer():
    y = 0
    def inner():
        ctypes.pythonapi.PyCell_Set(id(inner.func_closure[0]), id(y + 1))
        return y
    return inner

x = outer()
x()
>> 1
x()
>> 2
y = outer()
y()
>> 1
x()
>> 3

Estendendo l'elegante soluzione di Martineau sopra a un caso d'uso pratico e un po 'meno elegante ottengo:

class nonlocals(object):
""" Helper to implement nonlocal names in Python 2.x.
Usage example:
def outer():
     nl = nonlocals( n=0, m=1 )
     def inner():
         nl.n += 1
     inner() # will increment nl.n

or...
    sums = nonlocals( { k:v for k,v in locals().iteritems() if k.startswith('tot_') } )
"""
def __init__(self, **kwargs):
    self.__dict__.update(kwargs)

def __init__(self, a_dict):
    self.__dict__.update(a_dict)

Usa una variabile globale

def outer():
    global y # import1
    y = 0
    def inner():
        global y # import2 - requires import1
        y += 1
        return y
    return inner

f = outer()
print(f(), f(), f()) #prints 1 2 3

Personalmente non mi piacciono le variabili globali. Ma la mia proposta si basa sulla risposta https://stackoverflow.com/a/19877437/1083704

def report():
        class Rank: 
            def __init__(self):
                report.ranks += 1
        rank = Rank()
report.ranks = 0
report()

dove l'utente deve dichiarare una variabile globale ranks, ogni volta che è necessario chiamare il file report. Il mio miglioramento elimina la necessità di inizializzare le variabili di funzione dall'utente.