Discussion :

[rosty38]

bonjour,
je souhaite utiliser une variable hexadécimal mais lors du passe de la variable a la fonction celle-ci est convertie en str .

Code :

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

1
2
3
4
 
>>> a= 0xffff
>>> a
65535

et quand je fais

Code :

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

1
2
 
hex(maVariable)

celle-ci est convertie en string
serait il possible de travailler qu'avec des valeur hexadécimaux????
merci

[wiztricks]

Salut,

Je ne comprends pas trop.

La machine travaille avec des représentations en base2.
L'IHM vous propose par défaut une représentation en base 10.
Si vous voulez que çà affiche les valeurs en hexa, il faut le demander.

Code :

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

1
2
a = 0xff # 0x dit attention base 16, mais on aurait pu écrire
a = int(hex(255),16)

- W

[rosty38]

je viens de trouvé la source du problème, ce n'est pas liée au type de la variable mais au dictionnaire que j'utilise.
en fait j'ai crée un dictionnaire

dict1 = {a=1, b=2, c=3, d=4}

je récupère les valeurs du dictionnaire pour les utiliser dans une fonction

mafonction(a,b,c,d):
for.........

le problème est que l'ordre n'est pas respecter du coup je me retrouve avec une fonction avec des paramètres inversé (mafonction(b,c,d,a)par exemple ) .


si je trouve je mets la solution

[rosty38]

voila un exemple

Code :

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

1
2
3
4
5
 
>>> dict1 = {'e':0x78F, 'b':2, 'z':0xffff, 'a':4}
>>> dict1
{'a': 4, 'b': 2, 'e': 1935, 'z': 65535}
>>>

il faut que je le force a ne pas ordonnée , mais je ne sais pas encore comment

[wiztricks]

Salut,

Par défaut, le dict ne préserve pas l'ordre.
V27 vient avec OrderedDict dans "collections".

Mais pourquoi ne pas revoir la structure de donnée utilisée?
Une liste de tuple: [ ('e',0x78F), ('b',2), ('z',0xffff), ('a',4) ] préserve aussi l'ordre.
- W

[eyquem]

Je suppose que tu as voulu écrire

Code :

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

dict1 = {a:1, b:2, c:3, d:4}

Au lieu de

Code :

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

dict1 = {a:1, b:2, c:3, d:4}

il faut tout simplement utiliser

Code :

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

1
2
3
4
5
li1 = [(a,1),(b,2),(c,3),(d,4)]
 
for u,v in li1:
 
    ......

[rosty38]

ok merci
je teste tout de suite

[josmiley]

Que veux-tu faire qui nécessite une telle structure ?
Cela me semble bien compliqué ...

[rosty38]

en fait j'ai un script qui doit tester un autre script
exemple :
scriptAtester:

Code :

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

1
2
3
4
 
class exemple():
   fonction1 (a,b,c)
   fonction2 (x,y,z)

scriptteste:

Code :

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

1
2
3
4
 
class Test():
   test1_fonction1(a=1,b=2,c=3)
   test2_fonction1(a=55,b=88,c=97).....

au lieu d'exécuter la fonction a chaque teste different, je souhaite mettre les different testes dans une structure de données, puis parcourir cette structure pour recuperer les parametres et ecrire une seule fonction de teste , ce ki donnerai:

Code :

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

1
2
3
4
5
6
 
list_param = [{a:1,b:2,c:3}, {a:55,b:88,c:97}....]
 
for param in list_param
     scriptAtester.fonction1(*param)
     scriptAtester.fonction2(*param)

[wiztricks]

Hmmm

Gaffe à ta conception:
f(a, b, c) dit que a, b, c sont positionnels alors que f(a=1, b=2, c=3) les rends nommés et pouvant être "mixtes" => la fonction ne les verra pas arriver de la même façon.

Si on reste à dire quelconques, les paramètres effectifs sont de la forme params=(liste, dict) ou *args, **kwds.
Normalement inspect devrait permettre de récupérer la forme de la liste d'arguments, mais supposons que c'est une liste "positionnelle".

les noms 'a', 'b', 'c' c'est de la présentation alors qu'il faut passer la liste des valeurs => pourquoi stocker (a,1), (b, 2), ... plutôt que [1, 2, ...]
- W

[rosty38]

effectivement
alors j'ai repris le code enfin j'ai ecris un autre :

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
 
list_tests = {  'test1':[
							{'f1':(1,)},
							{'f2':(2,2)}],
				'test2':[
							{'f1':(1,)},
							{'f2':(2,2)}],
				'test3':[	
							{'f1':(1,)},
							{'f2':(2,2)}]}
 
def f1(a):
	print a
 
 
def f2(x,y):
	z = x+y
	print z
 
 
for test in list_tests.values():
	for fonct in test:
		if fonct.keys()== ['f2']:
			print fonct.values()

et voila le resultat:

[(2, 2)]
[(2, 2)]
[(2, 2)]

et cette conception???
il faut que je cherche encore , car si j'utilise le IF il faut que je fasse autant de "if" que de fonction a testé et puis j'ai toujours pas acces au parametres.

[rosty38]

en fait le but final est de Recevoir les valeurs Des Tuples Dans Des Fonctions différentes qui prennent des argument différents

[rosty38]

ah tiens j'ai trouvé , il fallait rajouter "*"

Code :

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

1
2
3
4
5
 
for test in list_tests.values():
	for fonct in test:
		if fonct.keys()== ['f2']:
			f2(*fonct.values()[0])

resultat:

4
4
4

maintenant il me reste plus qu'a trouvé une solution pour exécuter différentes fonction avec des paramètres différents (en valeur, en type, en nombre)

[rosty38]

voila un debut

Code :

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

1
2
3
4
5
6
7
 
>>> for test in list_tests.values():
	for fonct in test:
		if fonct.keys()== ['f2']:
			   f2(*fonct.values()[0])
		if fonct.keys()== ['f1']:
			   f1(*fonct.values()[0])

1
4
1
4
1
4

mais ce n'est pas jolie tout ca , vous imaginez 1000 fonctions

[wiztricks]

Juste pour le fun:

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
from functools import partial
 
def f1(a):
    print 'a = ', a
 
def f2(a, b):
    print 'a, b = ', a, b
 
list_tests = dict(
    test1 = [ partial(f1, 1),
              partial(f2, 2, 2) ],
    test2 = [ partial(f1, 2),
              partial(f2, 2, 2) ])
 
 
for v in list_tests.itervalues():
    for f in v:
        f()

Plus en ligne, on a:

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
list_tests = dict(
    test1 = [ ('f1', 1),
              ('f2', 2, 2) ],
    test2 = [ ('f1', 2),
              ('f2', 2, 2) ],)
def f1(a):
    print 'a = ', a
 
def f2(a, b):
    print 'a, b = ', a, b
 
if __name__ == '__main__':
    import sys
    module = sys.modules[globals()['__name__']]
    for v in list_tests.itervalues():
        for item in v:
            f = getattr(module, item[0])
            args = item[1:]
            f(*args)

- W

[eyquem]

J’ai du mal à saisir le code de wiztricks (mais où vas tu chercher tout ça, wiztricks ?)



Pour le moment, j’ai ça:

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
def f1(a):
	return a
 
def f2(x,y):
	return x+y
 
list_tests = [ ( (1,)  , (2,2)   ) ,
               ( (32,) , (10,-7) ) ,
               ( (-1,) , (9,3)   ) ,
               ( (7,)  , (0,2)   )  ]
 
funcs_a_tester = [ f1, f2 ]
 
 
aecr = []
for n,seq_argus in enumerate(list_tests):
   aecr.append( ('\n'+str(n+1)+'ieme test:','\nDeuxieme test:','\nPremier test:')[2//(n+1)] )
   aecr.extend(repr(f).split()[1]+repr(argus).replace(',)',')')+ ' = '+repr(f(*argus))
               for f,argus in zip(funcs_a_tester,seq_argus))
print '\n'.join(aecr)

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
 
Premier test:
f1(1) = 1
f2(2, 2) = 4
 
Deuxieme test:
f1(32) = 32
f2(10, -7) = 3
 
3ieme test:
f1(-1) = -1
f2(9, 3) = 12
 
4ieme test:
f1(7) = 7
f2(0, 2) = 2

Ah oui, j’oubliais:



- list_tests est un mauvais nom pour

Code :

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

1
2
3
4
dict(test1 = [ ('f1', 1),
               ('f2', 2, 2) ],
     test2 = [ ('f1', 2),
               ('f2', 2, 2) ],)

car ceci est un dictionnaire



- à quoi sert-il de repérer

[ ('f1', 1),
('f2', 2, 2) ] avec une clé ’test1’

[ ('f1', 2000),
('f2', 20, 2223) ] avec une clé ’test2’ ?

Si on y tient, on met

[ ('f1', 1),
('f2', 2, 2) ] en première position dans une liste,

[ ('f1', 2000),
('f2', 20, 2223) ] en deuxième position dans la liste,

et à partir de leur index i on peut déduire 'list'+str(i) si ça nous chante. Mais ça chante quelle chanson intéressante ? Je ne vois pas.

[rosty38]

merci wiztricks , le code fonctionne , et il est très cours mais il fallait pensé a utilisé le module "sys", je le déroule en pas a pas pour comprendre mieux

[wiztricks]

J’ai du mal à saisir le code de wiztricks (mais où vas tu chercher tout ça, wiztricks ?)

Attends Eyquem, on ne peut pas tout jeter.
Le code initial propose un dict avec des noms de tests auxquels sont associées fonctions et paramètres d'appel.

Qu'est ce qui te permet de supposer que la suite des fonctions sera identique d'un test à l'autre?
C'est peut être le cas...
Mais pourquoi "simplifier" alors qu'une solution plus générale n'est pas si compliquée à écrire?

D'autant que les soucis de l'auteur me semble plutôt être du côté... Bon super, j'ai construit la liste des tests mais "comment utiliser les informations?".

J'ai pris la liberté de changer la forme du stockage pour passer de:
[*methode, (p1, p2, ...) ] à (methode, p1, p2, ...) ce qui est assez iso côté informations.
Ensuite, j'ai fait varié le "type" de methode: pourquoi utiliser le nom "string" plutôt que la variable?
Dans ce cas, quitte à stocker un truc, partial appliqué à (methode, p1, p2, ...) nous retourne une liste de fonctions lambda qui simplifie la logique d'appel.

C'est une simplification qui me paraît intéressante: on teste l'accès au variables 'avant' l'exécution du test.

Ceci dit, passer de nom à adresse est quand même la question posée, d'où la mouture avec getattr.

Pas très compliqué, Python est un langage dynamique avec des possibilités d'introspection qui peuvent être utilisées...

- W

[wiztricks]

merci wiztricks , le code fonctionne , et il est très cours mais il fallait pensé a utilisé le module "sys", je le déroule en pas a pas pour comprendre mieux

Revisite la mouture avec partial après.
Elle fait la même chose en encore plus court.
- W

[eyquem]

Qu'est ce qui te permet de supposer que la suite des fonctions sera identique d'un test à l'autre?

Rien de sûr. Et j’ai d’ailleurs bien pensé qu’il était fort possible que rosty38 s’aperçoive ultérieurement que les fonctions n’auront pas à être tout le temps les mêmes au long des tests qui se succéderont.

Mais:

- j’ai un peu dépassé un stade dans lequel, à une époque , je cherchais à faire des réponses qui tenaient compte du plus grand nombre de possibilités de variation envisageables, allant jusqu’à anticiper des besoins que le questionneur n’avait pas exprimés. C’est un peu fatigant comme façon de faire, et, voyant combien les questions sont souvent mal posées, comme si les questionneurs avaient la flemme de bien décrire leur problème, ou craignaient de faire des posts trop longs, j’en viens à me dire qu’ils n’ont qu’à commencer par se débrouiller avec ce qu’on leur renvoie comme propositions, qui peuvent déclencher des idées nouvelles

- rosty38 nous sert un test2 qui est identique au test1; c’est pousser vers le chemin que j’ai pris

Attends Eyquem, on ne peut pas tout jeter.

De fait, je ne dis pas qu’il faut jeter des choses, je dis «moi j’ai ça», ce qui signifie que dans le cadre de ce que j’ai compris de la question, je fais une proposition, qui ne correspond peut être pas aux souhaits, mais rosty38 me le dira, et je ne ferai pas une maladie si ma réponse sera à coté de la plaque.

Du coup, une proposition permet aussi de faire naitre éventuellement des idées nouvelles. Et ca permet d’avancer des deux cotés sans attendre d’avoir des précisions ou de mieux comprendre un problème avant de faire une réponse.

Il y a trop de files dans lesquelles je me suis dit «tiens , j’ai une idée de réponse, mais il faut que je creuse ou vérifie tel ou tel sujet». Et plusieurs mois après je ne l’ai toujours pas fait. Il y a par exemple une remarque de PauseKawa du début de l’année et une de kango de l’an dernier auxquelles je pense de temps à autre qu’il me faudra répondre.... sans le faire jamais.

Et il n’y a pas que les réponses dans lesquelles je suis en sédimentation.



Enfin bref, la plupart de temps je ne fais que des propositions et je ne suis pas persuadé d’avoir l’avis optimal sur une question. Faut pas croire que j’ai cette illusion.




Et quand je dis «où vas-tu chercher tout ça » , ce n’est pas une critique, c’est parce que ça me donne l’impression que tu as parcouru l’entièreté de la doc au moins une fois et que tu sais où retrouver ce qu’il faut dans chaque occasion où cela est utile. Comme un Pyc de la Mirandolle en quelque sorte.