fonction et variable hexadecimal

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:

---

1 2 3 4

>>> a= 0xffff >>> a 65535

---

et quand je fais

Code:

---

1 2	hex(maVariable)

---

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

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:

---

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

---

- W

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

Citation:

---

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

---

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

Citation:

---

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

voila un exemple

Code:

---

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 :calim2:

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

Je suppose que tu as voulu écrire

Code:

---

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

---

Au lieu de

Code:

---

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

---

il faut tout simplement utiliser

Code:

---

1 2 3 4 5

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

---

ok merci
je teste tout de suite

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

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

Code:

---

1 2 3 4

class exemple(): fonction1 (a,b,c) fonction2 (x,y,z)

---

scriptteste:

Code:

---

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:

---

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)

---

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

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

Code:

---

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:

Citation:

---

[(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.

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

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

Code:

---

1 2 3 4 5

for test in list_tests.values(): for fonct in test: if fonct.keys()== ['f2']: f2(*fonct.values()[0])

---

resultat:

Citation:

---

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)

voila un debut

Code:

---

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])

---

Citation:

---

1
4
1
4
1
4

---

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

Juste pour le fun:

Code:

---

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:

---

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

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



Pour le moment, j’ai ça:

Code:

---

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:

---

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:

---

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.

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

Citation:

---

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

Citation:

---

Envoyé par 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

---

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

Citation:

---

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

Citation:

---

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. :mrgreen:

merci a vous , wiztricks et eyquem, grâce a vos proposition j'ai pu avancer, j'ai transformé un code de 900 ligne a un code de 80 ligne et ca marche ;), en utilisant la méthode proposé par wiztricks c.a.d celle qui utilise 'PARTIAL' .
après je pense que tout seul je n'aurai pas trouvé car il faut connaitre le module functools
en espérant que sa va servir a d'autre
encore merci

Salut,

Citation:

---

Envoyé par rosty38

après je pense que tout seul je n'aurai pas trouvé car il faut connaitre le module functools en espérant que sa va servir a d'autre
encore merci

---

Partial est une solution pour créer un callable avec à priori une liste partielle d'arguments. Ici, la liste est "complète", on pourrait s'en passer:

Code:

---

1 2 3 4 5 6

if __name__ == '__main__': for v in list_tests.itervalues(): for item in v: f = item[0] args = item[1:] f(*args)

---

Mais je trouve plus "simple" d'avoir une liste de callables. Ca permet de ne pas avoir à dépendre de la représentation i.e. savoir que c'est un tuple dans lequel...

Code:

---

1 2 3 4

if __name__ == '__main__': for v in list_tests.itervalues(): for f in v: f()

---

- W

@ rosty38,
Si ça ne te gène pas, donne ton code, stp.
Je parie qu’on va trouver de quoi réduire le nombre de lignes à 24.

Citation:

---

Envoyé par wiztricks

Code:

---

1 2 3 4 5 6 7 8

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)

---

---

Cela me semble plus compliqué que nécessaire...
Déjà, pourquoi écrire globals()['__name__'] quand __name__ aurait suffit ?
Mais surtout je vois pas trop pourquoi récupérer le module courant, alors qu'on peut accéder à son __dict__ directement avec globals:

Code:

---

1 2 3 4 5 6

if __name__ == '__main__': for v in list_tests.itervalues(): for item in v: f = globals()[item[0]] args = item[1:] f(*args)

---

Ca fait la même chose, non ?

Ah tiens salut dividee,

Citation:

---

Envoyé par dividee

Cela me semble plus compliqué que nécessaire...
Déjà, pourquoi écrire globals()['__name__'] quand __name__ aurait suffit ?
Mais surtout je vois pas trop pourquoi récupérer le module courant, alors qu'on peut accéder à son __dict__ directement avec globals:

Ca fait la même chose, non ?

---

Ca fait la même chose et ce n'est pas la même chose. Strange non?

Crois-tu que les fonctions à tester seront dans le même module que celui ou sont déclarés et lancés les tests - le module courant - ?
J'espère que non.

J'ai donc anticipé la réponse à une question à venir: "comment récupérer une variable dans le globals d'un autre module?" en suggérant les éléments qui permettent d'y arriver...

Bien sûr, en se contentant de lire le code sans prendre le temps de comprendre le contexte, cela est "plus compliqué que nécessaire". Mais le code n'est qu'une illustration et non le contenu de cette discussion.

Enfin, tu auras pu lire que cette solution n'a, à priori, pas été retenue.

- W

Salut wiztricks,

Citation:

---

Envoyé par wiztricks

Crois-tu que les fonctions à tester seront dans le même module que celui ou sont déclarés et lancés les tests - le module courant - ?
J'espère que non.

J'ai donc anticipé la réponse à une question à venir: "comment récupérer une variable dans le globals d'un autre module?" en suggérant les éléments qui permettent d'y arriver...

---

OK, mais ça va quand-même mieux en le disant. Sinon on se prend une remarque d'une andouille qui ont pas compris l'objectif ;)

Citation:

---

Enfin, tu auras pu lire que cette solution n'a, à priori, pas été retenue.

---

Utilisation intéressante de partial. Dans ce cas-ci, partial(f1,1) est équivalent à lambda: f1(1) vu que tous les arguments sont donnés. J'aurais plutôt utilisé lambda, car cela donnera une erreur si on oublie des arguments; avec partial on risque de ne pas s'en apercevoir tout de suite.
A moins que là aussi c'est pour anticiper... Non, je crois pas :)

Hello Dividee

Citation:

---

Envoyé par dividee

OK, mais ça va quand-même mieux en le disant. Sinon on se prend une remarque d'une andouille qui ont pas compris l'objectif ;)

---

La difficulté ici est que le code ne fait qu'illustrer des idées, montrer ce qu'on peut utiliser pour... Comme c'est "pas fini" et "hors contexte" on ne peut pas le lire, l'auditer de la même façon.

Citation:

---

Utilisation intéressante de partial. Dans ce cas-ci, partial(f1,1) est équivalent à lambda: f1(1) vu que tous les arguments sont donnés. J'aurais plutôt utilisé lambda, car cela donnera une erreur si on oublie des arguments; avec partial on risque de ne pas s'en apercevoir tout de suite.

---

Bonne remarque, car l'idée étant de tester la 'validité' dans la construction de la liste de tests, çà va dans le bon sens.
Mais je n'arrive pas à le faire marcher:cry:

Code:

---

1 2 3

def foo(a, b): print a+b x = lambda: foo(1) # ne retourne une erreur que lorsqu'on invoke x

---

Ce qui ne me semble pas anormal... mais pour le coup, je n'ai peut être pas compris ta remarque.

Citation:

---

A moins que là aussi c'est pour anticiper... Non, je crois pas :)

---

Dans l'exemple, la construction de la liste est "statique". Mais on pourrait imaginer qu'elle soit construite par des fonctions qui la construise à partir d'un fichier.

Soucis: est-ce qu'on "variabilise" le paquets de strings lors de sa construction ou lors de son parcours pour exécuter les tests?

La mouture "partial" variabilise "à la construction" et on en profite pour transformer (f, a, b,... ) en callable et séparer les erreurs de construction des erreurs d'exécution.

Cette séparation aurait sans doute été plus lisible en définissant une fonction, style:
>>> def make_callable(f, *args, **kwds):
... return lambda: f(*args, **kwds)
habillable ensuite avec des inspect.machin pour fiabiliser les tests.
J'ai peut être manqué d'inspiration sur ce coup là, j'en conviens.
- W

Citation:

---

Envoyé par wiztricks

Mais je n'arrive pas à le faire marcher:cry:

Code:

---

1 2 3

def foo(a, b): print a+b x = lambda: foo(1) # ne retourne une erreur que lorsqu'on invoke x

---

Ce qui ne me semble pas anormal... mais pour le coup, je n'ai peut être pas compris ta remarque.

---

C'est moi qui me suis mélangé les pinceaux, désolé. J'aime beaucoup la curryfication automatique qu'il y a en ML ou en haskell; du coup j'ai bêtement cru que partial retournait une version curryfiée de la fonction, et que donc x() (où x est le résultat d'un appel à partial) ne causerait pas une erreur mais renverrait la fonction x elle-même. C'est bien sûr totalement faux.

Citation:

---

Dans l'exemple, la construction de la liste est "statique". Mais on pourrait imaginer qu'elle soit construite par des fonctions qui la construise à partir d'un fichier.

Soucis: est-ce qu'on "variabilise" le paquets de strings lors de sa construction ou lors de son parcours pour exécuter les tests?

La mouture "partial" variabilise "à la construction" et on en profite pour transformer (f, a, b,... ) en callable et séparer les erreurs de construction des erreurs d'exécution.

---

S'il manque un argument, est-ce une erreur dans la construction des tests ou dans le code qui est testé, qui déclare un paramètre de trop ? Dans le premier cas, on peut souhaiter séparer les deux (càd faire échouer l'exécution du test), dans le second, on préférerait sans doute que le test s'exécute mais renvoie une erreur...

Citation:

---

Cette séparation aurait sans doute été plus lisible en définissant une fonction, style:
>>> def make_callable(f, *args, **kwds):
... return lambda: f(*args, **kwds)
habillable ensuite avec des inspect.machin pour fiabiliser les tests.
J'ai peut être manqué d'inspiration sur ce coup là, j'en conviens.
- W

---

inspect.machin ? Moi à ce moment je commencerais à chercher un framework de test existant, histoire de voir si quelqu'un aurait pas déjà fait le boulot à ma place ;)