Portée des classes imbriquées?

J'essaie de comprendre la portée des classes imbriquées en Python. Voici mon exemple de code:

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

La création de la classe ne se termine pas et j'obtiens l'erreur:

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

Essayer inner_var = Outerclass.outer_varne fonctionne pas. Je reçois:

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

J'essaye d'accéder à la statique à outer_varpartir de InnerClass.

Y a-t-il un moyen de faire cela?

class Outer(object):
    outer_var = 1

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

Ce n'est pas tout à fait la même chose que des choses similaires fonctionnent dans d'autres langues et utilisent la recherche globale au lieu d'étendre l'accès à outer_var. (Si vous modifiez l'objet Outerauquel le nom est lié, ce code utilisera cet objet la prochaine fois qu'il sera exécuté.)

Si vous souhaitez à la place que tous les Innerobjets aient une référence à un Outercar outer_varest vraiment un attribut d'instance:

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

Notez que l'imbrication de classes est quelque peu rare en Python et n'implique pas automatiquement une sorte de relation spéciale entre les classes. Vous feriez mieux de ne pas nicher. (Vous pouvez toujours définir un attribut de classe sur Outerpour Inner, si vous voulez.)

Je pense que vous pouvez simplement faire:

class OuterClass:
    outer_var = 1

    class InnerClass:
        pass
    InnerClass.inner_var = outer_var

Le problème que vous avez rencontré est dû à ceci:

Un bloc est un morceau de texte de programme Python qui est exécuté en tant qu'unité. Les blocs suivants sont: un module, un corps de fonction et une définition de classe.
(...)
Une portée définit la visibilité d'un nom dans un bloc.
(...)
La portée des noms définis dans un bloc de classe est limitée au bloc de classe; il ne s'étend pas aux blocs de code des méthodes - cela inclut les expressions génératrices puisqu'elles sont implémentées à l'aide d'une portée de fonction. Cela signifie que ce qui suit échouera:

   class A:  

       a = 42  

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

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

Ce qui précède signifie:
un corps de fonction est un bloc de code et une méthode est une fonction, alors les noms définis à partir du corps de fonction présent dans une définition de classe ne s'étendent pas au corps de fonction.

Paraphrasant ceci pour votre cas:
une définition de classe est un bloc de code, alors les noms définis à partir de la définition de classe interne présente dans une définition de classe externe ne s'étendent pas à la définition de classe interne.

Vous feriez peut-être mieux de ne pas utiliser de classes imbriquées. Si vous devez imbriquer, essayez ceci:

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

Ou déclarez les deux classes avant de les imbriquer:

class OuterClass:
    outer_var = 1

class InnerClass:
    inner_var = OuterClass.outer_var

OuterClass.InnerClass = InnerClass

(Après cela, vous pouvez del InnerClasssi vous en avez besoin.)

Solution la plus simple:

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

Cela vous oblige à être explicite, mais ne demande pas beaucoup d'efforts.

En Python, les objets mutables sont passés comme référence, vous pouvez donc passer une référence de la classe externe à la classe interne.

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)

Toutes les explications se trouvent dans la documentation Python Le didacticiel Python

Pour votre première erreur <type 'exceptions.NameError'>: name 'outer_var' is not defined. L'explication est:

Il n'y a pas de raccourci pour référencer des attributs de données (ou d'autres méthodes!) À partir de méthodes. Je trouve que cela augmente en fait la lisibilité des méthodes: il n'y a aucune chance de confondre les variables locales et les variables d'instance en parcourant une méthode.

cité dans The Python Tutorial 9.4

Pour votre deuxième erreur <type 'exceptions.NameError'>: name 'OuterClass' is not defined

Lorsqu'une définition de classe est laissée normalement (via la fin), un objet de classe est créé.

cité dans The Python Tutorial 9.3.1

Alors quand vous essayez inner_var = Outerclass.outer_var, le Quterclassn'a pas encore été créé, c'est pourquoiname 'OuterClass' is not defined

Une explication plus détaillée mais fastidieuse de votre première erreur:

Bien que les classes aient accès aux étendues des fonctions englobantes, elles n'agissent pas comme des étendues englobantes pour le code imbriqué dans la classe: Python recherche les fonctions englobant les noms référencés, mais jamais les classes englobantes. Autrement dit, une classe est une étendue locale et a accès aux étendues locales englobantes, mais elle ne sert pas d'étendue locale englobante à un code imbriqué supplémentaire.

cité de Learning.Python (5e) .Mark.Lutz