Python et l'orienté objet

Version imprimable

Bonjour. J'ai un petit soucie à comprendre la différence entre variable d'instance et variable de classe. Voici un petit module de trace que j'ai créé :

Code:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
import time
import datetime
 
myModuleList = list()
#ERROR and OFF is the samething.
myModuleList=[{'ModuleName':'ReplicationMaestro',           'FunctionName':'ALL',   'TraceLevel': 'DEBUG'}, \
            {'ModuleName': 'packagesEXPToCompress',         'FunctionName':'ALL',   'TraceLevel': 'DEBUG'}, \
            {'ModuleName': 'packagesACKToDecompress',       'FunctionName':'ALL',   'TraceLevel': 'DEBUG'}, \
            {'ModuleName': 'packagesEXPToDecompress',       'FunctionName':'ALL',   'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'packagesToProcess',             'FunctionName':'ALL',   'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'packagesACKToCompress',         'FunctionName':'ALL',   'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'packagesACKToTransfer',         'FunctionName':'ALL',   'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'packagesToTransfer',            'FunctionName':'ALL',   'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'packagesToACK',                 'FunctionName':'ALL',   'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'packagesToImport',              'FunctionName':'ALL',   'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'packagesToExport',              'FunctionName':'ALL',   'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'packagesToExport',              'FunctionName':'__isFullExport',   'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'packagesToRmvFromOrigin',       'FunctionName':'ALL',   'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'packagesToRmvFromDestination',  'FunctionName':'ALL',   'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'SiteXMLHandler',        'FunctionName':'ALL' ,  'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'SchedulerXMLHandler',   'FunctionName':'ALL' ,  'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'Tools',                 'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'Tools',                 'FunctionName':'Now_CleanString' ,  'TraceLevel': 'OFF'}, \
            {'ModuleName': 'Tools',                 'FunctionName':'Now_Object' ,  'TraceLevel': 'OFF'}, \
            {'ModuleName': 'Robocopy',              'FunctionName':'ALL' ,  'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'SitesManager',          'FunctionName':'ALL' ,  'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'SchedulersManager',     'FunctionName':'ALL' ,  'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'ScheduleChecker',       'FunctionName':'ALL' ,  'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'ScheduleChecker',       'FunctionName':'getCurrentTimeFrame' ,  'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'DaysOfTheWeek',         'FunctionName':'ALL' ,  'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'RemoveOrigPackage',     'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'RemoveDestPackage',     'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'CompressAckPckg',       'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'CompressExpPckg',       'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'TransferPackage',       'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'TransferACKPackage',    'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'ReceiveAck',            'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'ApplyPackage',          'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'ExtractForSite',        'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'main',                  'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'DecompressAckPckg',     'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'DecompressExpPckg',     'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'Action',                'FunctionName':'ALL' ,  'TraceLevel': 'INFO'}, \
            {'ModuleName': 'Oracle',                'FunctionName':'ALL',  'TraceLevel': 'ERROR'}, \
            {'ModuleName': 'Oracle',                'FunctionName':'executeSQL',        'TraceLevel': 'OFF'}]
 
class TRACES:
    count = 0
    Indentation = ""
    def __init__(self, moduleToTraces, functionToTraces):
 
        self.myModuleList = myModuleList
        self.moduleToTraces = moduleToTraces
        self.functionToTraces = functionToTraces
        if self.__isTracesNeeded():
            self.__setIndentation()
            TRACES.count += 1
            self.tracescount  = TRACES.count
            if TRACES.Indentation:
                self.LOG("[" + self.__NOW() + "] " + TRACES.Indentation  + moduleToTraces + "::" + functionToTraces + " {")
            else:
                self.LOG("[" + self.__NOW() + "] " + moduleToTraces + "::" + functionToTraces + " {")
            self.Indentation = TRACES.Indentation + ": "
        else:
            tmp = TRACES.Indentation
            self.__setIndentation()
            self.Indentation = TRACES.Indentation
            TRACES.Indentation = tmp
 
    def __del__(self):
        if self.__isTracesNeeded():
            try:
                if TRACES.Indentation:
                    self.LOG("[" + self.__NOW() + "] " + TRACES.Indentation + "} ")
                else:
                    self.LOG("[" + self.__NOW() + "] } ")
                TRACES.count -= 1
                TRACES.Indentation = TRACES.Indentation.replace(": ", "", 1)
                TRACES.Indentation = TRACES.Indentation.lstrip()
            except:
                self.LOG("[" + self.__NOW() + "] } ")
 
    def __setIndentation(self):
        Indentation = ""
        for i in range (0, TRACES.count):
            Indentation += ": "
 
        TRACES.Indentation = Indentation
 
    def ERROR(self, message):
        try:
            self.LOG("[" + self.__NOW() + "] " + self.Indentation + "**ERROR** in" + self.moduleToTraces + "::" + self.functionToTraces + "||" + message)
        except:
            self.LOG("error ERROR IN THE STRING YOU TRY TO TRACE")
 
    def DEBUG(self, message):
        try:
            if self.__isTracesNeeded("DEBUG"):
                self.LOG("[" + self.__NOW() + "] " + self.Indentation  +  message)
        except:
            self.LOG("debug ERROR IN THE STRING YOU TRY TO TRACE")
 
    def INFO(self, message):
        try:
            if self.__isTracesNeeded("INFO"):
                self.LOG("[" + self.__NOW() + "] " + self.Indentation + message)
        except:
            self.LOG("info ERROR IN THE STRING YOU TRY TO TRACE")
 
    def WARNING(self, message):
        try:
            if self.__isTracesNeeded("WARNING"):
                self.LOG("[" +  self.__NOW() + "] " + self.Indentation + "!WARNING! " + message)
        except:
            self.LOG("warning ERROR IN THE STRING YOU TRY TO TRACE")
 
    def LOG(self, message):
        print message
 
    def __NOW(self):
        import datetime
        return "(UTC)" + str(datetime.datetime.utcnow()).split(".")[0]
 
    def __isTracesNeeded(self, levelToCheck="ALLLEVEL"):
        show = False
        for module in self.myModuleList:
            if self.moduleToTraces in module['ModuleName']:
                if self.functionToTraces in module['FunctionName'] or module['FunctionName'] == 'ALL':
                    if module['TraceLevel'].upper() == "OFF" or module['TraceLevel'].upper() == "ERROR":
                        show =  False
                    elif levelToCheck.upper() == "ALLLEVEL":
                        show =  True
                    elif levelToCheck.upper() == "WARNING" and (module['TraceLevel'].upper() == "WARNING" or module['TraceLevel'].upper() == "INFO" or module['TraceLevel'].upper() == "DEBUG"):
                        show =   True
                    elif levelToCheck.upper() == "INFO" and (module['TraceLevel'].upper() == "DEBUG" or module['TraceLevel'].upper() == "INFO") :
                        show =   True
                    elif levelToCheck.upper() == "DEBUG" and (module['TraceLevel'].upper() == "DEBUG") :
                        show =   True
 
        #Module was not find in the list, that means that the we do not trace the module
        return show
 
####################################################################################
##### Called at the command line ###################################################
####################################################################################
if __name__ == '__main__':
    #print str(myModuleList[4]['ModuleName'])
    myTraces = TRACES("ReplicationMaestro", "function1")
    myTraces.DEBUG("niveau debug")
    myTraces.ERROR("niveau error")
    myTraces.INFO("niveau info")
    myTraces.WARNING("niveau warning")
 
    myTraces2 = TRACES("packagesEXPToCompress", "function2")
    myTraces2.DEBUG("niveau debug")
    #myTraces2.ERROR("niveau error")
    myTraces2.WARNING("niveau warning")
    myTraces2.INFO("niveau info")
    #
    myTraces3 = TRACES("packagesACKToDecompress", "function3")
    myTraces3.DEBUG("niveau debug")
    #myTraces3.ERROR("niveau error")
    myTraces3.WARNING("niveau warning")
    myTraces3.DEBUG("niveau debug")

Mon problème vient du fait que je n'ai plus accès aux variables de TRACES dans le dernier __del__ appelé. C'est comme si, dans le dernier __del__, les variables de classes sont effacé avant de débuter la fonction...

Quelqu'un peu m'aider?

merci!

Salut, je n'ai pas vraiment creusé (en fait pas du tout) ton code, mais une chose me saute aux yeux : plusieurs fois à l'interieur de tes méthode tu fais :

Code:

TRACES.uneVariable=valeur

alors qu'il faudrait faire tout simplement :

Code:

self.uneVariable=valeur

La forme que tu utilise est celle que l'on peut utiliser pour ajouter un attribut à une classe depuis l'exterieur de cette dernière :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 >>> class A(object):pass >>> a=A() >>> b=A() >>> A.foo=1 >>> a.foo 1 >>> b.foo 1 >>> b.foo2=0 >>> b.foo2 0 >>> a.foo2 Traceback (most recent call last): File "<pyshell#17>", line 1, in <module> a.foo2 AttributeError: 'A' object has no attribute 'foo2'
Ton problème viens de là

PS : on peut déclarer un attribut d'une classe depuis cette dernière sans le "self", mais seulement en dehors des méthodes, sinon il faut utiliser "self"

EDIT : Je viens de remarquer que tu utilisait la forme TRACES.uneVar depuis les méthodes pour acceder à l'attribut identations que tu as déclarer de cette façon :
Code:

1 2 3 4 5 6 7 8 9 10 11 class TRACES(object): identations='blabla' #la valeur n'a aucune importance pour l'explication ;) #identations est maintenant un attribut de la classe TRACES #depuis cet endroit on peut y acceder de la même façon qu'un variable locale: print identations def __init__(self): #voici la façon dont tu essayais de changer la valeur d'itentations : TRACES.identations='pas bon' #CE N'EST PAS BON #depuis une méthode, on accède et (re)défini un attribut de cette façon : self.identations="c'est bon" print self.identations
En fait ta façon de faire peut marcher dans une certaine mesure, mais possède un comportement un peu spécial :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class A(object): a=1 >>> a=A() >>> b=A() >>> b.a+=1 >>> b.a 2 >>> A.a=5 >>> a.a 5 #ici, l'attribut a de l'instance a à bien été modifiée, parcequ'il n'avais pas été modifié (il pointait en fait toujours sur l'attribut de la classe) >>> b.a 2 #ici, l'attribut a de l'instance b n'a pas été modifié, parcequ'il avait déjà été modifié, devenant ainsi véritablement un attribut de l'instance et non un simple pointage vers l'attibut de la classe

14/01/2009, 16h00
peterphonic

Bonjour,

En fait, l'objectif de faire TRACES.Indentation, c'est que je veux que la prochaine instance se rapelle l'Indentation... si je fais self.Indentation, c'est comme une nouvelle variable à chaque fois. En gros, je veux que mes instances partage une variable.... C'est possible?

Un petit exemple qui illustre les variables de classes et d'instance.
Code:

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/python # -*- coding: utf-8 -*- class MaClasse: cls_var = 0 def test(self, value = None): if value is not None: self.inst_var = value MaClasse.cls_var += 1 print 'cls_var = ', MaClasse.cls_var print 'inst_var = ', self.inst_var def __del__(self): print 'cls_var = ', MaClasse.cls_var test = MaClasse() test.test(12) test1 = MaClasse() test1.test(23) test.test() test1.test() del test del test1
J'ai toujours accès à ma variable de classe dans le __del__ et elle à la bonne valeur.

Pour en revenir à ton code, si je le copie/colle tel quel, je ne passe pas dans __del__ vu que tu ne delete pas ton instance et qu'elle n'est supprimé qu'après que ton programme soit fini.

Arf désolé, j'avais lu trop vite :oops:...

Ben en fait, tu t'y prend de la bonne manière, sauf dans l'initialisation

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    def __init__(self, moduleToTraces, functionToTraces):
 
        self.myModuleList = myModuleList
        self.moduleToTraces = moduleToTraces
        self.functionToTraces = functionToTraces
        if self.__isTracesNeeded():
            self.__setIndentation()
            TRACES.count += 1
            self.tracescount  = TRACES.count
            if TRACES.Indentation:
                self.LOG("[" + self.__NOW() + "] " + TRACES.Indentation  + moduleToTraces + "::" + functionToTraces + " {")
            else:
                self.LOG("[" + self.__NOW() + "] " + moduleToTraces + "::" + functionToTraces + " {")
            self.Indentation = TRACES.Indentation + ": "
        else:
            tmp = TRACES.Indentation
            self.__setIndentation()
            self.Indentation = TRACES.Indentation
            TRACES.Indentation = tmp

ici, cette ligne transforme l'attribut de classe en attribut d'instance... regarde le dernier cadre de code de mon dernier message... autre exemple du comportement :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> class A:
    y=0
    def __init__(self, statement=True):
        if statement: self.y=A.y
        A.y=50
 
 
>>> a=A()
>>> b=A(False)
>>> a.y
0
>>> b.y
50
>>> A.y=256
>>> a.y
0
>>> b.y
256

Bon, je dois aller mangar, donc j'éspère que t'aura compris, sinon, à tout à l'heure ;)

oulala, c'est plus compliqué que je croyais...

Pendant que je digère et comprenne bien cette particularité de python, pourrais tu me dire pourquoi le code suivant crash dans le __del__?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class A: y=0 def __init__(self, statement=True): if statement: self.y=A.y A.y=50 def __del__(self): print A.y a=A() b=A(False) print "a.y: ", a.y print "b.y: ", b.y A.y=256 print "a.y: ", a.y print "b.y: ", b.y
Oui, comme tu dis plus haut, je n'apelle pas le del, mais à la fin de l'exécution du script, mes objets meurent et le __del__ est automatiquement appelé pour chaque objet. Pourquoi j'ai l'erreur qui dit que y est None?

Je viens de faire un petit test... le code suivant ne crash pas
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 class A: y=0 def __init__(self, statement=True): if statement: self.y=A.y A.y=50 def __del__(self): print A.y class test: def __init__(self): a=A() b=A(False) print "a.y: ", a.y print "b.y: ", b.y A.y=256 print "a.y: ", a.y print "b.y: ", b.y t = test()
Alors la, je ne comprend plus rien... En gros, je devrais acheter un bon livre de python et revoir les principes de base python... j'ai clairement pas compris des choses de bases :cry:

Citation:
Envoyé par peterphonic
oulala, c'est plus compliqué que je croyais...

Pendant que je digère et comprenne bien cette particularité de python, pourrais tu me dire pourquoi le code suivant crash dans le __del__?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class A: y=0 def __init__(self, statement=True): if statement: self.y=A.y A.y=50 def __del__(self): print A.y a=A() b=A(False) print "a.y: ", a.y print "b.y: ", b.y A.y=256 print "a.y: ", a.y print "b.y: ", b.y
Oui, comme tu dis plus haut, je n'apelle pas le del, mais à la fin de l'exécution du script, mes objets meurent et le __del__ est automatiquement appelé pour chaque objet. Pourquoi j'ai l'erreur qui dit que y est None?
Ce code là ne crash pas chez moi et d'ailleurs il ne passe pas dans le __del__. Quel est le message d'erreur et sous quel environnement ?

14/01/2009, 21h40
peterphonic

Salut!

windows XP, python 2.4 et voici l'erreur :

Exception exceptions.AttributeError: "'NoneType' object has no attribute 'y'" in <bound method A.__del__ of <__main__.A instance at 0x00A86B70>> ignored

perso, j'ai jamais utilisé python 2.4, là je suis sur la 2.5.2, testes donc ce code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
class A:
    y=0
    def __init__(self, statement=True):
        if statement: self.y=A.y
        A.y=50
 
    def __del__(self):
        print A.y
 
a=A()
b=A()
print "a.y : %i\nb.y : %i"%(a.y,b.y)
del a, b

Sinon, pour l'explication... je vais essayer d'expliquer via un code, qu'il faudra lire ligne par ligne, l'explication sera chronologique :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#debut de la lecture du script par l'ordi
class A: #debut de la definition d'une classe
    y=0 #création de A.y admettons à l'adresse mémoire 0x0000:0x0001
    def __init__(self): # definition d'une méthode
        self.z=0 #pas de lecture
 
#A ce stade de la lecture, A.y existe, mais pas A.z, d'ailleurs A.z n'existera\
#pas, par contre A().z pourra exister, mais pas encore...
 
a=A() #Création d'une instance de A (ce qui inclut la lecture (et execution) cette fois de la méthode __init__())
#Maintenant a.z existe, mais toujours pas A.z, qui n'existera jamais
#a.y, en lecture, à pour valeur une instruction qui lui dit d'aller voir la valeur écrite à l'adresse 0x0000:0x0001 a.y à lui-même pour adresse 0x0000:0x0003
 
a.y=50 #une valeur à été affectée à a.y (rapelons-nous que sa valeur juste avant était une instruction qui lui disait d'aller voir en 0x0000:0x0001)
#résumons :
# en 0x0000:0x0001 il y a la valeur 0 (valeur de A.y)
# en 0x0000:0x0003 il y a la valeur 50 (valeur de a.y)
#donc, si par la suite on fais
A.y=108 
#on demande de mettre la valeur 108 à l'adresse 0x0000:0x0001
#ce qui n'a aucune influence sur la valeur en 0x0000:0x0003 (a.y)
#ce qu'il faudrait, pour remettre les choses comme elles l'étais, c'est de
#mettre comme valeur à l'adresse 0x0000:0x0003 l'instruction d'aller voir
#en 0x0000:0x0001, mais ça, je ne sais pas si c'est faisable en python

il faudrait fouiller dans les derniers messages du forum, il me semble que cette question à été abordée...

Citation:
Envoyé par N.tox
perso, j'ai jamais utilisé python 2.4, là je suis sur la 2.5.2, testes donc ce code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class A: y=0 def __init__(self, statement=True): if statement: self.y=A.y A.y=50 def __del__(self): print A.y a=A() b=A() print "a.y : %i\nb.y : %i"%(a.y,b.y) del a, b
Le résultat de ton code sans l'apelle explicite de del

a.y : 0
b.y : 50
Exception exceptions.AttributeError: "'NoneType' object has no attribute 'y'" in <bound method A.__del__ of <__main__.A instance at 0x00A86B70>> ignored
Exception exceptions.AttributeError: "'NoneType' object has no attribute 'y'" in <bound method A.__del__ of <__main__.A instance at 0x00A86DF0>> ignored

Ton code avec l'apelle du del

a.y : 0
b.y : 50
50
50

Je suis un peu confus. Est ce qu'on doit utiliser le del? Je croyais que python s'occupait de détruire automatiquement les objets?

14/01/2009, 22h11
DelphiManiac

Je pense que, d'une part c'est lié à la version de python et que d'autre part l'erreur se produit seulement en fin de programme, pour preuve ton deuxième exemple ou tu instances tes classes dans une autre classe.
14/01/2009, 22h29
N.tox

arf, ch'uis trop long à éditer les post :lol:, sinon je ne dis pas mieux que Delphimaniac : erreur due à la version de python, erreur d'ailleurs totalement benigne, sauf si dans ton cas (enfin je crois) on compte sur cette destruction d'objet automatique pour sortir un dernier affichage de données...
14/01/2009, 22h39
Guigui_

pas d'erreur chez moi (sous python 2.4.4 sur XP)

Le mieux est si tu en as la possibilité de passer à Python 2.5 (voire 2.6 si pas de souci avec l'utilisation de bibliohtèques externes non encore à jour).