fred a écrit :
> Bonsoir,
>
> Je vais essayer d'être clair ;-)
> Et bref.
>
> Soit un dico tout ce qu'il y a de plus banal :
>
> d = {'a': 1, 'b':2}
>
> Maintenant, supposons que a et b soient deux variables.
>
> Comment associer à la variable 'a' la "value" qui correspond
> la key "a" (en l'occurence 1) de mon superbe dico ?

def truc0(**kw):
a = kw['a']
b = kw['b']
print "a : %s" % a
print "b : %s" % b

def truc1(a=None, b=None, **kw):
print "a : %s" % a
print "b : %s" % b

def truc2(**kw):
locals().update(kw)
try:
print "a : %s" % a
print "b : %s" % b
except NameError:
print "marche pas "
print "et pourtant : locals() = ", locals()


def truc3(**kw):
for kv in kw.items():
exec "%s=%s" % kv
try:
print "a : %s" % a
print "b : %s" % b
except NameError:
print "kw : %s" % kw


if __name__ == '__main__':
d = dict(a=1, b=2, c=3)
for name, obj in globals().items():
if name.startswith('truc') and callable(obj):
print name
try:
obj(**d)
except Exception, e:
print "oops : %s" % e
print


question con: c'est quoi, le but de la manoeuvre, au juste ?

fred a écrit :
> Bruno Desthuilliers <bruno.42.desthuilliers@wtf.websiteburo.oops.com > a écrit :
>
>>Tu sais qu'il existe des packages pour ça dans la bibliothèque standard?
>
> Voui, je m'en doute.
> Mais je n'ai jamais été regarder.

Tu a tort. Et le tort tue.

Ok ---------->[]

> Et pis deuxième, j'ai tout un tas de sortes d'arguments à passer :
> "a", "a=1", "a='(2 2)'", "a='(2 2), (3 3)'"
> des trucs dans ce genre-là...
>
>
>>Mais bon, même si tu tiens à réinventer la roue...
>
> On est là pour s'amuser, non ?

Heu... Pas seulement, non. Moi j'y suis aussi pour nourrir ma famille !-)

> Et puis pour apprendre.
>
>
>>>J'ai donc construit mon dico comme ça
>>>{'mot clé': 'variable_flag'}
>>>et ensuite, je fais un
>>>if (p in dico.keys()):
>>> exec('self.'+dico[p]+' = False')
>>
>>Hem...
>>
>>Tu pouvais pas dire tout de suite qu'il s'agissait d'attributs d'un
>>objet, non ?
>
> Visiblement, non :-)))
> Je ne voyais pas la pertinence de cette info, c'est tout.

Et pourtant... Comprend bien qu'il y a en Python une différence assez
fondamentale entre un binding (ie : a = 42) et un appel de méthode
(obj.a = 4 => obj.__setattr__('a', 42)).

>>>Et ça marche du tonerre.
>>>Bon, le coup du exec ne me plaît pas des masses, ok...
>>>
>>
>>Moi non plus. Dans 99,9% des fois où j'ai utilisé un exec, c'est soit
>>que je ne connaissais pas la bonne façon de faire, soit que mon design
>>puait des pieds...
>
> D'accord avec toi.
> En l'occurence, je ne connaissais pas la bonne façon de faire
> pour ce cas précis.

D'où l'intéret des questions bien formulées !-)

Bonsoir,

Je vais essayer d'être clair ;-)
Et bref.

Soit un dico tout ce qu'il y a de plus banal :

d = {'a': 1, 'b':2}

Maintenant, supposons que a et b soient deux variables.

Comment associer à la variable 'a' la "value" qui correspond
la key "a" (en l'occurence 1) de mon superbe dico ?

Les réponses du genre

a = 1

ne sont pas admises ;-)

(je précise, il y en a des ceusses pointilleux ici ;-)))

Merci d'avance.


--
http://scipy.org/FredericPetit

Bruno Desthuilliers <bdesth.quelquechose@free.quelquepart.fr> a écrit :


> question con: c'est quoi, le but de la manoeuvre, au juste ?
réponse con : merci d'avoir posé la question.
Parce que en fait, je n'en ai pas besoin, de dico.
Et en plus, ça vous évite un post super long pour que je vous exlique
par le menu ma tambouille, alors...

Mais l'idée d'utiliser un dico m'amusait.

Merci quand même (tout court, en fait).

--
http://scipy.org/FredericPetit

fred <fredantispam@free.fr> a écrit :

> Bruno Desthuilliers <bdesth.quelquechose@free.quelquepart.fr> a écrit :
>
>
>> question con: c'est quoi, le but de la manoeuvre, au juste ?
> réponse con : merci d'avoir posé la question.
> Parce que en fait, je n'en ai pas besoin, de dico.
> Et en plus, ça vous évite un post super long pour que je vous exlique
> par le menu ma tambouille, alors...
>
> Mais l'idée d'utiliser un dico m'amusait.
Et m'amuse toujours.
Je vais donc m'en coller un quand même.
Mais pas de la façon prévue initialement.

--
« Le dico, c'est rigolo. »

fred a écrit :
> Bruno Desthuilliers <bdesth.quelquechose@free.quelquepart.fr> a écrit :
>
>
>> question con: c'est quoi, le but de la manoeuvre, au juste ?
> réponse con : merci d'avoir posé la question.
> Parce que en fait, je n'en ai pas besoin, de dico.
> Et en plus, ça vous évite un post super long pour que je vous exlique
> par le menu ma tambouille, alors...

Bin, tu fais comme tu veux, mais le but de la question était de voir si
y avait pas mieux à faire qu'un truc tordu...

> Mais l'idée d'utiliser un dico m'amusait.
>
> Merci quand même (tout court, en fait).
>

Bruno Desthuilliers <bruno.42.desthuilliers@wtf.websiteburo.oops.com > a écrit :

> fred a écrit :
>> Bruno Desthuilliers <bdesth.quelquechose@free.quelquepart.fr> a écrit :
>>
>>> question con: c'est quoi, le but de la manoeuvre, au juste ?
>> réponse con : merci d'avoir posé la question.
>> Parce que en fait, je n'en ai pas besoin, de dico.
>> Et en plus, ça vous évite un post super long pour que je vous exlique
>> par le menu ma tambouille, alors...
>
> Bin, tu fais comme tu veux, mais le but de la question était de voir
> si y avait pas mieux à faire qu'un truc tordu...
Mais justement, le fait d'écrire mon petit laïus pour expliquer la chose
m'a fait voir que c'était vraiment un truc tordu, et que donc,
de truc tordu, y en a pu.

Bon, pour résumer, je passe des arguments en ligne de commande,
des « mot-clés », qui sont associés à des variables (que j'appelle « flag
» parce que ce sont des booléens).

Le but est de détecter quels sont les mot-clés qui sont passés en ligne
de commande (auquel cas le flag est mis à True) pour pouvoir les repasser à False
par la suite parce que.

J'ai donc construit mon dico comme ça

{'mot clé': 'variable_flag'}

et ensuite, je fais un

if (p in dico.keys()):
exec('self.'+dico[p]+' = False')

Ok, d'aucuns trouveront peut-être ça tordu quand même,
mais nettement moins que mon idée initiale.
Et ça marche du tonerre.

Bon, le coup du exec ne me plaît pas des masses, ok...

--
http://scipy.org/FredericPetit

fred a écrit :
<zip>
> Bon, pour résumer, je passe des arguments en ligne de commande,
> des « mot-clés », qui sont associés à des variables (que j'appelle « flag
> » parce que ce sont des booléens).
>
> Le but est de détecter quels sont les mot-clés qui sont passés en ligne
> de commande (auquel cas le flag est mis à True) pour pouvoir les repasser à False
> par la suite parce que.
>
> J'ai donc construit mon dico comme ça
>
> {'mot clé': 'variable_flag'}
>
> et ensuite, je fais un
>
> if (p in dico.keys()):
> exec('self.'+dico[p]+' = False')
>
> Ok, d'aucuns trouveront peut-être ça tordu quand même,
> mais nettement moins que mon idée initiale.
> Et ça marche du tonerre.
>
> Bon, le coup du exec ne me plaît pas des masses, ok...


setattr(self,dico[p],False)

Ceci dit, si tu n'as que des vrai/faux, tu pourrais aussi travailler
avec un set qui contienne les mots clés présents...

cles = set(sys.argv[1:])
if x in cles : ....

A+