Comment puis-je accéder aux variables de classe "statiques" dans les méthodes en Python ?

Question

Si j'ai le code suivant :

class Foo(object):
    bar = 1

    def bah(self):
        print(bar)

f = Foo()
f.bah()

Il se plaint

NameError : le nom global 'bar' n'est pas défini

Comment puis-je accéder à une classe/ variable statique bar dans la méthode bah ?

Answer 1

Au lieu de bar utilice self.bar o Foo.bar . Affectation à Foo.bar créera une variable statique, et en l'assignant à self.bar va créer une variable d'instance.

Answer 2

Définir une méthode de classe :

class Foo(object):
    bar = 1
    @classmethod
    def bah(cls):    
        print cls.bar

Maintenant si bah() doit être une méthode d'instance (c'est-à-dire avoir accès à self), vous pouvez toujours accéder directement à la variable de classe.

class Foo(object):
    bar = 1
    def bah(self):    
        print self.bar

Answer 3

Comme dans tous les bons exemples, vous avez simplifié ce que vous essayez réellement de faire. C'est bien, mais il est bon de noter que python possède une fonction lot de flexibilité lorsqu'il s'agit de variables de classe ou d'instance. On peut dire la même chose des méthodes. Pour une bonne liste de possibilités, je vous recommande de lire Introduction aux classes de style nouveau de Michael Fötsch en particulier les sections 2 à 6.

Une chose dont il faut se souvenir quand on commence, c'est que python n'est pas java. Plus qu'un simple cliché. En Java, une classe entière est compilée, ce qui rend la résolution de l'espace de noms très simple : toutes les variables déclarées en dehors d'une méthode (n'importe où) sont des variables d'instance (ou, si elles sont statiques, de classe) et sont implicitement accessibles dans les méthodes.

Avec python, la règle générale est qu'il y a trois espaces de noms qui sont recherchés, dans l'ordre, pour les variables :

1. La fonction/méthode
2. Le module actuel
3. Builtins

{begin pedagogy}

Il existe des exceptions limitées à cette règle. La principale qui me vient à l'esprit est que, lorsqu'une définition de classe est chargée, elle constitue son propre espace de noms implicite. Mais cela ne dure que tant que le module est chargé, et est entièrement contourné lorsqu'il se trouve dans une méthode. Ainsi :

>>> class A(object):
        foo = 'foo'
        bar = foo

>>> A.foo
'foo'
>>> A.bar
'foo'

mais :

>>> class B(object):
        foo = 'foo'
        def get_foo():
            return foo
        bar = get_foo()

Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    class B(object):
  File "<pyshell#11>", line 5, in B
    bar = get_foo()
  File "<pyshell#11>", line 4, in get_foo
    return foo
NameError: global name 'foo' is not defined

{end pedagogy}

En fin de compte, la chose à retenir est que vous faire ont accès à toutes les variables auxquelles vous voulez accéder, mais probablement pas de manière implicite. Si vos objectifs sont simples et directs, alors choisir Foo.bar ou self.bar sera probablement suffisant. Si votre exemple devient plus compliqué, ou si vous voulez faire des choses fantaisistes comme l'héritage (vous pouvez hériter des méthodes statiques/de la classe !), ou si l'idée de faire référence au nom de votre classe dans la classe elle-même vous semble fausse, consultez l'introduction que j'ai citée.

Answer 4

class Foo(object):
     bar = 1
     def bah(self):
         print Foo.bar

f = Foo() 
f.bah()

Answer 5

bar est votre variable statique et vous pouvez y accéder en utilisant Foo.bar .

Fondamentalement, vous devez qualifier votre variable statique avec un nom de classe.