Bonjour,

en faisant joujou avec la fonction exec je découvre un rôle étrange des paramètres global et local.

Voici un bout de code qui vous éclairera sur ce qui me parait obscure :
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
28
29
30
code1 = '''
spam = lambda x : x*10
eggs = lambda x : spam( x )/2
'''
code2 = '''
print eggs( 5 )
'''
 
print 'exec( code1+code2 )'
exec( code1+code2 )
 
glo = {}
loc = {}
print '\nexec( code1+code2,glo,loc )'
try                : exec( code1+code2,glo,loc )
except Exception,e : print '####',e
 
glo = {}
loc = {}
print '\nexec( code1,glo,loc ) ; exec( code2,glo,loc )'
exec( code1,glo,loc )
try                : exec( code2,glo,loc )
except Exception,e : print '####',e
 
glo = {}
loc = {}
print '\nlast try'
exec( code1,glo,loc )
glo.update(loc)
exec( code2,glo,loc )
il affiche ça :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
exec( code1+code2 )
25
 
exec( code1+code2,glo,loc )
#### global name 'spam' is not defined
 
exec( code1,glo,loc ) ; exec( code2,glo,loc )
#### global name 'spam' is not defined
 
last try
25
Pourquoi est-ce que quand je laisse les paramètres par défaut de exec, ça marche, alors que quand je passe mes propres dictionnaires, non ?
Et pourquoi faut-il transférer le contenu de loc dans glo ?

J'ai relu le post très intéressant de tyrtamos, mais il ne répond pas (assez) à ma question.

Ce que j'aimerais, c'est pouvoir manipuler un interpréteur python avec son environnement (glo+loc) propre.
--> j'écris, en python, un compilateur pour un langage de mon cru, et je voudrais avoir un préprocesseur (un peu à la manière de celui du C) qui utilise la syntaxe python.
Mais je ne veux pas que le code "préprocessé" de mon langage puisse accéder aux variables/fonctions/classes de mon compilateur.

Merci d'avance pour vos retours éclairés !