Discussion :

[Le Furet]

Bonsoir,

j'ai besoin d'une variable de classe statique qui contient la première instance de la classe. J'ai naïvement fait ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
class A:
    master = None
 
    def __init__(self, l):
        if self.master:
            print str(self) + " n'est pas maitre"
            self.is_master = False
        else:
            print str(self) + " est maitre"
            self.master = self
            self.is_master = True
 
        self.l = l
 
 
test = A([A([]), A([])])

Contrairement à ce que j'attendais, les trois instances sont maître :

<__main__.A instance at 0xb77264cc> est maitre
<__main__.A instance at 0xb77264ec> est maitre
<__main__.A instance at 0xb77265cc> est maitre

Si quelqu'un peut m'expliquer pourquoi, et comment résoudre mon problème (si possible sans utiliser une variable globale), ça serait sympa

[mont29]

Je n’en suis pas vraiment sûr, mais je dirais que quand tu assignes self.master, tu crées une variable d’instance qui “écrase” dans cet objet la variable de classe… Enfin bref, je n’ai pas creusé la théorie, mais en tout cas, en faisant explicitement appel à la classe (au moins pour l’assignation), ça m’a tout l’air de marcher :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class A:
    master = None
 
    def __init__(self, l):
        if self.__class__.master: # ici, c’est optionnel, tu peux conserver self.master…
            print(str(self) + " n'est pas maitre")
            self.is_master = False
        else:
            print(str(self) + " est maitre")
            self.__class__.master = self # ici, par contre, obligé de passer par __class__
            self.is_master = True
 
        self.l = l
 
 
test = A([A([]), A([])])

…me donne (sous python2.6 comme 3.2) :

<__main__.A object at 0x7fe9dd65e610> est maitre
<__main__.A object at 0x7fe9dd65e710> n'est pas maitre
<__main__.A object at 0x7fe9dd65e750> n'est pas maitre

[Zorro]

Cherche du coté des classmethod et staticmethod.
voir dans cette discussion.

Z

[tyrtamos]

Bonjour,

Je suis d'accord avec mont29 sur le fait que l'affectation de self.master crée une nouvelle variable appartenant à l'instance de classe (instance dont l'adresse est 'self').

Pour que ça reste une variable appartenant à la classe, Il suffit de la préfixer par le nom de la classe: A.master.

Voilà un petit exemple qui montre que master est dans ce cas bien partagée par toutes les instances de la classe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class A:
    master = None
 
    def affecte(self, chaine):
        A.master= chaine
 
    def affiche(self):
        print A.master
 
x = A()
y = A()
 
x.affecte("toto")
y.affiche()
toto

Tyrtamos

[Le Furet]

Merci

Je m'étais inspiré d'un vieux post du forum où il était dit que <classe>.variable_statique et <instance>.variable_statique étaient synonymes, mais effectivement, ça ne l'est pas.

[PauseKawa]

Bonjour,

Autre approche

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#
#
class A(object):
 
    def __init__(self, m={}):
 
        self.m = m
 
        if 'master' in self.m:
            print(str(self) + " n'est pas maitre")
            self.is_master = False
        else:
            print(str(self) + " est maitre")
            self.m['master'] = self
            self.is_master = True
 
    def getmaster(self):
        return 'le maitre de ' + str(self) + ' est ' + str(self.m['master'])
 
test = A()
print(test.getmaster())
test = A()
print(test.getmaster())
test = A()
print(test.getmaster())

Après tout ce n'est qu'une histoire de conteneur.

@+

[wiztricks]

Salut,
Je suis d'accord, c'est une question de boîte... et il y a plusieurs "façons" pour traiter cette asymétrie "dans la boîte".
Boîte "classe" et __new__:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Base(object):
 
    @property
    def is_master(self):
        return self.master is self
 
    def __str__(self):
        return 'is_master: %s' % self.is_master
 
class A1(Base):
 
    master = None
    def __new__(cls, *args, **kwds):
        instance = object.__new__(cls)
        if cls.master is None:
            cls.master = instance
        return instance
 
a = A1()
b = A1()
print a
print b

L'inconvénient est que la classe étant, par défaut, "singleton", il ne va pas être simple d'avoir plusieurs ensemble ayant des "masters" différents. On peut "utiliser" __call__ ainsi pour résoudre cela:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class A2(Base):
 
    def __init__(self, master=None, *args, **kwds):
        self.master = self
 
    def __call__(self, *args, **kwds):
        clone = self.__class__(*args, **kwds)
        clone.master = self.master
        return clone
 
F = A2()
a = F()
b = F()
print F
print a
print b

Ce sont des constructions pythonesques autour des classes à connaître mais à utiliser avec modération.
- W