Discussion :

[jack_x4]

Bonjour,

Je me permets de pauser une question concernant l'assignation d'une variable dans un nom de fonction.

Voici la fonction :

Code :

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

1
2
3
 
mot="test"
print hashlib.md5(mot).hexdigest()

Dans mon script j'ai annoncé un choix et je demande à l'utilisateur de choisir, il renvoi soit

Code :

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

1
2
 
var="md5"

Soit

Code :

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

1
2
 
var="sha1"

maintenant ce que je souhaite faire c'est que la fonction accueil une variable "var" a la place du type de hash en fonction de ce l'utilisateur choisi :

Code :

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

1
2
 
print hashlib.var(mot).hexdigest()

Mais j'ai une erreur.

Merci de votre aide

[kango]

bonjour,

voici une façon de faire, il y en a plusieurs:

Code :

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

1
2
3
4
5
mot = "test"
var = "md5"
print getattr(hashlib,var)(mot).hexdigest()
var = "sha1"
print getattr(hashlib,var)(mot).hexdigest()

ou encore autre chose:

Code :

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

1
2
hashers = {'md5':hashlib.md5, 'sha1':hashlib.sha1}
print hashers[var](mot).hexdigest()

[rambc]

Le plus simple serait de faire un petit test :

Code :

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

1
2
3
4
5
6
if var == "md5":
    print hashlib.md5(mot).hexdigest()
elif var == "sda1":
    print hashlib.md5(mot).hexdigest()
else:
    print 'var invalide'

La méthode de kango est plus technique. Est-elle justifiée ici, je ne sais pas ?

[pacificator]

Bonjour,

perso j'utiliserais plus une méthode à base de dictionnaire:

Code :

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

1
2
3
4
5
d = {'md5': haslib.md5, 'sha1': hashlib.sha1}
try:
    print d[var](mot).hexdigest()
except KeyError:
    traiter_erreur()

[jack_x4]

J'ai retenu la première solution de Kango.

Merci aussi aux autres membres pour l'intérêt qu'il ont porté a mon projet.

Cdt

[wiztricks]

Salut,

Pour transformer:

hashlib.var(mot).hexdigest()

en

hashlib(var)(mot).hexdigest()

on peut faire:

Code :

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

1
2
3
4
5
6
7
8
9
import hashlib
 
def myhash(var):
    return lambda mot, var=var: getattr(hashlib, var)(mot)
 
print myhash('md5')('toto').hexdigest()
# ou
foo = myhash('md5')
print foo('toto').hexdigest()

Note: Ca en jette mais ca équivaut à mettre var=>getattr(x, var) dans un dict sauf qu'ici on utilise les closures et le dict "locals" qui est déjà là.

Ce qui avec des 'class' devrait s'écrire en plus verbeux:

Code :

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

1
2
3
4
5
class MyHash(object):
    def  __init__(self, var):
          self._var = getattr(hashlib, var)
    def __call__(self, mot):
          return self._var(mot)

Et si vous voulez limiter le nombre d'objets crées, on peut ajouter

Code :

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

1
2
3
4
5
6
7
     _instances = {}
     def __new__(cls, var):
           if var not in cls._instances:
                  instance = object.__new__(cls)
#                  instance.__init__(var)  -- oops, en fait il y va tout seul
                  cls._instances[var] = instance
           return cls._instances[var]

- W

[sjrd]

Toute méthode à base de getattr() est à proscrire si l'utilisateur peut entrer directement la valeur. Parce qu'alors il peut aussi entrer n'importe quoi d'autre (genre '__class__' par exemple ). Le dictionnaire est nettement plus sûr.

[wiztricks]

Toute méthode à base de getattr() est à proscrire si l'utilisateur peut entrer directement la valeur. Parce qu'alors il peut aussi entrer n'importe quoi d'autre (genre '__class__' par exemple ). Le dictionnaire est nettement plus sûr.

Ah ben on peut mettre du "non fonctionnel" dedans bien que personnellement je serais plus partant pour décorer, style:

Code :

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

1
2
3
4
5
6
7
8
9
 
 
def _myhash(var):
         return lambda mot, var=var: getattr(hashlib, var)(mot)
 
def myhash(var):
    if var in [ "la liste", "qu'on veux" ]:
           return _myhash(var)
    raise ValueError('la cle %(var)s est interdite' % vars())

1. Ca montre bien que cela est de l'overhead par rapport 'au fonctionnel' de la chose. Est ce qu'on a intérêt à séparer les points de vue? il y a des bouquins sur Aspect Oriented Programming qui racontent cela...
Ici, l'exemple est trop petit pour être significatif, mais illustre qu'il peut être (parfois) intéressant de pas mélanger...

2. Et toujours pas de dict
- W

[sjrd]

Si tu veux vraiment séparer, mieux vaut mettre le raise sous le if. Ainsi, il est très claire que le if et son code s'occupent du non-fonctionnel. Tandis qu'en-dessous se gère le cas correct.

Code :

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

1
2
3
4
5
6
7
8
9
_VALID_METHODS = ["la liste", "qu'on veut"]
 
def _myhash(var):
    return lambda mot, var=var: getattr(hashlib, var)(mot)
 
def myhash(var):
    if var not in _VALID_METHODS:
        raise ValueError('la cle %(var)s est interdite' % vars())
    return _myhash(var)

Bon maintenant il y a l'autre école qui dit qu'il faut mettre en évidence le code "normal", puis seulement mettre les cas d'erreur à la fin. Mais ça va à l'encontre du fonctionnel/non-fonctionnel.

[wiztricks]

Salut,

Pour moi le fonctionnel se réduit à _myhash.

Le non fonctionnel (ce qui est dans myhash) peut être écrit comme on veut...

Où plus précisément suivant un contexte particulier - propre au "non fonctionnel" - dont les interprétations (et les implications) restent libres tant qu'elles ne sont pas contraintes par des critères tangibles du style: coûts, délais, qualité, maintenabilité, évolutivité, standards et pratiques, ...
Et encore, les contraintes sont nécessaires mais parfois insuffisantes.

A défaut, tu as raison, je n'ai pas tort et réciproquement
- W

[sjrd]

Effectivement ça se tient