objet "globalement" utilisable

Version imprimable

Bonjour à tous,

Je poursuis mon apprentissage de Python et de la programmation objet et plus ça va plus je trouve cela extrêmement intéressant et puissant.

Par contre il semble que je ne maitrise pas bien les espaces de noms !

Voila mon problème :

Mon application est un ensemble de traitements de calculs statistiques, qui utilisent des objets communs.

Pour cela j'ai donc créé :
un module S3Library.py qui contient mes objets communs fonctionnels
un module S3Tools.py qui contient des fonctions et des objets utilitaires

Dans S3Tools, j'ai créé une classe S3Log, dont le but est d'ouvrir (__init__) un fichier texte en écriture, puis, au fur et à mesure du déroulement du calcul d'y ajouter des messages (méthode log) :

Code:

1
2
3
4
5
6
7
8
class S3Log:
    """fichier log de traitement"""
    def __init__(self,fichier):
        self.logFile = open(fichier,'w')
 
    def log(self, niveau, message):
        log = str(datetime.now()) + " " + str(niveau) + " " + str(message) + "\n"
        self.logFile.write(log)

Cela marche d'ailleurs bien, lorsque j'exécute le code ci-dessous, cela crée bien mon fichier Log.txt et écrit bien une première ligne dans celui-ci :

$ cat Log.txt
2010-05-13 11:49:24.128577 0 Debut de traitement

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Codage :
# -*- coding:Utf-8 -*- 
 
# imports
import os
import csv
 
from S3Library     import *
from S3Tools        import *
 
# Création d'une instance de fichier de log
 
logFile = S3Log('Log.txt')
logFile.log(0,"Debut de traitement")

ensuite, ça ce corse :

Pour chaque ligne lue dans le fichier EntrepotData.csv, je crée une instance de la classe Entrepot (module S3Library.py)

Code:

1
2
3
4
5
6
7
# lecture des données et calcul
Reader = csv.DictReader(open('EntrepotData.csv'), delimiter=';',quotechar='"')
nomenclature = Reader.next()
 
for row in Reader:
# instanciation d'un entrepot
    entrepot = Entrepot(nomenclature, row)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# -*- coding:Utf-8 -*- 
#                                                                              #
# Bibliothèque standard du moteur de calcul                                    #
#                                                                              #
# Cette bibliothèque contient l'ensemble des objets nécessaires au calcul      #
#                                                                              #
#______________________________________________________________________________#
 
from UserDict   import UserDict
from datetime   import datetime
 
from S3Tools    import *
 
# Classe Entrepot
class Entrepot:
 
    def __init__(self, nomenclature, entrepot):
        for k, v in entrepot.items():
            w = typage(nomenclature, k, v)
            setattr(self, k, w)

La fonction typage me permet de créer des attributs de l'instance Entrepot du bon type (chaine, entier, date, float,...) à partir des données de mon fichier csv qui sont toutes des strings. Cela me permet notamment de contrôler que les données reçues sont correctes (enfin au bon format..)

Cette fonction devrait me renvoyer un message dans le fichier de log si un attribut ne correspond pas à son type :

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
def typage(nomenclature, cle, valeur): 
    logAtt = None                                   
    try:
        typeValeur = nomenclature[cle]
    except:
        logAtt  = 1
        logMess = "Fonction typage : %s, donnée inexistante" % (cle)
    else:
        if typeValeur == "cr":
            return valeur
        elif typeValeur == "en":
            try:
                return int(valeur)
            except:
                logAtt  = 1
                logMess = "Fonction typage: %s n'est pas un nombre entier valide (%s)" % (cle, valeur)
        elif typeValeur == "dc":
            try:
                return float(valeur)
            except:
                logAtt  = 1
                logMess = "Fonction typage: %s n'est pas un nombre décimal valide (%s)" % (cle, valeur)
        elif typeValeur == "dt":
            try:
                return datetime.strptime(valeur, "%d/%m/%Y")
            except:
                logAtt  = 1
                logMess = "Fonction typage: %s n'est pas une date valide (%s)" % (cle, valeur)
        elif typeValeur == "cr/en":
            try:
                return int(valeur)
            except:
                return valeur
        elif typeValeur == "cr/dc":
            try:
                return float(valeur)
            except:
                return valeur 
        elif typeValeur == "cr/dt":
            try:
                return datetime.strptime(valeur, "%d/%m/%Y")
            except:
                return valeur
 
        if logAtt:
            logFile.log(logAtt, logMess)

Et là, j'ai systématiquement le message :

logFile.log(logAtt, logMess)
NameError: global name 'logFile' is not defined

Je me doute qu'il s'agit d'un problème d'espace de nom, mais je sèche sur la solution. J'ai essayé de définir logFile comme global dans ma fonction typage, mais ça ne marche pas.

Merci à l'avance de votre aide.

13/05/2010, 21h23
kango

bonsoir,

pourquoi ne pas simplement passer l'instance de S3Log en argument de la fonction ? ce qui implique de le donner aussi en paramètre à Entrepot.
13/05/2010, 23h56
alphascorpii

Merci de l'aide Kango,

Entre temps j'ai pensé à cette solution qui fonctionne, c'est vrai, passer logFile à Entrepot qui le repasse à la fonction typage. Néanmoins, cela veut dire qu'il faudra le faire pour toutes les fonctions qui appellent cette méthode et sur l'ensemble de l'applicatif, il risque d'y avoir beaucoup d'appels de ce genre, mais bon ...

Au début j'avais utilisé une fonction et non un objet pour faire fonctionner mon fichier de log, et ça marchait très bien, si nécessaire je reviendrai plutôt à cette solution.

En fait, je voudrais surtout comprendre pourquoi ça ne marche pas ?

Là, l'usage de l'instance de S3Log fonctionne lorsque l'instance est créée ou la méthode log appelée depuis le programme principal, mais pas depuis une fonction d'un autre module, alors que l'instance existe.

C'est ça que je ne comprends pas, pourquoi, puisque mon objet (instance) existe, je ne peux y faire référence ?

mais je suis sûr qu'il y a une bonne raison, et j'avoue que les espaces de noms et les variables globales ou locales, j'ai pas bien saisi comment cela fonctionne, et j'ai beau lire des tutos ou des bouquins, ça ne s'éclaire pas vraiment..., ces notions sont un peu nouvelles pour moi et, il me semble assez différentes d'autres langage (procéduraux en tout cas).
14/05/2010, 07h21
PauseKawa
Bonjour alphascorpii,

Vu l'indentation de typage il semble que cette fonction soit dans S3Library.py et non dans la class Entrepot. En as tu besoin autre part ? Sinon pourquoi ne pas faire :
Code:

1 2 3 4 5 6 7 class Entrepot: def __init__(self, nomenclature, entrepot): .... def typage(self, nomenclature, cle, valeur): ....
A noter que si tu fais un from S3Tools import * dans S3Library il n'est pas besoin de la faire dans le principal.

Sinon :
Code:

1 2 logFile = S3Log('Log.txt') logFile.log(0,"Debut de traitement")
Est dans le main ?

@+

Edit : Sinon teste tes variables avec un print globals()

Hello,

Effectivement j'ai mal décrit l'organisation de mes modules. Comme je l'ai dit mon appli fait des calculs statistiques différents sur des objets communs.

Donc là j'ai :

Calc1.py : programme principal (c'est là que je crée mon objet logFile et édite le premier message de log, et que je crée mes instances d'Entrepot). l'objectif est de créer de nouveaux programmes (Calc2, 3,...) au fur et à mesure des besoins.

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
# Codage :
# -*- coding:Utf-8 -*- 
#
# Calc1
#______
# imports
import os
import csv
 
from S3Library     import *
 
# Création d'une instance de fichier de log
 
logFile = S3Log('Log.txt')
logFile.log(0,"Debut de traitement")
 
# lecture des données et calcul
Reader = csv.DictReader(open('EntrepotData.csv'), delimiter=';',quotechar='"')
 
# défini la nomenclature du fichier
nomenclature = Reader.next()
 
for row in Reader:
# instanciation d'un entrepot
    entrepot1 = Entrepot(nomenclature, row)
#
# ...suite du calcul

S3Library.py : Classes "fonctionnelles", c'est à dire les objets communs qui seront utilisés par mes différents programmes de calcul, et qui contient notamment la classe Entrepot

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# -*- coding:Utf-8 -*-
#
# S3Library.py 
#                                                                              #
# Bibliothèque standard du moteur de calcul                                    #
#                                                                              #
# Cette bibliothèque contient l'ensemble des objets nécessaires aux calculs    #
#                                                                              #
#______________________________________________________________________________#
 
from UserDict   import UserDict
from datetime   import datetime
from S3Tools    import * 
 
# Classe Entrepot
class Entrepot:
 
    def __init__(self, nomenclature, entrepot):
        for k, v in entrepot.items():
            w = typage(nomenclature, k, v)
            setattr(self, k, w)

S3Tools.py : objets et fonctions "utilitaires", communs à l'ensemble de l'application, pour l'instant la classe S3Log et la fonction typage

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
# -*- coding:Utf-8 -*-
#
# S3Tools.py
#
# outils du moteur de calcul
#
#   Fonction typage : typage et contrôle des attributs
#_______________________________________________________________________________
 
from datetime   import datetime
 
#_______________________________________________________________________________
# Fonction typage                                                              
#
# Défini le type et contrôle la validité des données lors de l'instanciation
# des principaux objets du moteur de calcul
#
# en entrée :
#   nomenclature : dictionnaire attribut/type
#   cle : attribut à typer
#   valeur : valeur de l'attribut
#
# en sortie :
#   valeur : attribut de type recherché ou None
#_______________________________________________________________________________
 
def typage(nomenclature, cle, valeur): 
    logAtt = None                                   
    try:
        typeValeur = nomenclature[cle]
    except:
        logAtt  = 1
        logMess = "Fonction typage : %s, donnée inexistante" % (cle)
    else:
        if typeValeur == "cr":
            return valeur
        elif typeValeur == "en":
            try:
                return int(valeur)
            except:
                logAtt  = 1
                logMess = "Fonction typage: %s n'est pas un nombre entier valide (%s)" % (cle, valeur)
        elif typeValeur == "dc":
            try:
                return float(valeur)
            except:
                logAtt  = 1
                logMess = "Fonction typage: %s n'est pas un nombre décimal valide (%s)" % (cle, valeur)
        elif typeValeur == "dt":
            try:
                return datetime.strptime(valeur, "%d/%m/%Y")
            except:
                logAtt  = 1
                logMess = "Fonction typage: %s n'est pas une date valide (%s)" % (cle, valeur)
        elif typeValeur == "cr/en":
            try:
                return int(valeur)
            except:
                return valeur
        elif typeValeur == "cr/dc":
            try:
                return float(valeur)
            except:
                return valeur 
        elif typeValeur == "cr/dt":
            try:
                return datetime.strptime(valeur, "%d/%m/%Y")
            except:
                return valeur
 
        if logAtt:
            S3Tools.logFile.log(logAtt, logMess)
 
#_______________________________________________________________________________
# Class S3Log                                                              
#
# Ecriture d'un message d'alerte dans le log du traitement
#
# en entrée :
#   - niveau : niveau d'alerte 
#     (0= information 1=warning, 2=erreur non fatale, 3=erreur fatale)
#   - message à éditer
#_______________________________________________________________________________
 
class S3Log:
    """fichier log de traitement"""
    def __init__(self,fichier):
        self.logFile = open(fichier,'w')
 
    def log(self, niveau, message):
        log = str(datetime.now()) + " " + str(niveau) + " " + str(message) + "\n"
        self.logFile.write(log)
 
#
# EOF

Mais en fait, je ne sais pas si c'est important, car j'ai fait un essai en regroupant S3Library et S3Tools dans le seul module S3Library, et mon problème subsiste : mon objet logFile instancié dans Calc1.py n'est visiblement pas utilisable dans ma fonction typage, ou en tout cas par une simple référence logFile.log.

Dois-je le qualifier autrement ? genre quelquechose.logfile.log ?

Je pensais naïvement que des variables ou des objets définis dans un niveau étaient accessibles aux niveaux inférieurs ?

Citation:

Envoyé par alphascorpii

Je pensais naïvement que des variables ou des objets définis dans un niveau étaient accessibles aux niveaux inférieurs ?

Non en fait c'est plutôt le contraire, il faut importer un module pour avoir accès aux variables qui y sont déifinies. Il faudrait donc importer Calc1.py (ton module principal) dans S3Tools ce qui ne fonctionnera pas vu que cela créer des imports circulaires (Calc1 importe S3Library qui import S3Tools qui importe Calc1). De plus, c'est contraire au principe de modularité car tu veux pouvoir écrire d'autres programmes principaux.

Ce qui t'a induit en erreur c'est la forme "from S3Tools import *". Cela importe (copie!) les noms définis dans S3Tools dans l'espace de nom du module courant mais les fonctions importées référencent toujours l'espace de nom du module, qui n'est pas accessible quand tu importes sous cette forme.

Dans Calc1.py tu pourrais écrire:
Code:

1 2 3 4 5 ... import S3Tools S3Tools.logFile = S3Log('Log.txt') logFile = S3Tools.logFile # uniquement si tu veux t'en servir dans Calc1 sans le préfixer à chaque fois
Mais ce n'est pas très propre de créer ainsi des variables dans l'espace de nom d'un autre module.
Tu peux aussi faire:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 # dans Calc1.py: initLog('Log.txt') # ou S3Tools.initLog('Log.txt') # ou logFile = initLog('Log.txt') si tu en as besoin dans le module principal # dans S3Tools.py: logFile = None def initLog(filename): global logFile logFile = S3Log(filename) return logFile
De façon générale, il vaut mieux éviter la forme "from module import *" en faveur de "import module" ou "from module import nom1,nom2".

Il ne faut pas avoir peur d'importer un module "un peu partout" pour y avoir accès. Si le module est déjà chargé, Python s'en rendra compte et rendra juste disponible l'espace de nom du module. Par exemple, on trouve parfois:
Code:

1 2 import module from module import nom1, nom2
Ce qui permet d'avoir une référence au module lui-même, et de copier nom1 et nom2 dans l'espace de nom courant pour pouvoir y accéder sans les préfixer.

Il faut juste éviter les imports circulaires...

Citation:

Envoyé par dividee

Non en fait c'est plutôt le contraire, il faut importer un module pour avoir accès aux variables qui y sont déifinies.

Ok ! effectivement j'avais compris tout à l'envers

Citation:

Envoyé par dividee

Ce qui t'a induit en erreur c'est la forme "from S3Tools import *". Cela importe (copie!) les noms définis dans S3Tools dans l'espace de nom du module courant mais les fonctions importées référencent toujours l'espace de nom du module, qui n'est pas accessible quand tu importes sous cette forme.

Là aussi j'ai pas encore tout bien compris entre les différentes formes d'import et leur conséquences. Je vais relire tuto et docs pour approfondir.

Mais quand tu dis "copie!", cela veut-il dire que un nom existe dans deux endroits, l'espace de nom de S3Tools ET l'espace de nom du module courant ? Dans ce cas comment le système s'y retrouve ?

Citation:

Envoyé par dividee

Dans Calc1.py tu pourrais écrire: ...

Là OK, j'ai bien vu qu'effectivement ce n'est pas très "propre" comme programmation. En plus préfixer ne me gène pas.
Citation:
Envoyé par dividee
Code:

1 2 3 4 5 6 7 8 9 10 11 # dans Calc1.py: initLog('Log.txt') # ou S3Tools.initLog('Log.txt') # ou logFile = initLog('Log.txt') si tu en as besoin dans le module principal # dans S3Tools.py: logFile = None def initLog(filename): global logFile logFile = S3Log(filename) return logFile
Là aussi, j'ai bien compris, en fait ça se rapproche de ce que j'avais fait au début en utilisant une fonction et non une classe pour S3Log.

Par contre tu définis logFile comme global dans la définition de la fonction initlog : est que cela veut dire que logFile est accessible ailleurs que dans la fonction ?

En fait, j'ai du comprendre complètement de travers cet exemple ci-dessous, extrait du tuto de Swinnen. Je pensais que la variable a était définie (créée) dans le "main" et que le fait de la déclarer "global" dans la fonction permettait à cette fonction d'accéder à cette variable. C'est donc le contraire : a est définie dans la fonction comme "global" ce qui permet au programme principal d'y accéder ?

Dites moi si j'ai bien compris surtout, tout n'est pas encore très clair :roll:
Code:

1 2 3 4 5 6 7 8 9 10 11 >>> def monter(): ... global a ... a = a+1 ... print a ... >>> a = 15 >>> monter() 16 >>> monter() 17 >>>
Citation:

Envoyé par dividee

Il ne faut pas avoir peur d'importer un module "un peu partout" pour y avoir accès. Si le module est déjà chargé, Python s'en rendra compte et rendra juste disponible l'espace de nom du module.

Ça, je m'en rend compte, d'ailleurs ça me gênait, de faire tout le temps le même import dans mes différents modules, et je ne comprenait pas bien pourquoi et je me disais qu'en terme de performance ça devait pas être terrible :

Par exemple j'ai "from datetime import datetime et from S3Tools import *" dans S3Library, mais dans S3Tools une référence à datetime.now() me donne une erreur si je n'ai pas aussi "from datetime import datetime" dans ce module.

Je trouve ça un peu bizarre, mais bon... Donc tu me confirmes que si j'ai 2 fois le même import, cela référence bien le même espace de noms ?

En tout cas merci à tous pour votre aide.

Bonjour alphascorpii,

Citation:

Envoyé par alphascorpii

Mais quand tu dis "copie!", cela veut-il dire que un nom existe dans deux endroits, l'espace de nom de S3Tools ET l'espace de nom du module courant ? Dans ce cas comment le système s'y retrouve ?

Pour un objet (classe, fonction etc) tu as deux espaces de nom (deux dico en fait) : globals() et locals(). Le système regarde dans locals() puis dans globals()
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 a=1 b=1 def unefonc(): a = 7 print 'globals() et locals() de unefonc' print locals() print globals() print 'a dans locals() :', locals()['a'] print 'Valeur de a dans unefonc :', a print "b n'est pas dans locals() :", b unefonc() print '---------------------------------' print globals() print 'a dans main :', a
Citation:

Envoyé par alphascorpii

Par contre tu définis logFile comme global dans la définition de la fonction initlog : est que cela veut dire que logFile est accessible ailleurs que dans la fonction ?

Oui, du block de code parent.
Citation:
Envoyé par alphascorpii
En fait, j'ai du comprendre complètement de travers cet exemple ci-dessous, extrait du tuto de Swinnen. Je pensais que la variable a était définie (créée) dans le "main" et que le fait de la déclarer "global" dans la fonction permettait à cette fonction d'accéder à cette variable. C'est donc le contraire : a est définie dans la fonction comme "global" ce qui permet au programme principal d'y accéder ?

Dites moi si j'ai bien compris surtout, tout n'est pas encore très clair :roll:
Code:

1 2 3 4 5 6 7 8 9 10 11 >>> def monter(): ... global a ... a = a+1 ... print a ... >>> a = 15 >>> monter() 16 >>> monter() 17 >>>
Oui, la variable est définie dans l'espace global.
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 def monter(): b = a + 1 # assigne b > b = globals()['a'] + 1. globals() car a n'est pas dans locals() donc monter le recherche dans globals() print 'b dans monter :', b print '-------------------------------' def monter1(): global a # print 'a dans locals() :', locals()['a'] # Ne fonctionne pas car global a mets a dans le dico globals() > KeyError: 'a' print 'a dans globals() :', globals()['a'] a = a + 1 # C'est le a dans globals() print 'a dans monter1 :', a # C'est encore le a de globals() print '-------------------------------' def monter2(): # global a a = 10 # assigne a. a est dans locals(). Ce nest pas le meme que celui de globals() print "ce n'est pas les memes" print 'id de a dans locals() :', id(a) print 'a dans locals() :', locals()['a'] print 'a dans globals() :', globals()['a'] a = a + 1 # a existe dans locals() c'est donc celui ci qui est utiliser print 'a dans monter2 :', a print '-------------------------------' a = 15 print '-------------------------------' monter() # 16 print ' a >', a print '-------------------------------' monter1() # 16 print ' a >', a print '-------------------------------' monter2() # 16/11 print 'id de a dans globals() :', id(a) print ' a >', a print '-------------------------------'
Citation:

Envoyé par alphascorpii

Je trouve ça un peu bizarre, mais bon... Donc tu me confirmes que si j'ai 2 fois le même import, cela référence bien le même espace de noms ?

Oui

When Python imports a module, it first checks the module registry (sys.modules) to see if the module is already imported. If that’s the case, Python uses the existing module object as is.

Otherwise, Python does something like this:

1. Create a new, empty module object (this is essentially a dictionary)
2. Insert that module object in the sys.modules dictionary
3. Load the module code object (if necessary, compile the module first)
4. Execute the module code object in the new module’s namespace. All variables assigned by the code will be available via the module object.

This means that it’s fairly cheap to import an already imported module; Python just has to look the module name up in a dictionary.

@+

Re,

J'avais oublier de donner un exemple pour les imports

testv.py

Code:

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/env python
import inspect
# import sys
 
 
a=1
 
class classa(object):
    def retourprt(self):
         return inspect.stack()[1][3]
         # Ou sys._getframe(1).f_code.co_name

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
#!/usr/bin/env python
import testv
from testv import classa
 
#
# Les imports
#
# C'est les meme objects
print id(testv.classa)
test1=testv.classa()
print id(test1.retourprt())
#
print id(classa)
test2=classa()
print id(test2.retourprt())
#
# La preuve
print classa == testv.classa
#
# inspect est importe dans testv...
print testv.inspect.stack()
#
# Un dernier pour la route
monimport = __import__("testv")
test3=monimport.classa()
print id(test3.retourprt())
# pffff, encore lui
#
from testv import *
if 'a' in globals(): print 'ok ici aussi'

Citation:

Envoyé par alphascorpii

Mais quand tu dis "copie!", cela veut-il dire que un nom existe dans deux endroits, l'espace de nom de S3Tools ET l'espace de nom du module courant ? Dans ce cas comment le système s'y retrouve ?

Oui, elle existe à deux endroits quand on utilise la forme "from ... import ...". C'est bien sûr une copie superficielle (shallow copy).
Exemple:
Code:

1 2 3 # module test a = 3 b = []
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 >>> import test >>> from test import * >>> a 3 >>> b [] >>> a = 5 >>> b.append(0) >>> a 5 >>> b [0] >>> test.a 3 # n'a pas été modifié ! >>> test.b [0] # on n'a pas modifié la valeur de la variable b elle-même, # mais l'objet qu'elle référence, qui lui n'a pas été copié
Citation:
Envoyé par alphascorpii
En fait, j'ai du comprendre complètement de travers cet exemple ci-dessous, extrait du tuto de Swinnen. Je pensais que la variable a était définie (créée) dans le "main" et que le fait de la déclarer "global" dans la fonction permettait à cette fonction d'accéder à cette variable. C'est donc le contraire : a est définie dans la fonction comme "global" ce qui permet au programme principal d'y accéder ?

Dites moi si j'ai bien compris surtout, tout n'est pas encore très clair :roll:
Code:

1 2 3 4 5 6 7 8 9 10 11 >>> def monter(): ... global a ... a = a+1 ... print a ... >>> a = 15 >>> monter() 16 >>> monter() 17 >>>
La question ne se pose pas ainsi. Il y a (si on ne joue pas avec globals()) deux façons de créer une variable globale:
1) Lui assigner une valeur au top-level du module
2) Dans une fonction, la déclarer avec le mot-clé global et lui assigner une valeur.

Dans l'exemple que tu donnes, la variable est créée au top-level, puis lue et modifiée par la fonction. Si j'écris:
Code:

1 2 3 4 5 6 7 8 >>> def f(): ... global a ... a = 15 ... >>> f() >>> a=a+1 >>> a 16
c'est l'inverse.

Citation:

Envoyé par alphascorpii

Par exemple j'ai "from datetime import datetime et from S3Tools import *" dans S3Library, mais dans S3Tools une référence à datetime.now() me donne une erreur si je n'ai pas aussi "from datetime import datetime" dans ce module.

Je trouve ça un peu bizarre, mais bon... Donc tu me confirmes que si j'ai 2 fois le même import, cela référence bien le même espace de noms ?

Oui, et c'est cent fois mieux ainsi... Sinon, en lisant le code d'un module, on verrait des accès à des noms sans avoir aucune idée de leur provenance. Le module serait incompréhensible pris en isolation, ce qui est un peu contraire à la notion de "module", non ? La façon dont Python gère cela permet toujours, en lisant le code d'un module, de retrouver d'où proviennent tous les noms utilisés...

Je ne connais pas de système de module qui fonctionne comme tu l'entends, mais cela ressemble un peu aux #include du C (lorsqu'il sont mal utilisés), mais les appeler "système de module" c'est leur faire trop d'honneur...

16/05/2010, 07h58
PauseKawa
Bonjour,

Citation:

Envoyé par dividee

Dans l'exemple que tu donnes, la variable est créée au top-level, puis lue et modifiée par la fonction.

Petite précision (hors sujet) sur le 'modifiée'
Code:

1 2 3 4 5 6 7 8 9 10 11 12 >>> a=0 >>> b=[] >>> print id(a) 27131140 >>> print id(b) 40010936 >>> a=a+1 >>> b.append(0) >>> print id(a) 27131128 >>> print id(b) 40010936
Pourquoi dans le cadre d'une variable (int, var ...) le changement de celle ci implique que ce n'est plus le même objet alors que pour les listes, dico et autres c'est l'objet vers lequel pointe le nom qui est modifier ?
Cela veux t'il dire que dans l'exemple ci dessu j'ai un objet 27131140 de type int et de valeur 0 qui reste en mémoire dans l'attente du prochain ramassage ?
Cela veux t'il dire qu'a chaque assignement (=) Python comprend qu'il dois réserver une adresse (plage variable suivant le type) ?

Oui :
Code:

1 2 3 4 5 6 >>> print id(a) 27131128 >>> a.__add__(10) 11 >>> print id(a) 27131128
C'est bien l'opérateur = le 'coupable', il demande la création d'une nouvelle variable et écrase le nom dans l'espace de nom (promis dividee, je mets mes locals()/globals() dans ma poche pour cette fois). L'utilisation d'une méthode permet de modifier l'objet lui même. C'est évident pour les autres objets (b=[]) mais moins pour les variables.

@+

Bonjour,

Citation:

Envoyé par PauseKawa

Pourquoi dans le cadre d'une variable (int, var ...) le changement de celle ci implique que ce n'est plus le même objet alors que pour les listes, dico et autres c'est l'objet vers lequel pointe le nom qui est modifier ?

Pourquoi ? Je pourrais dire que c'est parce que c'est ce que tu lui demandes de faire... Toutes les variables sont des références (càd des pointeurs, en première approximation) en Python, même pour les types de bases comme int.

Citation:

Envoyé par PauseKawa

Cela veux t'il dire que dans l'exemple ci dessu j'ai un objet 27131140 de type int et de valeur 0 qui reste en mémoire dans l'attente du prochain ramassage ?

Pour les entiers longs oui. Pour les petits entiers comme 0 il y a des optimisations dans le core pour ces cas fréquents. L'objet int(0) n'est pas supprimé lorsque son nombre de référence atteint 0 mais est gardé en attente de sa prochaine utilisation.

Au passage, quand tu dis "dans l'attente du prochain ramassage", il ne faut pas voir le GC de Python comme celui de Java ou .NET. Un objet est supprimé immédiatement lorsque son compteur de références atteint 0. Un "ramassage" n'est lancé que pour détecter et supprimer des objets "morts" dont le nombre de référence n'est pas 0, c'est à dire lorsqu'on a des références cycliques.

Citation:

Envoyé par PauseKawa

Cela veux t'il dire qu'a chaque assignement (=) Python comprend qu'il dois réserver une adresse (plage variable suivant le type) ?

Tu veux dire allouer de la mémoire ? Ce n'est pas l'assignement qui alloue de la mémoire mais la création de l'objet. Si tu assignes à une variable un objet déjà existant il n'y a pas d'allocation (a=b). Si tu crées un objet sans l'assigner il y a une allocation, même si il est supprimé juste après car il n'y a pas de références qui pointe dessus:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 >>> id([]) 14299824 >>> id([]) 14497072 >>> id(7) 3368416 >>> id(7) 3368416 # optimisation pour les int >>> id(489762752457257259178) 10332784 >>> id(489762752457257259178) 10332688 # ... mais pas les long
Citation:
Envoyé par PauseKawa
Code:

1 2 3 4 5 6 >>> print id(a) 27131128 >>> a.__add__(10) 11 >>> print id(a) 27131128
C'est bien l'opérateur = le 'coupable', il demande la création d'une nouvelle variable et écrase le nom dans l'espace de nom (promis dividee, je mets mes locals()/globals() dans ma poche pour cette fois). L'utilisation d'une méthode permet de modifier l'objet lui même. C'est évident pour les autres objets (b=[]) mais moins pour les variables.
= ne crée pas forcément une nouvelle variable; elle ne la crée que si elle n'existait pas avant. Si la variable existait déjà, c'est sa valeur qui est écrasée, pas la variable elle-même.
Il ne faut pas oublier que id() retourne l'identifiant de l'objet référencé par la variable, pas de la variable elle-même.

Attention ton exemple est trompeur: a.__add__(10) ne modifie pas a, mais retourne un nouvel entier qui vaut 11. a vaut toujours 1 après l'appel, c'est pourquoi id(a) n'a pas changé. Les entiers sont immutables; aucune méthode ne modifie un entier "en place" (c'est ce qui permet l'optimisation dont j'ai parlé plus haut, et cela masque en quelque sorte au programmeur le fait que les entiers sont alloués sur le tas).

16/05/2010, 17h25
PauseKawa

Bonjour,

J'adore ce forum. Merci dividee.

@+