Discussion :

[Thibqult]

Bonjour à tous !

J'essaye de comprendre comment appeller une fonction seulement à partir de son nom (stocké dans un string), et mes recherhes mènent toutes au même genre de réponse, à savoir utiliser getaddr. Cela donne généralement :

result = getattr(foo, 'bar')()

Avc bar = nom de la fonction. Le problème, c'est que je ne vois pas du tout ce qu'est censé être foo ! Les définitions de getattr me parlent d'un "objet" ou d'un "module" mais cela ne correspond à rien dans mon programme... Est-ce une erreur de conception de ma part ou de compréhension de ce getattr ? Merci d'avance de m'éclairer un peu...

[fred1599]

J'essaye de comprendre comment appeller une fonction seulement à partir de son nom (stocké dans un string)

Edit : Pourquoi dans un string?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> def add(a, b):
	return a+b
 
>>> def sub(a, b):
	return a-b
 
>>> my_func = [add, sub]
>>> for func in my_func:
	print(func(3, 5))
 
 
8
-2

getattr(objet, 'data') il permet de donner l'attribut data de l'objet.

Code :

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

1
2
3
4
5
6
7
>>> class A:
	pass
 
>>> a = A()
>>> a.data = 6
>>> getattr(a, 'data')
6

[Pymento]

si mes souvenirs sont bon, la fonction

Code :

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

exec

devrait pouvoir faire l'affaire

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
 
def f1():
	print 'ok'
 
s1 = "f"
s2 = "1"
 
s3 = s1 + s2 + "()"
 
exec(s3)

Voilou

[panda31]

Getattr est bon si on connait l'objet dans lequel chercher la méthode ou l'attribut de cet objet.

Exemple :

Code :

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

1
2
3
4
5
6
7
8
class A:
	def myMethod(self, a, b):
		print "argument 1 : "+a+", argument 2 : "+b
 
if __name__ == "__main__":
	obA = A()
	func = getattr(obA, "myMethod")
	func("chose", "truc")

L'exécution donne:

Code :

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

argument 1 : chose, argument 2 : truc

Si tu veux plus d'aide, détaille un peu plus ta demande.
Bon code!

[wiztricks]

Salut,

Avec bar = nom de la fonction. Le problème, c'est que je ne vois pas du tout ce qu'est censé être foo ! Les définitions de getattr me parlent d'un "objet" ou d'un "module" mais cela ne correspond à rien dans mon programme...

Python crée cela pour vous...

Pensez getattr comme une fonction recherchant la définition d'un nom dans un espace (de noms "plat"). Avec Python tout est "objet" et tous les objets appartiennent à un "module". Un module pourrait être considéré comme un objet particulier mais...

Exemple:
>>> int.__module__
'__builtin__'

** but ** le string '__builtin__' n'est pas le module qui se récupère via:
>>> module = sys.modules['__builtin__']
>>> x = getattr(module, 'int')
>>> x
<type 'int'>

Est-ce une erreur de conception de ma part ou de compréhension de ce getattr ? Merci d'avance de m'éclairer un peu...

Pas facile de concevoir proprement lorsqu'on ne comprend pas... Donc je dirais les deux mon capitaine, mais prenez le temps d'apprendre et çà ira bien.

- W

[plxpy]

Et passer par globals(), à partir du moment où la fonction est dans le script lui-même ou a été importée nommément ?

dans plus.py :

Code :

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

1
2
def plus(a,b):
    return a+b

script.py :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
import sys 
 
from plus import plus
 
def moins(a,b):
    return a-b 
 
def calcule(operation,entier_1,entier_2):
    function = globals()[operation]
    return function(entier_1,entier_2)
 
if __name__ == '__main__':
    print calcule(sys.argv[1],int(sys.argv[2]),int(sys.argv[3]))

à l'usage :

Code :

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

1
2
3
4
$> python script.py plus 4 5
9
$> python script.py moins 4 5
-1

[fred1599]

@Pymento

La fonction exec n'est surtout pas une bonne chose en python, on l'utilise vraiment que lorsqu'elle est indispensable car c'est une fonction source de bugs, de manque de contrôle de son programme, de destruction des performances, etc...

Martelli lui même en parle de cette façon

Use exec only when it's really indispensable

Hors dans ce cas, ça ne l'est pas.

[utopman]

Bonjour, tu peux exécuter une chaîne de caractère avec la fonction eval comme il suit

Code :

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

eval('1 + 2')

je ne sais pas exactement ce que tu peux faire de plus avec
sinon, autre solution :
tu ecris ton code dans un fichier et tu l'importes ensuite genre

Code :

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

1
2
3
4
c = open('toto.py')
c.write(moncode)
c.close()
from toto import *

[wiztricks]

Je comprends qu'à la vue d'un string certains puissent perdre leur sang froid mais la question initiale portait sur getattr et non sur comment écrire un "interpréteur" de commandes ingérable.
- W
PS: Si tel était le cas, les modules cmd et shlex sont à regarder.

[fred1599]

Bonjour, tu peux exécuter une chaîne de caractère avec la fonction eval comme il suit

Il y a le module ast, qui est plus safe que la fonction builtin eval().

Code :

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

1
2
3
>>> import ast
>>> ast.literal_eval('2+1')
3

Je comprends qu'à la vue d'un string certains puissent perdre leur sang froid mais la question initiale portait sur getattr

Dans ce cas je n'utiliserais pas getattr mais cette solution

Code :

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

1
2
3
4
5
>>> def test(a):
	return a
 
>>> print(globals()['test'](5))
5

Edit : Je crois avoir été grilled par plxpy

[plxpy]

mais la question initiale portait sur getattr

Non. Getattr est ce qu'avait trouvé Thibqult pour tenter de résoudre son problème qui était initialement de :

comment appeller une fonction seulement à partir de son nom (stocké dans un string)

comment écrire un "interpréteur" de commandes ingérable

L'exemple choisi n'avait pour but que de montrer que ça fonctionnait, rien d'autre. Je ne sais pas ce que Thibqult souhaite faire.

[tyrtamos]

Bonjour,

Petit complément: il est quelquefois intéressant de conserver la relation nomdefonction <=> fonction avec un dictionnaire:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
def plus(x, y):
    return x+y
 
def moins(x, y):
    return x-y
 
Op = {"plus": plus, "moins": moins}
 
print Op["plus"](5,4)
9
print Op["moins"](5,4)
1

Ça permet de simuler un "case of" inexistant sous Python

[plxpy]

@wiztricks: Par contre, vraiment sans polémiquer et en dehors du côté "interpréteur de commandes ingérable", j'aimerais bien que tu me/nous donnes des conseils sur l'utilisation de globals() pour ce genre de problème. Est-ce propre ? A quels problèmes on s'expose en procédant de la sorte , etc ...

[wiztricks]

Salut,

Par contre, vraiment sans polémiquer et en dehors du côté "interpréteur de commandes ingérable", j'aimerais bien que tu me/nous donnes des conseils sur l'utilisation de globals() pour ce genre de problème. Est-ce propre ? A quels problèmes on s'expose en procédant de la sorte , etc ...

globals() permettra de récupérer la définition de symboles dans le module courant. getattr sera plus générique. Le côté "fonctionnel" s'arrête là.

Le fait est que si on se pose la question, c'est qu'on a récupéré des chaînes de caractère d'on ne sait où et qu'on a peut être envie de "contrôler" plus précisément la liste des symboles qu'on se proposera de...

Ce qui n'a rien à voir avec le côté "fonctionnel" mais a plutôt trait à la sécurité ou à l'affichage de message d'erreurs circonstanciés.

Une réponse est ce que propose Tyrtamos: les symboles à traduire sont stockés dans un dict.
Ce pas là franchit, plus besoin de passer par "globals"!

Mais on pourrait très bien emballer les fonctions dans une classe et se servir de la boîte "classe" ou "instance" (et getattr) plutôt que d'un dict simple.

Cela pourrait donner une chose de la forme:

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
class A:
    @classmethod
    def _plus(cls, x, y):
        return x+y
 
    @classmethod
    def _moins(cls, x, y):
        return x-y
 
    @classmethod
    def call(cls, name, *args, **kwds):
        name = '_' + name
        if hasattr(cls, name):
            return getattr(cls, name)(*args, **kwds)
 
print A.call('plus', 1, 2)
print A.call('moins', 1, 2)

Ce qui est un peu "over-engineered" pour ce cas particulier.
- W

[plxpy]

@wiztricks Merci pour ces précisions

[PauseKawa]

Bonjour,

globals() permettra de récupérer la définition de symboles dans le module courant.

En soit n'est il pas risqué de 'stocker' quelque chose dans une boite aussi 'volatile' (les dicos global) ?
Cela n'a pas d'importance ici mais pour du code plus important n'est ce pas le meilleur moyen de 'perdre des petits en route' ?
Outre l'aspect 'injection' le fait d'avoir une 'boite' (objet) bien définie me semble la meilleure façon de 'suivre' ses variables, non ?
Quant a getattr il a au moins l'avantage de limiter les 'dégâts'

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
>>> class A:
...     pass
... 
>>> getattr(A, 'toto')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'A' has no attribute 'toto'
>>> class A:
...      toto=1
... 
>>> getattr(A, 'toto')
1

@+

[wiztricks]

Salut,

En soit n'est il pas risqué de 'stocker' quelque chose dans une boite aussi 'volatile' (les dicos global) ?

Cela n'a pas d'importance ici mais pour du code plus important n'est ce pas le meilleur moyen de 'perdre des petits en route' ?

En python, tout étant "dynamique".... je ne connais pas de boîtes qui soient des "coffres forts" inviolables.

classe ou module, ce qui me semble "important", c'est la durée de vie de l'objet: tous deux sont, par défaut, crées et détruits au lancement et à la fin... mais le premier paramètre de getattr fonctionne avec les deux...

note: en fait tout est dans des dict plus ou moins aménagés...

- W

[PauseKawa]

En python, tout étant "dynamique".... je ne connais pas de boîtes qui soient des "coffres forts" inviolables.

classe ou module, ce qui me semble "important", c'est la durée de vie de l'objet: tous deux sont, par défaut, crées et détruits au lancement et à la fin... mais le premier paramètre de getattr fonctionne avec les deux...

note: en fait tout est dans des dict plus ou moins aménagés...

C'est bien le sens de mes 'questions': La visibilité et le type de la 'boite'.
La 'boite' class boite(dict) me semble bien pour du code propre.

@+

[plxpy]

Un truc continue à me turlupiner. Vous êtes plusieurs à éviter autant que possible d'utiliser globals() - le dictionnaire retourné - avec, comme clé, le nom de la fonction à appeler.

J'ai le vague sentiment que, dans certains cas, l'utilisation directe du dictionnaire retourné par globals() est préférable* (moins d'intermédiaires, code plus "ramassé" et plus lisible) à l'utilisation d'un dictionnaire géré à la main, qui associerait mots-clés/noms de fonction avec les fonctions, résultat d'un "switch" (if ... elif) géant Non, vu que c'est un dictionnaire - c'est l'initialisation, clé/fonction, une à une qui peut être lourdingue.

(*) du moins, il ne faut pas l'exclure d'emblée

Aussi, y-a-t-il, fondamentalement, une différence entre :

exécuter l'intruction

Code :

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

globals()[nom_fonction](parametres)

avec nom_fonction valant "fonction"

et ecrire, dans le code lui-même,

Code :

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

fonction(parametres)

Sous la deuxième forme, à l'exécution, l'interpréteur va rechercher le symbole nom_fonction dans l'espace de nommage local, ne pas le trouver (sauf si on est, par exemple, dans le main où locals() et globals() retournent la même chose), dans l'espace de nommage global qui est censé être récupérable via, justement, globals() et, s'il le trouve, (tenter de) lancer/appeler la dite-fonction.

Si la fonction n'existe pas, on n'aura seulement des exceptions différentes levées (NameError ou KeyError) selon l'approche.


Est-ce que je loupe quelque chose en faisant ce raisonnement ?

[PauseKawa]

Bonjour plxpy,

Pour être franc (et je me trompe sans doute):
Pour moi les namespaces font partis de la tuyauterie interne, que ce soit globals() ou locals() ce n'est qu'un accès (représentation sous forme de dico) aux espaces de nom 'global' et 'local' (block).
Certes il est possible d'écrire directement dedans (non recommander pour le local bien sur) mais key = valeur en fait autant et c'est l'interpréteur qui le gère. Je préfère cela.
Ensuite viens le namespace pollution. On y ajoute quelques from tutu import * et nous voila avec une belle pagaille.
Pour finir le suivi des objets. Je trouve plus propre de faire mondico[key] que globals[key]. A moins je sais ce qu'est 'key' dans mon dico, dans le globals (qui est en r/w) je risque d'avoir des surprises. Cela fait un appel global de plus ? globals[key] aussi (et interdit de faire mumuse avec le local).
C'est juste un avis personnel sur mon approche d’autodidacte de Python.

@+