L'ambito delle classi annidate?

Sto cercando di capire l'ambito nelle classi nidificate in Python. Ecco il mio codice di esempio:

class OuterClass:
    outer_var = 1
    class InnerClass:
        inner_var = outer_var

La creazione della classe non viene completata e ottengo l'errore:

<type 'exceptions.NameError'>: name 'outer_var' is not defined

Provare inner_var = Outerclass.outer_varnon funziona. Ottengo:

<type 'exceptions.NameError'>: name 'OuterClass' is not defined

Sto cercando di accedere alla statica outer_varda InnerClass.

C'è un modo per fare questo?

class Outer(object):
    outer_var = 1

    class Inner(object):
        @property
        def inner_var(self):
            return Outer.outer_var

Non è esattamente la stessa cosa che cose simili funzionano in altre lingue e utilizza la ricerca globale invece di limitare l'accesso a outer_var. (Se modifichi quale oggetto il nomeOuter è associato , questo codice utilizzerà quell'oggetto la prossima volta che verrà eseguito.)

Se invece desideri che tutti gli Inneroggetti abbiano un riferimento a un Outerperché outer_varè davvero un attributo di istanza:

class Outer(object):
    def __init__(self):
        self.outer_var = 1

    def get_inner(self):
        return self.Inner(self)
        # "self.Inner" is because Inner is a class attribute of this class
        # "Outer.Inner" would also work, or move Inner to global scope
        # and then just use "Inner"

    class Inner(object):
        def __init__(self, outer):
            self.outer = outer

        @property
        def inner_var(self):
            return self.outer.outer_var

Nota che la nidificazione delle classi è piuttosto insolita in Python e non implica automaticamente alcun tipo di relazione speciale tra le classi. È meglio non fare il nido. (È comunque possibile impostare un attributo di classe su Outerper Inner, se si desidera.)

Penso che tu possa semplicemente fare:

class OuterClass:
    outer_var = 1

    class InnerClass:
        pass
    InnerClass.inner_var = outer_var

Il problema che hai riscontrato è dovuto a questo:

Un blocco è un pezzo di testo del programma Python che viene eseguito come un'unità. I seguenti sono blocchi: un modulo, un corpo della funzione e una definizione di classe.
(...)
Uno scope definisce la visibilità di un nome all'interno di un blocco.
(...)
L'ambito dei nomi definiti in un blocco di classe è limitato al blocco di classe; non si estende ai blocchi di codice dei metodi - questo include le espressioni del generatore poiché sono implementate utilizzando un ambito di funzione. Ciò significa che quanto segue fallirà:

   class A:  

       a = 42  

       b = list(a + i for i in range(10))

http://docs.python.org/reference/executionmodel.html#naming-and-binding

Quanto sopra significa:
un corpo di funzione è un blocco di codice e un metodo è una funzione, quindi i nomi definiti al di fuori del corpo della funzione presente in una definizione di classe non si estendono al corpo della funzione.

Parafrasando questo per il tuo caso:
una definizione di classe è un blocco di codice, quindi i nomi definiti dalla definizione di classe interna presente in una definizione di classe esterna non si estendono alla definizione di classe interna.

Potresti stare meglio se non usi le classi annidate. Se devi annidare, prova questo:

x = 1
class OuterClass:
    outer_var = x
    class InnerClass:
        inner_var = x

Oppure dichiara entrambe le classi prima di annidarle:

class OuterClass:
    outer_var = 1

class InnerClass:
    inner_var = OuterClass.outer_var

OuterClass.InnerClass = InnerClass

(Dopo questo puoi, del InnerClassse necessario.)

Soluzione più semplice:

class OuterClass:
    outer_var = 1
    class InnerClass:
        def __init__(self):
            self.inner_var = OuterClass.outer_var

Richiede che tu sia esplicito, ma non richiede molto sforzo.

In Python gli oggetti mutabili vengono passati come riferimento, quindi puoi passare un riferimento della classe esterna alla classe interna.

class OuterClass:
    def __init__(self):
        self.outer_var = 1
        self.inner_class = OuterClass.InnerClass(self)
        print('Inner variable in OuterClass = %d' % self.inner_class.inner_var)

    class InnerClass:
        def __init__(self, outer_class):
            self.outer_class = outer_class
            self.inner_var = 2
            print('Outer variable in InnerClass = %d' % self.outer_class.outer_var)

Tutte le spiegazioni possono essere trovate nella documentazione di Python The Python Tutorial

Per il tuo primo errore <type 'exceptions.NameError'>: name 'outer_var' is not defined. La spiegazione è:

Non esiste una scorciatoia per fare riferimento ad attributi di dati (o altri metodi!) Dall'interno dei metodi. Trovo che questo in realtà aumenti la leggibilità dei metodi: non c'è possibilità di confondere le variabili locali e le variabili di istanza quando si sfoglia un metodo.

citato da The Python Tutorial 9.4

Per il tuo secondo errore <type 'exceptions.NameError'>: name 'OuterClass' is not defined

Quando una definizione di classe viene lasciata normalmente (tramite la fine), viene creato un oggetto di classe.

citato da The Python Tutorial 9.3.1

Quindi, quando ci provi inner_var = Outerclass.outer_var, Quterclassnon è stato ancora creato, ecco perchéname 'OuterClass' is not defined

Una spiegazione più dettagliata ma noiosa per il tuo primo errore:

Sebbene le classi abbiano accesso agli ambiti delle funzioni che racchiudono, tuttavia, non agiscono come ambiti che racchiudono il codice annidato all'interno della classe: Python cerca le funzioni che racchiudono i nomi referenziati, ma mai le classi che racchiudono. Ovvero, una classe è un ambito locale e ha accesso per racchiudere ambiti locali, ma non funge da ambito locale di inclusione per ulteriore codice nidificato.

citato da Learning.Python (5 °) .Mark.Lutz