Discussion :

[Zavonen]

Bonjour à tous !
Voici mon problème:
J'ai une liste d'objets créés en grand nombre par un constructeur appelé dans une boucle.
Je peux accéder à ces objets par leur indice dans la liste.
A côté de cela j'ai une liste de chaines (étiquettes) en correspondance avec la liste des objets.
Je voudrais pouvoir nommer dans une boucle mes objets avec les étiquettes de la liste de chaines.
Exemple ma liste d'objets:
L1=[ ... , ...., ...., ... ]
Ma liste d'étiquettes:
L2=['un','deux', ......]
Au lieu de référencer le premier objet par L1[0] j'aimerais le référencer par 'un', un peu comme si j'avais instancié par
un= Truc( , ..) si ma classe est Truc.
Je n'ai rien trouvé dans la doc officielle.
Quelqu'un sait faire ?

[eyquem]

Il n'est pas expliqué dans la question ce que signifie "en correspondance".
En supposant que la correspondance d'un élément A de L1 avec un élément B de L2 signifie que L1.index(A) = L2.index(B) ( A et B ont le même rang dans leur liste respective), alors j'aurais tendance à proposer

Code :

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

d = dict(zip(L2,L1))

qui permet de remplacer

Code :

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

1
2
3
for el2 in L2:
    i = L2.index(el2)
    el1 = L1[i]

par

Code :

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

1
2
for el2 in L2:
    el1 = d[el2]

L'ennui est évidemment que d n'est pas ordonné selon L2 alors que L1 est ordonné selon [0,1,2,3,4,5...].
Ce qui m'a ainsi d'abord gêné, c'est que pour conserver la connaissance de l'ordre contenue dans la nature de liste pour L1, il faut garder à portée de main la liste L2 qui tient lieu d'indices.
Mais en réfléchissant, finalement, la nécessité de recourir à xrange(y) quand on veut parcourir L1 n'est pas différente de la nécessité de recourir à L2 quand on veut parcourir d.

La vraie différence est en réalité qu'on ne peut pas écrire
d.index(el1) alors qu'on peut écrire L1.index(el1)
ce qui signifie qu'on ne peut pas remonter d'un élément el1 de d à un imaginaire rang appartenant à L2 de cet élément dans d en faisant d.index(el1).

Je ne sais pas si ma réponse est bien en correspondance avec la question mais j'ai l'impression que celle-ci revient à chercher un dictionnaire ordonné. Or, pour autant que je sache, cela n'existe encore pas dans Python.

[clic4]

Salut !

J'utiliserais tout simplement un dictionnaire, en partant du principe qu'il y a autant d'éléments dans chaque liste et que leurs indices correspondes:

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
# -*- coding: latin-1 -*-
 
class Truc:
        # Un objet quelconque...
	def __init__(self, machin):
		self.machin = machin
# Les deux listes contenant les objets et leurs étiquettes
L1 = [Truc('truc'), Truc('bidule'), Truc('chose')]
L2 = ['Ga', 'Bu', 'Zo']
 
# Dictionnaire pour associer les objets et leurs étiquettes
dico = {}
for i in range(len(L1)):
 
	dico[ L2[i] ] = L1[i]
 
# Afficher le résultat	
for e in dico:
	print e + ": " + str(dico[e])

[Zavonen]

Merci pour vos réponses, mais ce n'est pas exactement ce que je veux.
Si je reprends le code de clic4, et que j'écris par exemple:
Ga ou bien [Ga]. Je me retrouve avec:

Code :

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

1
2
3
4
Traceback (most recent call last):
  File "/home/gilles/sources_python/etiqettes.py", line 21, in <module>
    L=[Ga]
NameError: name 'Ga' is not defined

Je voudrais pouvoir utiliser Ga à la place de L1[0]. Donc en fait faire comme si j'avais déclaré: Ga=Truc('truc')

[pacificator]

en utilisant globals?

Code :

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

1
2
3
4
5
6
7
>>> liste1 = range(1, 6)
>>> liste2 = ['un', 'deux', 'trois', 'quatre', 'cinq']
>>> globals().update(zip(liste2, liste1))
>>> un
1
>>> deux
2

[Zavonen]

en utilisant globals?

YES !!!!
Merci pour ce coup de baguette magique ! Cela résout exactement mon problème.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
# -*- coding: latin-1 -*-
 
class Truc:
        # Un objet quelconque...
	def __init__(self, machin):
		self.machin = machin
# Les deux listes contenant les objets et leurs étiquettes
L1 = [Truc('truc'), Truc('bidule'), Truc('chose')]
L2 = ['Ga', 'Bu', 'Zo']
 
globals().update(zip(L2,L1))
 
print Ga

[eyquem]

Je ne suis en rien étonné que m'a proposition ne soit pas la bonne solution. Je me doutais bien que ça allait être comme ça, parce que je sais très bien que je suis encore novice en Python.
Mais c'est seulement avec la solution de pacificator que je m'aperçois que je n'avais même pas compris le problème, et qu'au delà de ce problème je n'avais pas encore bien saisi certaines notions fondamentales.

Mais je trouve qu'aussi bien la réponse de pacificator que la question de Zavonen, de par la façon dont elles sont rédigées, recouvrent d'un voile tamisant les intéressantes choses à en tirer, alors même qu'elles sont fort subtiles et intéressantes. Enfin, moi je trouve que le problème est subtil et que le décortiquer est intéressant.... C'est parce que je suis novice.....

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

Tout d'abord la réponse de pacificator:

Code :

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

globals().update(zip(liste2, liste1))

ce n'est rien d'autre que

Code :

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

1
2
3
dico = dict(zip(liste2,liste1))
for u in dico:
    globals()[u] = dico[d]

c'est à dire qu'il s'agit en fait de faire rentrer dans le dictionnaire globals() de nouveaux items u:dico[u] qui n'y sont pas.
En allant au plus simple, en se passant même de tout dictionnaire et de toute boucle, cela se réduit à

Code :

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

1
2
3
4
5
6
7
8
9
10
a = 'soleil'
diametre = 1391000
print globals()
globals()['annee'] = 2009
globals()['zwi':'paf']
print
print globals()
 
print
print annee

qui affiche

{'a': 'soleil', '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'C:\\Python25\\Lib\\idlelib\\idle.pyw', 'idlelib': <module 'idlelib' from 'C:\Python25\lib\idlelib\__init__.pyc'>, 'diametre': 1391000, '__name__': '__main__', '__doc__': None}

{'a': 'soleil', 'zwi': 'paf', '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'C:\\Python25\\Lib\\idlelib\\idle.pyw', 'idlelib': <module 'idlelib' from 'C:\Python25\lib\idlelib\__init__.pyc'>, 'diametre': 1391000, '__name__': '__main__', 'annee': 2009, '__doc__': None}

annee = 2009

où l'on voit que les deux items 'annee': 2009 et 'zwi':'paf' sont ajoutés à globals().

Ce que je trouve magique là dedans c'est que créer l'item 'annee':2009 dans globals() signifie qu'on crée dans le code une variable annee en lui affectant la valeur 2009.
C'est à dire que ce qui est une chaine dans globals() , 'annee', est le nom d'une variable, annee, dans le code.

Le fait que ce nom ait un fonctionnement d'étiquette et qu'on l'appelle étiquette n'a pas de rapport avec le nom: ce nom s'écrit annee dans le code et 'annee' dans globals(). "Étiquette" ne signifie pas que c'est une chaine.

Quant au nom annee, il permet dans le code d'atteindre "la valeur de la variable", c'est à dire l'objet que référence le nom de ce qu'on appelle variable. Mais le terme de variable est impropre en Python. En réalité, il y a un objet en mémoire auquel est attaché un nom comme une étiquette.
Python a des "noms"
http://www.biologeek.com/bonnes-prat...stuces-python/

Comprendre ce qu'il y a dans globals(), c'est à dire des items
'nom de variable sous forme de chaine':objet que référence la variable
permettait de répondre en 2 secondes à la question de Zavonen.


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

Quant à la question, il fallait être au courant de ces subtilités relatives aux variables et à globals() pour s'apercevoir qu'elle pêchait en quelques endroits:
Au lieu de
«Je voudrais pouvoir nommer dans une boucle mes objets avec les étiquettes de la liste de chaines.»
j'aurais préféré lire:
«Je voudrais pouvoir référencer dans une boucle de code mes objets avec des variables dont les noms seront issus des chaines contenues dans la liste de chaines.»
facilement traduisible en
«Je voudrais pouvoir référencer dans globals() mes objets avec des noms de variables qui seront les chaines contenues dans la liste de chaines.»
ce qui est ni plus ni moins que l'expression de la solution qu'il ne reste plus qu'à concrétiser en code.

De même à la place de
«Au lieu de référencer le premier objet par L1[0] j'aimerais le référencer par 'un'»
il aurait dû y avoir
«Au lieu de référencer le premier objet par L1[0] j'aimerais le référencer par un».

C'est entendu, je suis un bleu et je me suis polarisé sur ces phrases confusionnantes alors que j'aurais dû m'attacher à comprendre
«comme si j'avais instancié par
un= Truc( , ..) si ma classe est Truc»
que je ne comprenais pas.
Mais je remarque qu'en général, les questions posées dans le forum gagneraient à être un peu peaufinées.

C'est pour ça que je trouve que la réponse de pacificator est d'autant plus remarquable qu'il n'a pas seulement réussi à trouver la bonne réponse mais surtout à comprendre la vraie question.
pacificator, il est fort.
Ceci dit, pour arriver à se poser la question, il doit falloir être fort aussi. Et la mettre sur le tapis est très très instructif.
Mais bon, «Ce qu'on trouve est plus important que ce qu'on cherche.» , je ne suis pas tellement d'accord avec ça.


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

Pour ce qui est de mon allusion à un dictionnaire ordonné, je crois que c'est une allusion sans rapport avec le problème.

[dividee]

Joli monologue d'eyquem, comme d'habitude
Petite énigme pour eyquem
Peux-tu prédire ce que va afficher le code suivant, et l'expliquer ?

Code :

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

1
2
3
4
5
6
7
8
def f():
  globals()["var"] = 3
  print var
  var = 2
 
var = 35
f()
print var

Au passage, c'est bien de corriger les questions des gens, mais c'est relativement rare les questions précises et bien posées, car cela nécessite une bonne compréhension du sujet, et si qq'un est capable de poser la question de façon précise, il a bien souvent déjà fait une bonne partie du chemin pour trouver la réponse. Les questions sont donc le plus souvent imprécises, et il faut faire avec.

[eyquem]

Salut dividee,

Il serait trop long et peut être mal interprété que je fasse écho à ton commentaire sur la façon dont sont posées les questions. Dans la gamme télescopique des longueurs de "réponses" que je pourrais faire, je choisis donc la minimale: je suis globalement d'accord avec toi et je préfère éviter un monologue sur des points localisés.

-------

Concernant la petite énigme que tu m'as exposée, j'ai joué ce qui me semble être le jeu que tu proposes: prédire le résultat sans faire tourner le code.
Je pense (je suis même quasi certain) que le résultat sera le suivant:

3
3

L'exécution du code faisant ceci:

* var = 35
crée un variable affectée de la valeur 35.
La création de cette variable consiste en la création de l'item "var":35 dans le dictionnaire globals() et la possibilité d'appeler la valeur de cette variable au moyen du nom var dans le code.

* dans f():
~ globals()["var"] = 3
je vais supposer que l'utilisation de globals() au sein d'une fonction a le même effet que l'utilisation de global c'est à dire que son action ne s'éteint pas avec la sortie de la fonction. C'est le seul point dont je ne suis pas entièrement sûr parce que je n'avais pas jusqu'à présent pensé à le vérifier. Et comme je ne fais pas tourner le code....
Donc d'après moi l'instruction
globals()["var"] = 3
remplace la valeur 35 de la variable globale var, qui "se trouve à l'extérieur" de f(), par la valeur 3. Ce changement est destiné à perdurer après la sortie de f().
~ print var
affiche 3
~ var = 2
Ça parait bizarre, mais cette instruction crée une variable locale qui n'a rien à voir avec la variable extérieure var. Cette impression de bizarre est la même que celle attachée à global. En effet, si on voulait dire au programme qu'on veut affecter la valeur 2 à la variable extérieure var, on écrirait

Code :

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

1
2
global var
var = 2

Je réalise qu'écrire

Code :

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

1
2
3
4
global V
V = valeur
#est équivalent à 
globals()["V"] = valeur

Il faudra que je le vérifie.
Il est donc créée une variable locale var à laquelle est affectée la valeur 2 mais ça n'a aucune importance puisqu'il n'est rien fait de cette variable et de cette valeur et qu'elles meurent quand le programme sort de f().

* print var
après sortie de f() , cette instruction affiche la valeur 3 de la variable globale var, qui a pris la place de la valeur initiale 35 dans f().


Je dirais que la référence à globals() ou global au sein d'une fonction permet le dialogue entre une fonction et son extérieur tandis que la déclaration simple de variable au sein d'une fonction sans cette référence cantonne la fonction dans un monologue.

[eyquem]

Euh...... un doute m'est venu...

Si globals()["var"] = 3 fait de var une variable globale au sein de f() , alors il n'y a aucune raison que l'instruction var = 2 y change quelque chose car une variable ne peut pas être locale et globale en même temps.
Auquel cas l'instruction var = 2 donne bien la valeur 2 à la variable globale var, il s'en suit que var en sortie de f() est égale à 2 et le résultat du code entier est

3
2

Je ne sais pas comment je suis allé me perdre dans l'idée que var=2 définissait une variable locale
dans f() avec le même nom qu'une variable déjà déclarée globale.
Peut être est-ce parce que j'ai absolument voulu trouver un truc particulier dans ce qui était annoncé comme une énigme. Je vais peut êre encore me planter en écrivant ceci, mais je ne vois pas où il y a difficulté dans ton code, dividee. S'il y en a une, ce doit être vraiment retors.

J'ai vérifié au passage dans la définition de globals:
«This is always the dictionary of the current module (inside a function or method, this is the module where it is defined, not the module from which it is called).»
Ici il n'y a qu'un module, c'est le code principal et je me suis autorisé un test avec le code suivant

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
def f():
    a = 12
    print 'a =',a
    x= 34
    print
    print globals()
 
def g(p):
    z = p**2.1
    print 'fonction g sur',p,':  ',z+3
 
x,y = 9,12
g(x)
print '\nx avant f() =',x
f()
print '\nx apres f() =',x

Dans le globals() appelé au sein de f(), il y a
'g': <function g at 0x00FAC770>
'x': 9
'y': 12
Ce globals() recense donc bien des instances relatives à l'extérieur de la fonction f().
Donc à mon avis globals()["var"] = 3 change bien la valeur de la variable var à l'extérieur de f().
Si c'est bien ainsi, le résultat de ton code est

3
2

Je me plante encore, là ?

[dividee]

Salut eyquem,

Ta première réponse était plus proche, var=2 crée bien une variable locale dans f. globals()["var"] = 3 modifie bien sur la variable globale, mais n'a pas l'effet d'un global var.
As-tu essayé d'exécuter le code ? Il y a bien un piège

[eyquem]

Salut dividee,

Oui, j'ai lancé le code tard cette nuit.
J'attendais un retour sur ce que j'avais écrit pour continuer à réfléchir au problème avec de nouveaux éléments, comme ceux que tu as écrit tôt cette nuit. J'aurais bien aimé voir si je serais parvenu à la bonne réponse avec ces éléments. Parce que malgré la crâne et néamoins artificielle assurance que j'ai osé exprimer dans ma première réponse, je ne croyais pas tellement, ni après celle-ci, ni après la seconde réponse, que je pouvais vraiment avoir trouvé juste. Je me disais que si tu avais posé cela comme énigme, c'est qu'il devait bien y avoir anguille sous roche.

Mais parvenu à un point de blocage dans ce qui n'était rien d'autre qu'un nano-système de croyances que je m'étais forgé moi-même au cours de mes réflexions divagantes, et ne voyant donc plus ce que je pouvais faire comme tests sans faire tourner le code lui-même, n'y tenant plus, je l'ai essayé.

Et là, bing.
L'affichage résultant ne m'a pas tout à fait étonné: j'avais envisagé cette hypothèse. Mais parmi mes croyances construites, il y avait celle que tu ne pouvais pas faire un coup pareil et j'avais écarté cette hypothèse. Je m'étais même persuadé que tu avais employé le mot "résultat" dans ta question, ce qui pour moi signifierait fortement qu'il Y A un résultat; or tu ne demandes que ce que va "afficher" l'exécution du code. Auto-persuasion....

Je ne dirais pas qu'il y a un piège dans ce code. À l'origine d'un piège, il y a une intention et je ne crois pas que Guido ait élaboré son langage en le truffant de quelques pièges pour s'amuser.
Mon impression est simplement que le fonctionnement de globals() et global est encore plus sophistiqué qu'il n'y parait au premier abord.
Ton intéressante énigme permet de réaliser que cette sophistication peut aller jusqu'au byzantinisme tant qu'on n'en a pas compris les plus poussées subtilités.

Bon, alors, après avoir échoué à prédire ce que donne l'exécution de ton code, j'ai fait quelques tests, je suis parvenu à démanteler son byzantinisme et je crois avoir trouvé l'explication du comportement de ton code, ce qui était la seconde mais non secondaire partie de ton défi.

Exposer cette explication et les prolongements qu'elle me suscite me demanderait un temps que je n'ai pas présentement. Et on va trouver ce monologue déjà trop long pour que j'ose allonger la sauce.
Je suppose que de toutes façons, tu connais cette explication, par conséquent je préfère poser les trois questions suivantes:

- comment en es tu arrivé, dividee, à pouvoir poser ton énigme-question ?
est-ce un cas pratique sur lequel tu es tombé un jour ?
est-ce en cherchant à résoudre certains comportements étranges de l'appel de variable au sein d'une fonction qui t'a conduit à cette compréhension poussée ?
ou est-ce la compréhension préalable de l'ensemble du fonctionnement de globals() et global qui t'a permis de concevoir ce problème en forme de devinette ?

- as-tu des références de documents dans lesquels on trouve des explications suffisamment poussées pour comprendre globals() et global dans toute leur étendue ?

- plus généralement, j'aimerais savoir
s'il y a des forumeurs qui ont réussi à prédire l'affichage demandé par dividee,
et s'il y en a qui en ont compris l'explication