Discussion :

[.:Spip:.]

Bonjour,

je cherche un moyen élégant d'écrire un bout de fonction qui est en perl :

Code :

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

@$var

où $var contiendrait par ex 'tableau'
ce qui fait qu'au final j'accède à @tableau

En python, j'ai ma variable var='tuple' et j'ai déclaré plus tôt tuple = ('a','b','c')
et je veux avoir quelque chose comme

Code :

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

1
2
3
 
for i in ????:
          ....

où j'utilise ma variable var dans les ?????


Merci d'avance.

[PauseKawa]

Bonjour,

Pour toute autre chose qu'un tuple j'aurais dit getattr...
Pour les tuples utiliser les dicos ?

Code :

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

1
2
3
4
5
6
7
8
>>> exemple = ('a','b','c')
>>> var='exemple'
>>> for i in locals()[var]:
...     print i
... 
a
b
c

Dans l'attente d'une réponse plus pro

@+

[.:Spip:.]

Merci beaucoup. En effet, ça fonctionne très bien chez moi (et ça raccourcit mon code de 60 lignes).

Je ne suis pas encore arrivé à cette partie de mon cours, il faut que je buche ça

[PauseKawa]

Hola... Ce n'est qu'une idée...

Attention à la portée

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
>>> def getvar(varname):
...     if varname in locals():
...         return locals()[varname]
...     elif varname in globals():
...         return globals()[varname]
... 
>>> exemple = ('a','b','c')
>>> var='exemple'
>>> for i in getvar(var):
...     print i
... 
a
b
c
>>> def test():
...     exemple1 = ('a','b','c')
...     var1='exemple1'
...     for i in getvar(var1):
...          print i
... 
>>> test()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in test
TypeError: 'NoneType' object is not iterable
>>>

Bon code

[eyquem]

Pausekawa, c’est bien essayé mais il y a un petit twist dans ton dernier code du message #4

Code :

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

1
2
3
def getvar(varname):
    if varname in globals():
        return globals()[varname]

donne exactement les mêmes résultat que

Code :

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

1
2
3
4
5
def getvar(varname):
    if varname in locals():
        return locals()[varname]
    if varname in globals():
        return globals()[varname]

Ce qui est visé:

La valeur de la référence varname est censément un objet de type chaîne ayant un rôle d’identifiant quelque part dans le programme:
chaîne 'exemple' dans le premier cas, chaîne 'exemple1' dans le second cas.

À partir d’une valeur chaîne de varname, il faut trouver l’objet que cette chaîne identifie.

À cette fin, il faut interroger l’espace de noms contenant varname, c’est à dire le dictionnaire dans lequel se trouve cette valeur chaîne de varname en tant que clé, car un espace de noms est un dictionnaire qui établit la correspondance entre l’identifiant d’un objet et l’objet lui-même situé en mémoire.





Explication du twist:

En écrivant if varname in locals() au sein de la fonction getvar() , tu cherches varname dans l’espace de noms de la fonction getvar() , c’est à dire la valeur chaîne de varname parmi les clés du dictionnaire locals() de la fonction getvar()

Or, de par le rôle de getvar() , l’objet dont l’identifiant est la valeur de varname ne peut d’évidence pas être congénital à la fonction getvar() : sa définition se situe au contraire dans un niveau fonctionnel quelconque extérieur à getvar().

La valeur de varname qui identifie l’objet voulu n’est donc jamais dans l’espace de noms de getvar()
==> varname in locals() sera donc toujours False

Par contre bien sûr:
def getvar(varname)
=> la valeur chaîne varname est dans les values de l’espace de noms locals() de getvar() , référencée par l’identifiant ’varname’ . Ce qui est sans doute la source de l’imbroglio.

Si ton code donne l’apparence de fonctionner une fois et pas la fois suivante, c’est de par le seul résultat de
if varname in globals():
Ce que montre ton code, c'est que globals() comme seul niveau fonctionnel exploré, c’est insuffisant dès que l’objet voulu n’est pas défini au niveau d’un module.




Le code suivant illustre tout ceci:

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
31
32
33
34
35
36
37
def getvar(varname):
    print 'globals() '+\
      '\n          '.join( repr(x) for x in globals().items()
                           if x[0] not in ('__builtins__','__package__','__name__','__doc__'))
    print'\n---- DANS FONCTION GETVAR(varname) --------------------'
    print 'parametre varname a pour valeur: ',repr(varname),'   de ',type(varname)
    print 'locals() vu dans getvar est    : ',locals()
    print '   varname in locals()           :::  varname in globals()'
    print '       ',varname in locals(),'\t\t\t :::\t  ',varname in  globals()
    print '   varname in locals().values()  :::  varname in globals().values()'
    print '       ',varname in locals().values(),'\t\t\t :::\t  ',varname in globals().values()
    print '--------------------------------------------------------\n'
 
    if varname in locals():
        print 'je passe dans if varname in locals()'
        return locals()[varname]
    elif varname in globals():
        print 'je passe dans if varname in globals()'
        return globals()[varname]
    else:
        print 'je ne passe dans rien du tout'
        return ('- rien du tout','- a iterer')
 
exemple = ('a','b','c')
var='exemple'
for i in getvar(var):
    print i
 
 
def test():
    exemple1 = ('a','b','c')
    var1='exemple1'
    print '\n\nlocals() de test()',locals()
    for i in getvar(var1):
         print i
 
test()

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
31
32
33
34
35
36
37
38
globals() ('exemple', ('a', 'b', 'c'))
          ('getvar', <function getvar at 0x010BB270>)
          ('var', 'exemple')
 
---- DANS FONCTION GETVAR(varname) --------------------
parametre varname a pour valeur:  'exemple'    de  <type 'str'>
locals() vu dans getvar est    :  {'varname': 'exemple'}
   varname in locals()           :::  varname in globals()
        False 			 :::	   True
   varname in locals().values()  :::  varname in globals().values()
        True 			 :::	   True
--------------------------------------------------------
 
je passe dans if varname in globals()
a
b
c
 
 
locals() de test {'exemple1': ('a', 'b', 'c'), 'var1': 'exemple1'}
globals() ('exemple', ('a', 'b', 'c'))
          ('i', 'c')
          ('test', <function test at 0x010BB2B0>)
          ('getvar', <function getvar at 0x010BB270>)
          ('var', 'exemple')
 
---- DANS FONCTION GETVAR(varname) --------------------
parametre varname a pour valeur:  'exemple1'    de  <type 'str'>
locals() vu dans getvar est    :  {'varname': 'exemple1'}
   varname in locals()           :::  varname in globals()
        False 			 :::	   False
   varname in locals().values()  :::  varname in globals().values()
        True 			 :::	   False
--------------------------------------------------------
 
je ne passe dans rien du tout
- rien du tout
- a iterer

C’est donc bien une question de portée, toutefois pas à examiner comme tu l’as traitée, la plus enfouie (locals() de getvar() dans lequel la valeur de varname n’est jamais ) avant le niveau global.
De plus, en n'examinant que locals() enfoui et globals() , on saute tous les niveaux fonctionnels intermédiaires entre getvar() et le niveau global de module.





Ce qu’il faudrait faire, c’est examiner tous les niveaux fonctionnels situés entre (et y compris) le niveau module ( globals() ) et la fonction englobante de getvar() ( locals() dans lequel il y a ('getvar', <function getvar at 0x010BB270>) )



Et bien, après avoir moult écumé les docs pour trouver une piste, il m’apparaît que ce ne doit être possible:

- ni d’obtenir l’espace de nom d’une fonction ( soit en descendant à partir de l’espace de noms global, soit en descendant à partir d’un espace de nom de fonction inférieur au niveau global ) sans que l’interpréteur se situe dans cette fonction

- ni de remonter d’une fonction enchassée dans une autre pour obtenir l’espace de noms local de cette fonction de niveau supérieur



Pour ce qui est d’essayer de descendre en cascade du niveau module vers les fonctions à partir de l’espace de noms global, on peut bien partir de l’espace de nom global, puisque l’interpréteur peut le consulter en appelant globals() , même d’un point interne à une fonction; mais je ne sais pas comment descendre à partir de globals().


Et pour ce qui est d’essayer de remonter d’une fonction getvar() à la fonction qui l’englobe, j’ai eu beau examiner les infos contenues dans les attributs co_freevars, co_varnames, co_cellvars, etc de l’attribut func_code , ou dans func_closure[0].cell_contents, je ne suis tombé sur aucun moyen de sortir vers l’espace de noms extérieur à une fonction pour obtenir l’espace de noms qui englobe cette fonction.


Si quelqu’un a des lumières sur ce problème, je serai très intéressé de les lire.



---------------------------------------------

La seule mesure qui puisse être prise à mon sens est d’appeler une fonction getvar() , en un point du programme où on pense avoir besoin de l’objet identifié par la valeur de varname, en lui fournissant le dictionnaire locals() existant en ce point;
en espérant que l’objet référencé par varname sera soit dans locals() existant à ce point soit dans globals()

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
def getvar(varname,dee = locals()):
    if varname in dee:
        print "j'ai trouve l'identifiant "+repr(varname)+" dans locals()"
    elif varname in globals():
        print "j'ai trouve l'identifiant "+repr(varname)+" dans globals()"
    else:
        print "je n'ai pas trouve l'identifiant  " + repr(varname)
    print
 
exemple = ('a','b','c')
var='exemple'
getvar(var,dee = locals()) 
 
def test():
    exemple1 = ('d','e','f','g')
    var1='exemple1'
    getvar(var1,dee = locals())
 
    exemple2 = ('P','Q','R')
    var2='exemple2'
    def inner():
        getvar(var2,dee = locals())
 
        getvar(var,dee = locals())      
 
    inner()
 
test()

Code :

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

1
2
3
4
5
6
7
j'ai trouve l'identifiant 'exemple' dans locals()
 
j'ai trouve l'identifiant 'exemple1' dans locals()
 
je n'ai pas trouve l'identifiant  'exemple2'
 
j'ai trouve l'identifiant 'exemple' dans globals()

[kango]

bonjour,

Et bien, après avoir moult écumé les docs pour trouver une piste, il m’apparaît que ce ne doit être possible:

- ni d’obtenir l’espace de nom d’une fonction ( soit en descendant à partir de l’espace de noms global, soit en descendant à partir d’un espace de nom de fonction inférieur au niveau global ) sans que l’interpréteur se situe dans cette fonction

- ni de remonter d’une fonction enchassée dans une autre pour obtenir l’espace de noms local de cette fonction de niveau supérieur

si, on peut tout à fait remonter la pile des appels:

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
import sys
a = 3
def getvar(varname):
    f = sys._getframe(1)
    locals = f.f_locals
    globals = f._f_globals
    if varname in locals:
        return locals[varname]
    if varname in globals:
        return gloabls[varname]
def toto():
    b = 8
    print getvar('a') # accède à la portée globale de toto
    print getvar('b') # accède à la portée locale de toto
toto()

produit comme résultat:

Code :

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

1
2
3
8

c'est faisable, mais je trouve ça moche...

il n'y a qu'une seule fois où j'ai vraiment eu besoin d'aller chercher ce type de mécanisme (pour un class advisor) et cela est implémenté dans pyProtocols (http://peak.telecommunity.com/PyProtocols.html)

[PauseKawa]

Bonjour,

J'avais bien vu le souci eyquem.
A vrais dire comme j'avais déjà testé ce genre de manipulations comme kango j'en étais arrivé aux f_locals/f_globals, soit avec sys._getframe(1) soit avec inspect (que je préfère dans ce cas).

Si je n'ai pas fais suite c'est :

1) Que je me suis dit que si l'un d'entre vous tombe sur le sujet j'allais encore avoir un 'ne pas réinventer la roue' ou quelque chose du genre.
Pour une fois c'est pour kango

2) Comment retrouver la variable dans les attributs de l'appelant à partir du frame object ?

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
# import inspect
import sys
 
def getvar(varname):
    appelant = sys._getframe(1)
    if varname in appelant.f_locals:
        print ('Variable dans le dico locals')
        return appelant.f_locals[varname]
    elif varname in appelant.f_globals:
        print ('Variable dans le dico globals')
        return appelant.f_globals[varname]
    else:
        # Et dans les attributs de l'appelant ?
        pass
 
def test():
    # Soit en fait class maclass(): ... self.exemple=
    test.exemple = ('a','b','c')
    var = 'exemple'
    for i in getvar(var):
        print i
test()

3) Quel sont vraiment les besoins de .:Spip:. ?
Pour une utilisation 'locale', ce qui semble le cas puisque Merci beaucoup. En effet, ça fonctionne très bien chez moi (et ça raccourcit mon code de 60 lignes). je trouve l'idée bizarre.
A vrais dire le et ça raccourcit mon code de 60 lignes m'inquiète.
C'est juste un exercice de style .:Spip:. ? L'utilisation d'un tuple et l'inutilité de getattr dans ce cas m'y fais penser.

Ceci dit puisque il y as du monde maintenant si vous avez la réponse pour le point 2

Bon code

[eyquem]

'ne pas réinventer la roue'

Et pourquoi le dire ? Si un besoin ne trouve qu’une seule solution, comment faire autrement ?





le code de ton 2) n’examine toujours que appelant.f_locals et appelant.f_globals







La question du besoin, et de la qualité du code qui conduit à rechercher une équivalence de @$var, est en effet une bonne question.

Sans doute que si nous voyions le code, nous aurions des choses à dire......

Ce serait d’ailleurs fort intéressant si le code est une réécriture d’un code en Perl, pour constater les différences entre ces deux langages et voir leurs conséquences sur la façon de coder.


Mais pour ma part j’ai pris la question comme un exercice stimulant sans mettre en question son bien-fondé.
Tout en étant surpris de la réduction de 60 lignes.

L'utilisation d'un tuple et l'inutilité de getattr dans ce cas m'y fais penser.

je ne comprends pas cette phrase

si vous avez la réponse pour le point 2

je ne comprends pas non plus ceci. Quel point 2 ?





PS
Je travaille sur un code récursif

[PauseKawa]

Bonsoir,

le code de ton 2) n’examine toujours que appelant.f_locals et appelant.f_globals

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
>>> import sys
>>> 
>>> def getvar(varname):
...     appelant = sys._getframe(1)
...     if varname in appelant.f_locals:
...         print ('Variable dans locals')
...         return appelant.f_locals[varname]
...     elif varname in appelant.f_globals:
...         print ('Variable dans globals')
...         return appelant.f_globals[varname]
... 
>>> exemple=('a','b','c')
>>> var='exemple'
>>> 
>>> for i in getvar(var):
...     print i
... 
Variable dans locals
a
b
c
>>> def test():
...     var1 = 'exemple'
...     for i in getvar(var1):
...          print i
...     exemple1 = ('d','e','f')
...     var2 = 'exemple1'
...     for i in getvar(var2):
...          print i
...     for i in getvar(var):
...         print i
... 
>>> test()
Variable dans globals
a
b
c
Variable dans locals
d
e
f
Variable dans globals
a
b
c
>>>

Cela fonctionne.

L'utilisation d'un tuple et l'inutilité de getattr dans ce cas m'y fais penser.

je ne comprends pas cette phrase

J'avais en premier penser passer par getattr mais les tuples n'ont pas de méthodes.
Ce qui me fais penser un exercice de style de conversion de code.

je ne comprends pas non plus ceci. Quel point 2 ?

Comment retrouver la variable dans les attributs de l'appelant à partir d'un frame object ?

En fait le sujet est bien comme je les aimes

@+

Ps:

PS
Je travaille sur un code récursif

Pas trop vite svp ou je vais devoir encore poser des rtt pour comprendre.

[kango]

Ceci dit puisque il y as du monde maintenant si vous avez la réponse pour le point 2

par exemple comme ceci:

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
import inspect
 
def getobjattr(attrname):
    stack = inspect.stack()
    callerStack = stack[1]
    callerFrame = callerStack[0]
    callerName = callerStack[3]
    callerObj = callerFrame.f_globals[callerName]
    return getattr(callerObj,attrname)
 
def toto():
    toto.example = ('a','b','c')
    print getobjattr('example')
 
toto()

retourne:

Code :

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

>>> ('a', 'b', 'c')

c'est vraiment pour répondre à ta question PauseKawa, je vois pas à quoi ça peut servir

le code de ton 2) n’examine toujours que appelant.f_locals et appelant.f_globals

je ne comprends pas non plus. Cherches tu autre chose que remonter à l'appelant et à chercher un nom dans le contexte de ce dernier Eyquem ?

[PauseKawa]

Bonsoir,

Genial, merci kango.
A force de tourner en rond j'avais oublier cela mais il me semblais bien que la réponse était dans inspect.

c'est vraiment pour répondre à ta question PauseKawa, je vois pas à quoi ça peut servir

A ceci :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
import sys
import inspect
 
def getvar(varname):
    appelant = sys._getframe(1)
    if varname in appelant.f_locals:
        print ('Variable dans locals')
        return appelant.f_locals[varname]
    elif varname in appelant.f_globals:
        print ('Variable dans globals')
        return appelant.f_globals[varname]
    else:
        print ('Variable dans les attributs')
        stack = inspect.stack()
        callerStack = stack[1]
        callerFrame = callerStack[0]
        callerName = callerStack[3]
        callerObj = callerFrame.f_globals[callerName]
        return getattr(callerObj,varname)
 
 
exemple=('a','b','c')
var='exemple'
 
for i in getvar(var):
    print i
 
def test():
    var1 = 'exemple'
    for i in getvar(var1):
         print i
    exemple1 = ('d','e','f')
    var2 = 'exemple1'
    for i in getvar(var2):
         print i
    for i in getvar(var):
        print i
    test.exemple3 = ('g','h','i')
    var3 = 'exemple3'
    for i in getvar(var3):
        print i
 
test()

@+

[eyquem]

@ kango

Tout d’abord, merci bien pour ta première réponse.

Avant elle, j’étais un peu déçu d'aboutir à l’idée que Python ne permettait pas de faire ce qu'on voulait.
J’avais vaguement pensé à la piste de remonter dans les contextes d’exécution, mais n’y connaissant rien, je me suis auto persuadé que cette piste ne devait pas être bonne, surtout après avoir déjà passé beaucoup de temps à découvrir les méandres des objets fonction que je ne connaissais pas non plus.

c'est faisable, mais je trouve ça moche...

Je ne vois pas ce que ça a de moche. Si c’est la seule façon de faire.






@ PauseKawa

2) Comment retrouver la variable dans les attributs de l'appelant à partir du frame object ?

Comprends pas. Juste dessous cette phrase dans le message #7, tu donnes la réponse. Qui marche pour le cas simple pris.
Et qui marche encore dans les cas du code dans le message #9. Sauf que les deux lignes ouges sont superflues puisqu’elles répètent les deux lignes vertes.

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
>>> exemple=('a','b','c')
>>> var='exemple'
>>> 
>>> for i in getvar(var):
...     print i
... 
Variable dans locals
a
b
c
>>> def test():
... var1 = 'exemple'
... for i in getvar(var1):
... print i
... exemple1 = ('d','e','f')
... var2 = 'exemple1'
... for i in getvar(var2):
... print i
... for i in getvar(var):
... print i

J’ai repris le code en éliminant les var , var1 , var2 qui troublent la vue sans être nécessaires.

Mais désolé, non ça ne fonctionne pas dans des cas plus complexes:

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
31
32
import sys
 
def getvar(varname):
    appelant = sys._getframe(1)
    print varname,varname in appelant.f_locals,varname in appelant.f_globals
    if varname in appelant.f_locals:
        print ('Variable dans locals')
        return appelant.f_locals[varname]
    elif varname in appelant.f_globals:
        print ('Variable dans globals')
        return appelant.f_globals[varname]
 
exemple=('a','b','c')
for i in getvar('exemple'): #1 locals de __main__  abc
    print i
 
def test():
    exemple1 = ('D','E','F')
 
    for i in getvar('exemple'): #2 globals abc
         print i
    for i in getvar('exemple1'): #3 locals de test() DEF
         print i
 
    def seconde():
        for i in getvar('exemple'): #4 globals abc
            print i
        for i in getvar('exemple1'): #5 locals superieur, de test() DEF
            print i
    seconde()
 
test()

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
exemple True True
Variable dans locals
a
b
c
exemple False True
Variable dans globals
a
b
c
exemple1 True False
Variable dans locals
D
E
F
exemple False True
Variable dans globals
a
b
c
exemple1 False False
 
Traceback (most recent call last):
  File "E:\Python\python27\jhhvgfdwed.py", line 32, in <module>
    test()
  File "E:\Python\python27\jhhvgfdwed.py", line 30, in test
    seconde()
  File "E:\Python\python27\jhhvgfdwed.py", line 28, in seconde
    for i in getvar('exemple1'): #5 locals superieur, de test() DEF
TypeError: 'NoneType' object is not iterable

C’est un cas un peu tordu je le concède, mais c’est à titre d’exercice en quelque sorte, car dans un vrai code ce serait peut être un peu inquiétant de devoir faire ceci que j’avais déjà décrit:

Ce qu’il faudrait faire, c’est examiner tous les niveaux fonctionnels situés entre (et y compris) le niveau module ( globals() ) et la fonction englobante de getvar() ( locals() dans lequel il y a ('getvar', <function getvar at 0x010BB270>) )

je ne comprends pas non plus. Cherches tu autre chose que remonter à l'appelant et à chercher un nom dans le contexte de ce dernier Eyquem ?

Oui, je cherchais donc à remonter autant de fois que nécessaire pour trouver l’objet.




C’est pourquoi je parlais de récursion, puisqu'il ne suffit pas d'examiner appelant.f_locals et appelant.f_globals.
Récursion pour remonter progressivement de sys._getframe(1) à sys._getframe(2) puis sys._getframe(3) etc....
Mais en fait une récursion ne va pas au mieux: faire un appel récursif getvar(varname) au sein de la fonction getvar(varname), c’est descendre un degré de plus dans l’emboîtement de fonctions; or si un tel appel devait ëtre fait, ce serait pour remonter au contraire de 1 cran dans les contexte. Donc un indice i pour écrire sys._getframe(i).f_locals qui devrait varier par saut de 2. Trop compliqué, je suis resté avec une boucle.

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import sys
 
def getvar(varname,i = 1):
    while 1:
        dee = sys._getframe(i).f_locals
        if varname in dee:
            print "objet d'identifiant "+varname+'    : ' + repr(dee[varname])
            break
        elif '__name__' in dee:
            print "Pas trouve d'objet d'identifiant " + varname
            break
        else:
            i += 1
 
 
 
exemple = ('a','b','c')
getvar('exemple')
getvar('rambo')
print
 
def test():
    exemple1 = ('d','e','f','g')
    getvar('exemple1')
    getvar('cuicui')
    getvar('exemple')
    print
 
    def inner():
        exemple2 = ('P','Q','R')
        getvar('exemple2')
        getvar('exemple1')
        getvar('omelette')
        getvar('exemple')
        print
 
        def inninn():
            exemple3 = ('w','x','y','z')
            getvar('exemple3')
            getvar('exemple2')
            getvar('exemple1')
            getvar('exemple')
            getvar('boulon')
 
        inninn()
    inner()
test()

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
objet d'identifiant exemple    : ('a', 'b', 'c')
Pas trouve d'objet d'identifiant rambo
 
objet d'identifiant exemple1    : ('d', 'e', 'f', 'g')
Pas trouve d'objet d'identifiant cuicui
objet d'identifiant exemple    : ('a', 'b', 'c')
 
objet d'identifiant exemple2    : ('P', 'Q', 'R')
objet d'identifiant exemple1    : ('d', 'e', 'f', 'g')
Pas trouve d'objet d'identifiant omelette
objet d'identifiant exemple    : ('a', 'b', 'c')
 
objet d'identifiant exemple3    : ('w', 'x', 'y', 'z')
objet d'identifiant exemple2    : ('P', 'Q', 'R')
objet d'identifiant exemple1    : ('d', 'e', 'f', 'g')
objet d'identifiant exemple    : ('a', 'b', 'c')
Pas trouve d'objet d'identifiant boulon

[kango]

2) Comment retrouver la variable dans les attributs de l'appelant à partir du frame object ?

PauseKawa veut accéder à un attribut de la fonction, pas à un nom défini dans la fonction:

Code :

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

1
2
3
def func():
    func.attribut = "je suis un attribut"
    variable = "je suis une variable"

"attribut" n'apparait pas dans le locals de la fonction alors que variable oui. c'est pour ça que j'ai écrit un petit bout de code qui passe par l'objet appelant.

ensuite:

Code :

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

1
2
3
4
5
6
7
8
def test():
    exemple1 = ('D','E','F')         
    print locals()
    def seconde():
        print globals()
    seconde() 
 
test()

montre que la fonction seconde n'"hérite" pas des noms définis dans le corps de la fonction test (le globals dans seconde n'a pas de clé exemple1).

un simple:

Code :

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

print exemple1

dans seconde lève donc un NameError.

Et donc getvar fonctionne parfaitement, elle ne rend pas accessible des variables qui ne le seraient pas de manière naturelle.

Il me semble que le sujet initial c'est d'arriver à la valeur d'une variable à partir de son nom mais pas de contourner le mécanisme naturel de Python

[fred1599]

PauseKawa veut accéder à un attribut de la fonction, pas à un nom défini dans la fonction:

Excusez moi je m'y connais moins que vous en python,mais pour accéder à un attribut de fonction, il ne faut pas créer une classe?

Un truc du style

Code :

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

1
2
instance=maclasse()
getattr(instance, mavariable)

J'espère que je dis pas trop de bourdes

[kango]

en python tout est objet, donc on peut lier un attribut à une fonction:

Code :

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

1
2
3
4
def hello():
   print "hello"
 
hello.var = "un attribut de fonction"

ici PauseKawa veut accéder à un attribut de fonction depuis un "callee", un getattr est donc insuffisant

[eyquem]

Code :

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

1
2
3
4
5
6
def test():
    exemple1 = ('D','E','F')         
    print locals()
    def seconde():
        print globals()
    seconde()

test()montre que la fonction seconde n'"hérite" pas des noms définis dans le corps de la fonction test (le globals dans seconde n'a pas de clé exemple1).

un simple:

Code :

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

print exemple1

dans seconde lève donc un NameError.

Ben , heu .......... :

Code :

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

1
2
3
4
5
6
7
8
9
10
def test():
    exemple1 = ('D','E','F')         
    print 'locals() dans test\n',locals()
    def seconde():
        print '\nlocals() dans seconde\n',locals()
        print '\nexemple1\n',exemple1
        print '\nglobals()\n',globals()
    seconde() 
 
test()

Code :

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

1
2
3
4
5
6
7
8
9
10
11
locals() dans test
{'exemple1': ('D', 'E', 'F')}
 
locals() dans seconde
{'exemple1': ('D', 'E', 'F')}
 
exemple1
('D', 'E', 'F')
 
globals()
{'__builtins__': <module '__builtin__' (built-in)>, '__package__': None, 'test': <function test at 0x010A1AB0>, '__name__': '__main__', '__doc__': None}

le globals dans seconde n'a pas de clé exemple1

D’accord. Mais ça n’est pas ce qui compte.

The execution of a function introduces a new symbol table used for the local variables of the function. More precisely, all variable assignments in a function store the value in the local symbol table; whereas variable references first look in the local symbol table, then in the local symbol tables of enclosing functions, then in the global symbol table, and finally in the table of built-in names.

http://docs.python.org/tutorial/cont...ning-functions

If a name is bound in a block, it is a local variable of that block. (...) If a variable is used in a code block but not defined there, it is a free variable.

http://docs.python.org/reference/exe...ng-and-binding

locals() ne regroupe pas seulement les références locales,
il regroupe aussi les références libres.
C’est un piège.



--------------------------------------------------

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
a = '14 juillet 1789'
b = '2 avril 748'
c = '21 janvier 1950'
 
print 'avant f  ',globals().keys()
def f(x):
    di = dict(zip(('janvier','fevrier','mars','avril','mai','juin','juillet',
                   'aout','septembre','ocobre','novembre','decembre'),
                  (1,2,3,4,5,6,7,8,9,10,11,12)))
 
    date1 = '4 aout 1789'
    date2 = '16 juin 1969'
    date3 = '14 mai 1610'
    L = [date1,date2,date3]
    L.extend(x)
 
    ch = '  '.join( date.replace(' '+date.split()[1]+' ','/'+str(di[date.split()[1]])+'/')
                    for date in L)
    print '  '+ch
 
    print 'avant g  ',globals().keys()
    def g(y):
        lin = [ int(date.split()[0]) for date in y]
        s = sum(lin)
 
        print 'avant h  ',globals().keys()
        def h(z):
            what =  z%12
            for k,v in di.iteritems():
                if v==z%12:
                    print '  somme bizarre =',z,' --> ',what,' -->  mois deduit =',k
                    what = 'trouve'
 
            print 'fin h()  ',globals().keys()
 
        print 'avant h()',globals().keys()
        h(s)
        print 'fin g()  ',globals().keys()
 
    print 'avant g()',globals().keys()
    g(L)
    print 'fin f()  ',globals().keys()
 
print 'avant f()',globals().keys()
 
f([a,b,c])
 
print 'fin code ',globals().keys()

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
avant f   ['a', 'c', 'b', '__builtins__', '__package__', '__name__', '__doc__']
avant f() ['a', 'c', 'b', 'f', '__builtins__', '__package__', '__name__', '__doc__']
  4/8/1789  16/6/1969  14/5/1610  14/7/1789  2/4/748  21/1/1950
avant g   ['a', 'c', 'b', 'f', '__builtins__', '__package__', '__name__', '__doc__']
avant g() ['a', 'c', 'b', 'f', '__builtins__', '__package__', '__name__', '__doc__']
avant h   ['a', 'c', 'b', 'f', '__builtins__', '__package__', '__name__', '__doc__']
avant h() ['a', 'c', 'b', 'f', '__builtins__', '__package__', '__name__', '__doc__']
  somme bizarre = 71  -->  11  -->  mois deduit = novembre
fin h()   ['a', 'c', 'b', 'f', '__builtins__', '__package__', '__name__', '__doc__']
fin g()   ['a', 'c', 'b', 'f', '__builtins__', '__package__', '__name__', '__doc__']
fin f()   ['a', 'c', 'b', 'f', '__builtins__', '__package__', '__name__', '__doc__']
fin code  ['a', 'c', 'b', 'f', '__builtins__', '__package__', '__name__', '__doc__']

Ne pas faire attention à l’algorithme qui n’a aucun sens, mais à la valeur de globals() à différents points du programme.

If a name is bound in a block, it is a local variable of that block. If a name is bound at the module level, it is a global variable. (The variables of the module code block are local and global.) If a variable is used in a code block but not defined there, it is a free variable.

http://docs.python.org/reference/exe...ng-and-binding

Second piège. Et confusion commune, me semble-t-il.


Do you know what I mean ?

C'est vrai que ce n'est pas mis en relief dans les docs. À part la citation ci-dessus, je ne connais pas d'autre endroit de la doc où c'est aussi clair.



PS

Sauf erreur de ma part.

Correctifs bienvenus si je me trompe.


PPS

The execution of a function introduces a new symbol table used for the local variables of the function. More precisely, all variable assignments in a function store the value in the local symbol table;

http://docs.python.org/tutorial/cont...ning-functions

Je viens de réaliser que

- l’ensemble des références locales d’une fonction est appelé “symbol table“ dans la doc

- le dictionnaire locals() dans une fonction est l’union de toutes les tables de symboles locales, de la fonction en question et de toutes ses fonctions englobantes.



NB

J'ai décidé , en Python, d'appeler sytématiquement "références" ce que tout le monde appelle "variable" car il n'y a pas de variables au sens strict en Python.

[kango]

Ben , heu .......... :

et v'là que j'ai ressorti mes gros doigts en effet, le code fonctionne, il n'y a pas de NameError...

et la dernière citation est très claire en effet, seule les variables définies au niveau du module sont globales. cela ne s'applique donc pas aux fonctions imbriquées.

[kango]

j'ai trouvé ça:

Lorsqu’une ligne de code demande la valeur d’une variable x, Python recherche cette variable dans tous les espaces de noms disponibles dans l’ordre suivant :

1. Espace de noms local - spécifique à la fonction ou méthode de classe en cours. Si la fonction a défini une variable locale x, ou si elle a un argument x, Python l’utilise et arrête sa recherche.
2. Espace de noms global - spécifique au module en cours. Si le module a défini une variable, une fonction ou une classe nommée x, Python l’utilise et arrête sa recherche.
3. Espace de noms prédéfini - global à tous les modules. En dernière instance, Python considère que x est le nom d’une fonction ou variable du langage.

Si Python ne trouve x dans aucun de ces espaces de noms, il abandonne et déclenche une exception NameError avec le message There is no variable named 'x', que vous avez vu tout au début au chapitre 1, mais à ce moment là vous ne pouviez pas savoir tout le travail que Python fait avant de vous renvoyer cette erreur.
Important
Python 2.2 a introduit une modification légère mais importante qui affecte l’ordre de recherche dans les espaces de noms : les portées imbriquées. Dans les versions précédentes de Python, lorsque vous référenciez une variable dans une fonction imbriquée ou une fonction lambda, Python recherchait la variable dans l’espace de noms de la fonction (imbriquée ou lambda) en cours, puis dans l’espace de noms du module. Python 2.2 recherche la variable dans l’espace de noms de la fonction (imbriquée ou lambda) en cours, puis dans l’espace de noms de la fonction parente, puis dans l’espace de noms du module. Python 2.1 peut adopter l'un ou l'autre de ces comportements, par défaut il fonctionne comme Python 2.0, mais vous pouvez ajouter la ligne de code suivante au début de vos modules pour les faire fonctionner comme avec Python 2.2 :


from __future__ import nested_scopes

source: http://diveintopython.adrahon.org/ht...d_globals.html

il faut donc implémenter une récursivité comme tu le disais Eyquem

[eyquem]

J'ai décidé, en Python, d'appeler sytématiquement "références" ce que tout le monde appelle "variables" car il n'y a pas de variables au sens strict en Python.

Enfin si..... Il y a bien des variables en Python.
C'est mal dit.
Il ne faut pas que je dise les choses de cette manière sommaire.



Il faut plutôt dire:

Une variable est une portion de mémoire dont la valeur peut changer: la représentation binaire de data cantonnée dans une variable est modifiable.

En Python, les représentations binaires des data ne sont pas logées dans des variables, mais dans des objets non modifiables.



De façon courte:
en Python, les data ne sont pas dans des variables, elles sont dans des objets.