Attention, erreurs de syntaxe ({...} plutôt que (...)). Et dict est un mot réservé... De plus, si vous envisagez un truc un peu général, vous ne deviez pas vous limiter pour les tests à des valeurs string:
dico = {'id1':'name1', 'id2':'name2','idn':lambda x: x +1, 'idnum':1.2}
id1 = 'name1' id2 = 'name2' ... idn = 'namen'
--------
for k,v in dict: k = v ne marche pas évidemment
Evidemment ;-)
Il faut parcourir la liste des paires (key, value), c'est à dire dict.items(). Ensuite il faut fabriquer l'instruction d'affectation, à partir de exec(). Avec éventuellement une prise en compte des risques potentiels selon l'origine des données.
dico = {'id1':'name1', 'id2':'name2','idn':lambda x: x +1, 'idnum':1.2}
for cle, valeur in dico.items(): exec(cle + ' = valeur')
print idnum, type(idnum) print idn, type(idn) print id1, type(id1) print idn(12) for elem in locals(): print elem print locals()
On fait comment pour faire cela?
Si vos affectations peuvent être globales:
globals().update(dico)
-- Pierre Maurette
Laurent FRANCOIS, le 04/07/2008 a écrit :
bonjour,
Je cherche a faire des affectations a partir d'un iterateur list ou
dictionnaire:
Attention, erreurs de syntaxe ({...} plutôt que (...)). Et dict est un
mot réservé...
De plus, si vous envisagez un truc un peu général, vous ne deviez pas
vous limiter pour les tests à des valeurs string:
dico = {'id1':'name1', 'id2':'name2','idn':lambda x: x +1, 'idnum':1.2}
id1 = 'name1'
id2 = 'name2'
...
idn = 'namen'
--------
for k,v in dict:
k = v
ne marche pas évidemment
Evidemment ;-)
Il faut parcourir la liste des paires (key, value), c'est à dire
dict.items().
Ensuite il faut fabriquer l'instruction d'affectation, à partir de
exec(). Avec éventuellement une prise en compte des risques potentiels
selon l'origine des données.
dico = {'id1':'name1', 'id2':'name2','idn':lambda x: x +1, 'idnum':1.2}
for cle, valeur in dico.items():
exec(cle + ' = valeur')
print idnum, type(idnum)
print idn, type(idn)
print id1, type(id1)
print idn(12)
for elem in locals():
print elem
print locals()
Attention, erreurs de syntaxe ({...} plutôt que (...)). Et dict est un mot réservé... De plus, si vous envisagez un truc un peu général, vous ne deviez pas vous limiter pour les tests à des valeurs string:
dico = {'id1':'name1', 'id2':'name2','idn':lambda x: x +1, 'idnum':1.2}
id1 = 'name1' id2 = 'name2' ... idn = 'namen'
--------
for k,v in dict: k = v ne marche pas évidemment
Evidemment ;-)
Il faut parcourir la liste des paires (key, value), c'est à dire dict.items(). Ensuite il faut fabriquer l'instruction d'affectation, à partir de exec(). Avec éventuellement une prise en compte des risques potentiels selon l'origine des données.
dico = {'id1':'name1', 'id2':'name2','idn':lambda x: x +1, 'idnum':1.2}
for cle, valeur in dico.items(): exec(cle + ' = valeur')
print idnum, type(idnum) print idn, type(idn) print id1, type(id1) print idn(12) for elem in locals(): print elem print locals()
On fait comment pour faire cela?
Si vos affectations peuvent être globales:
globals().update(dico)
-- Pierre Maurette
Bruno Desthuilliers
Pierre Maurette a écrit :
Laurent FRANCOIS, le 04/07/2008 a écrit :
bonjour,
Je cherche a faire des affectations a partir d'un iterateur list ou dictionnaire:
Par contre, il est vrai que l'utiliser comme identifiant est une mauvaise idée puisque ça masque le type builtin du même nom dans l'espace de nommage en cours...
Pierre Maurette a écrit :
Laurent FRANCOIS, le 04/07/2008 a écrit :
bonjour,
Je cherche a faire des affectations a partir d'un iterateur list ou
dictionnaire:
Par contre, il est vrai que l'utiliser comme identifiant est une
mauvaise idée puisque ça masque le type builtin du même nom dans
l'espace de nommage en cours...
Par contre, il est vrai que l'utiliser comme identifiant est une mauvaise idée puisque ça masque le type builtin du même nom dans l'espace de nommage en cours...
Bruno Desthuilliers
Laurent FRANCOIS a écrit :
bonjour,
Je cherche a faire des affectations a partir d'un iterateur list ou dictionnaire:
D'autres ont déjà répondu sur le "comment". Par contre, aucun ne pose la question du "pourquoi". Si tu connais déjà les identifiants que tu va trouver, tu peux faire les affectations directement, ie:
id1 = dict['id1'] id2 = dict['id2'] # etc
Sinon, je ne vois pas à quoi ça va te servir de créer les identifiants dans l'espace de nommage en cours.
Laurent FRANCOIS a écrit :
bonjour,
Je cherche a faire des affectations a partir d'un iterateur list ou
dictionnaire:
D'autres ont déjà répondu sur le "comment". Par contre, aucun ne pose la
question du "pourquoi". Si tu connais déjà les identifiants que tu va
trouver, tu peux faire les affectations directement, ie:
id1 = dict['id1']
id2 = dict['id2']
# etc
Sinon, je ne vois pas à quoi ça va te servir de créer les identifiants
dans l'espace de nommage en cours.
D'autres ont déjà répondu sur le "comment". Par contre, aucun ne pose la question du "pourquoi". Si tu connais déjà les identifiants que tu va trouver, tu peux faire les affectations directement, ie:
id1 = dict['id1'] id2 = dict['id2'] # etc
Sinon, je ne vois pas à quoi ça va te servir de créer les identifiants dans l'espace de nommage en cours.
Pierre Maurette
Bruno Desthuilliers, le 07/07/2008 a écrit :
Pierre Maurette a écrit :
Laurent FRANCOIS, le 04/07/2008 a écrit :
bonjour,
Je cherche a faire des affectations a partir d'un iterateur list ou dictionnaire:
Par contre, il est vrai que l'utiliser comme identifiant est une mauvaise idée puisque ça masque le type builtin du même nom dans l'espace de nommage en cours...
Merci. J'ai effectivement utilisé abusivement le terme "mot réservé", réservé (!!) à une toute petite liste de "keywords" dans le manuel. Je me comprenais, mais ce n'est pas le but ultime quand on intervient sur usenet ;-)
Je savais bien que dict était "utilisable", comme keys et values, mais je préfère éviter. J'utilise souvent un des rares avantages à parler une langue marginale presque morte - le français - c'est à dire pouvoir étendre le choix des identifiants. dico, cles, valeurs, etc. Il m'arrivait même de ne pas vouloir utiliser key et value, et je pense que j'avais tort, qu'il est plus productif d'utiliser systématiquement les mêmes identifants bien parlants dans des contextes très localisés comme une fontionnette.
<MODE papoting> Le choix de règles de nommage a plusieurs buts. Aider à la compréhension du code, permettre des prétraitements et des analyses du code, etc. Mais il y en a un qui est rarement cité, et qui pour moi arrive pratiquement en tête: libérer par l'automatisme l'esprit du programmeur qui a mieux à faire à chaque fois qu'il faut créer un identifiant. Et je suis assez emmerdé en Python, j'avais utilisé un document plus ou moins officiel <URL:http://www.python.org/dev/peps/pep-0008/> pour élaborer mes règles de style. Et maintenant je me trouve en contradiction semble-t-il avec pylint. Je ne me suis pas encore vraiment penché sur le problème, mais pour l'instant c'est un vaste bordel. Je crois que je me suis un peu trop compliqué la vie... </MODE papoting>
-- Pierre Maurette
Bruno Desthuilliers, le 07/07/2008 a écrit :
Pierre Maurette a écrit :
Laurent FRANCOIS, le 04/07/2008 a écrit :
bonjour,
Je cherche a faire des affectations a partir d'un iterateur list ou
dictionnaire:
Par contre, il est vrai que l'utiliser comme identifiant est une mauvaise
idée puisque ça masque le type builtin du même nom dans l'espace de nommage
en cours...
Merci. J'ai effectivement utilisé abusivement le terme "mot réservé",
réservé (!!) à une toute petite liste de "keywords" dans le manuel. Je
me comprenais, mais ce n'est pas le but ultime quand on intervient sur
usenet ;-)
Je savais bien que dict était "utilisable", comme keys et values, mais
je préfère éviter. J'utilise souvent un des rares avantages à parler
une langue marginale presque morte - le français - c'est à dire pouvoir
étendre le choix des identifiants. dico, cles, valeurs, etc. Il
m'arrivait même de ne pas vouloir utiliser key et value, et je pense
que j'avais tort, qu'il est plus productif d'utiliser systématiquement
les mêmes identifants bien parlants dans des contextes très localisés
comme une fontionnette.
<MODE papoting>
Le choix de règles de nommage a plusieurs buts. Aider à la
compréhension du code, permettre des prétraitements et des analyses du
code, etc. Mais il y en a un qui est rarement cité, et qui pour moi
arrive pratiquement en tête: libérer par l'automatisme l'esprit du
programmeur qui a mieux à faire à chaque fois qu'il faut créer un
identifiant. Et je suis assez emmerdé en Python, j'avais utilisé un
document plus ou moins officiel
<URL:http://www.python.org/dev/peps/pep-0008/> pour élaborer mes règles
de style. Et maintenant je me trouve en contradiction semble-t-il avec
pylint. Je ne me suis pas encore vraiment penché sur le problème, mais
pour l'instant c'est un vaste bordel. Je crois que je me suis un peu
trop compliqué la vie...
</MODE papoting>
Par contre, il est vrai que l'utiliser comme identifiant est une mauvaise idée puisque ça masque le type builtin du même nom dans l'espace de nommage en cours...
Merci. J'ai effectivement utilisé abusivement le terme "mot réservé", réservé (!!) à une toute petite liste de "keywords" dans le manuel. Je me comprenais, mais ce n'est pas le but ultime quand on intervient sur usenet ;-)
Je savais bien que dict était "utilisable", comme keys et values, mais je préfère éviter. J'utilise souvent un des rares avantages à parler une langue marginale presque morte - le français - c'est à dire pouvoir étendre le choix des identifiants. dico, cles, valeurs, etc. Il m'arrivait même de ne pas vouloir utiliser key et value, et je pense que j'avais tort, qu'il est plus productif d'utiliser systématiquement les mêmes identifants bien parlants dans des contextes très localisés comme une fontionnette.
<MODE papoting> Le choix de règles de nommage a plusieurs buts. Aider à la compréhension du code, permettre des prétraitements et des analyses du code, etc. Mais il y en a un qui est rarement cité, et qui pour moi arrive pratiquement en tête: libérer par l'automatisme l'esprit du programmeur qui a mieux à faire à chaque fois qu'il faut créer un identifiant. Et je suis assez emmerdé en Python, j'avais utilisé un document plus ou moins officiel <URL:http://www.python.org/dev/peps/pep-0008/> pour élaborer mes règles de style. Et maintenant je me trouve en contradiction semble-t-il avec pylint. Je ne me suis pas encore vraiment penché sur le problème, mais pour l'instant c'est un vaste bordel. Je crois que je me suis un peu trop compliqué la vie... </MODE papoting>
-- Pierre Maurette
Laurent FRANCOIS
> D'autres ont déjà répondu sur le "comment". Par contre, aucun ne pose la question du "pourquoi". Si tu connais déjà les identifiants que tu va trouver, tu peux faire les affectations directement, ie:
id1 = dict['id1'] id2 = dict['id2'] # etc
Sinon, je ne vois pas à quoi ça va te servir de créer les identifiants dans l'espace de nommage en cours.
Je débute avec Python. Les espaces de nommage j'ai du mal. Je sens bien que c'est important.
Sur la question du pourquoi: mon idée est qu'il me parait plus simple de modifier une liste ou un dictionnaire que de taper "directement". Non? bon je sais pas.
> D'autres ont déjà répondu sur le "comment". Par contre, aucun ne pose la
question du "pourquoi". Si tu connais déjà les identifiants que tu va
trouver, tu peux faire les affectations directement, ie:
id1 = dict['id1']
id2 = dict['id2']
# etc
Sinon, je ne vois pas à quoi ça va te servir de créer les identifiants
dans l'espace de nommage en cours.
Je débute avec Python. Les espaces de nommage j'ai du mal. Je sens bien
que c'est important.
Sur la question du pourquoi: mon idée est qu'il me parait plus simple de
modifier une liste ou un dictionnaire que de taper "directement". Non?
bon je sais pas.
> D'autres ont déjà répondu sur le "comment". Par contre, aucun ne pose la question du "pourquoi". Si tu connais déjà les identifiants que tu va trouver, tu peux faire les affectations directement, ie:
id1 = dict['id1'] id2 = dict['id2'] # etc
Sinon, je ne vois pas à quoi ça va te servir de créer les identifiants dans l'espace de nommage en cours.
Je débute avec Python. Les espaces de nommage j'ai du mal. Je sens bien que c'est important.
Sur la question du pourquoi: mon idée est qu'il me parait plus simple de modifier une liste ou un dictionnaire que de taper "directement". Non? bon je sais pas.
bruno.desthuilliers
On 12 juil, 07:13, Laurent FRANCOIS wrote:
> D'autres ont déjà répondu sur le "comment". Par contre, aucun ne pose la > question du "pourquoi". Si tu connais déjà les identifiants que tu va > trouver, tu peux faire les affectations directement, ie:
> id1 = dict['id1'] > id2 = dict['id2'] > # etc
> Sinon, je ne vois pas à quoi ça va te servir de créer les identif iants > dans l'espace de nommage en cours.
Je débute avec Python. Les espaces de nommage j'ai du mal. Je sens bien que c'est important.
C'est un euphémisme.
Sur la question du pourquoi: mon idée est qu'il me parait plus simple d e modifier une liste ou un dictionnaire que de taper "directement". Non?
Tu veux dire que tu trouves ceci:
d = {'nom':'valeur'} exec "%(nom)s = '%(valeur)s'" % d
plus simple que ceci:
nom = 'valeur'
???
On 12 juil, 07:13, Laurent FRANCOIS <lau.franc...@worldonline.fr>
wrote:
> D'autres ont déjà répondu sur le "comment". Par contre, aucun ne pose la
> question du "pourquoi". Si tu connais déjà les identifiants que tu va
> trouver, tu peux faire les affectations directement, ie:
> id1 = dict['id1']
> id2 = dict['id2']
> # etc
> Sinon, je ne vois pas à quoi ça va te servir de créer les identif iants
> dans l'espace de nommage en cours.
Je débute avec Python. Les espaces de nommage j'ai du mal. Je sens bien
que c'est important.
C'est un euphémisme.
Sur la question du pourquoi: mon idée est qu'il me parait plus simple d e
modifier une liste ou un dictionnaire que de taper "directement". Non?
Tu veux dire que tu trouves ceci:
d = {'nom':'valeur'}
exec "%(nom)s = '%(valeur)s'" % d
> D'autres ont déjà répondu sur le "comment". Par contre, aucun ne pose la > question du "pourquoi". Si tu connais déjà les identifiants que tu va > trouver, tu peux faire les affectations directement, ie:
> id1 = dict['id1'] > id2 = dict['id2'] > # etc
> Sinon, je ne vois pas à quoi ça va te servir de créer les identif iants > dans l'espace de nommage en cours.
Je débute avec Python. Les espaces de nommage j'ai du mal. Je sens bien que c'est important.
C'est un euphémisme.
Sur la question du pourquoi: mon idée est qu'il me parait plus simple d e modifier une liste ou un dictionnaire que de taper "directement". Non?
Tu veux dire que tu trouves ceci:
d = {'nom':'valeur'} exec "%(nom)s = '%(valeur)s'" % d
plus simple que ceci:
nom = 'valeur'
???
Laurent FRANCOIS
> Tu veux dire que tu trouves ceci:
d = {'nom':'valeur'} exec "%(nom)s = '%(valeur)s'" % d
plus simple que ceci:
nom = 'valeur'
???
Oui le jour ou tu veux passer de d = {'nom':'valeur'} à d = {'nom1':'valeur1', 'nom2':'valeur2', ...., 'nomN':'valeurN'}
Même là c'est pas interessant? Il vaut mieux coder en dur?
> Tu veux dire que tu trouves ceci:
d = {'nom':'valeur'}
exec "%(nom)s = '%(valeur)s'" % d
plus simple que ceci:
nom = 'valeur'
???
Oui le jour ou tu veux passer de
d = {'nom':'valeur'}
à
d = {'nom1':'valeur1', 'nom2':'valeur2', ...., 'nomN':'valeurN'}
Même là c'est pas interessant?
Il vaut mieux coder en dur?
> Tu veux dire que tu trouves ceci: > > d = {'nom':'valeur'} > exec "%(nom)s = '%(valeur)s'" % d > > plus simple que ceci: > > nom = 'valeur'
Oui le jour ou tu veux passer de d = {'nom':'valeur'} Ã d = {'nom1':'valeur1', 'nom2':'valeur2', ...., 'nomN':'valeurN'}
Juste pour savoir, quelles seraient les avantages de la manière dont t u proposes ?
- Jonathan
bruno.desthuilliers
On 13 juil, 05:28, Laurent FRANCOIS wrote:
> Tu veux dire que tu trouves ceci:
> d = {'nom':'valeur'} > exec "%(nom)s = '%(valeur)s'" % d
> plus simple que ceci:
> nom = 'valeur'
> ???
Oui le jour ou tu veux passer de d = {'nom':'valeur'} à d = {'nom1':'valeur1', 'nom2':'valeur2', ...., 'nomN':'valeurN'}
Même là c'est pas interessant?
Pourquoi faire ?
Il vaut mieux coder en dur?
En quoi l'un est-il plus ou moins "codé en dur" que l'autre ?
La question n'est pas de savoir s'il faut mieux utiliser un dict ou des variables dans l'espace de nommage courant - cette question n'a de sens qu'en fonction du contexte - mais à quoi ça t'avance de vouloir transformer automatiquement les paires nom-valeur d'un dict en variables (c'est à dire: des paires nom-valeur) dans l'espace de nommage courant ? Si tu connais d'avance ces variables et à quoi elles vont te servir dans le traitement en cours, autant les créer directement dans l'espace de nommage - passer par un dict et exec est une totale perte de temps. Sinon - si tu ne sais pas d'avance ce que va contenir ton dict - à quoi te sert-il d'en injecter le contenu dans l'espace de nommage en cours (à part à risquer d'écraser une autre variable dont tu a besoin par ailleurs) ?
On 13 juil, 05:28, Laurent FRANCOIS <lau.franc...@worldonline.fr>
wrote:
> Tu veux dire que tu trouves ceci:
> d = {'nom':'valeur'}
> exec "%(nom)s = '%(valeur)s'" % d
> plus simple que ceci:
> nom = 'valeur'
> ???
Oui le jour ou tu veux passer de
d = {'nom':'valeur'}
à
d = {'nom1':'valeur1', 'nom2':'valeur2', ...., 'nomN':'valeurN'}
Même là c'est pas interessant?
Pourquoi faire ?
Il vaut mieux coder en dur?
En quoi l'un est-il plus ou moins "codé en dur" que l'autre ?
La question n'est pas de savoir s'il faut mieux utiliser un dict ou
des variables dans l'espace de nommage courant - cette question n'a de
sens qu'en fonction du contexte - mais à quoi ça t'avance de vouloir
transformer automatiquement les paires nom-valeur d'un dict en
variables (c'est à dire: des paires nom-valeur) dans l'espace de
nommage courant ? Si tu connais d'avance ces variables et à quoi elles
vont te servir dans le traitement en cours, autant les créer
directement dans l'espace de nommage - passer par un dict et exec est
une totale perte de temps. Sinon - si tu ne sais pas d'avance ce que
va contenir ton dict - à quoi te sert-il d'en injecter le contenu dans
l'espace de nommage en cours (à part à risquer d'écraser une autre
variable dont tu a besoin par ailleurs) ?
> d = {'nom':'valeur'} > exec "%(nom)s = '%(valeur)s'" % d
> plus simple que ceci:
> nom = 'valeur'
> ???
Oui le jour ou tu veux passer de d = {'nom':'valeur'} à d = {'nom1':'valeur1', 'nom2':'valeur2', ...., 'nomN':'valeurN'}
Même là c'est pas interessant?
Pourquoi faire ?
Il vaut mieux coder en dur?
En quoi l'un est-il plus ou moins "codé en dur" que l'autre ?
La question n'est pas de savoir s'il faut mieux utiliser un dict ou des variables dans l'espace de nommage courant - cette question n'a de sens qu'en fonction du contexte - mais à quoi ça t'avance de vouloir transformer automatiquement les paires nom-valeur d'un dict en variables (c'est à dire: des paires nom-valeur) dans l'espace de nommage courant ? Si tu connais d'avance ces variables et à quoi elles vont te servir dans le traitement en cours, autant les créer directement dans l'espace de nommage - passer par un dict et exec est une totale perte de temps. Sinon - si tu ne sais pas d'avance ce que va contenir ton dict - à quoi te sert-il d'en injecter le contenu dans l'espace de nommage en cours (à part à risquer d'écraser une autre variable dont tu a besoin par ailleurs) ?
