récupérer le nom d'une méthode

Version imprimable

09/11/2011, 10h17
awalter1

récupérer le nom d'une méthode
Bonjour,
je voudrais faire le print de la méthode dans laquelle je me trouve, exemple :
Code:

1 2 3 4 5 def MaMethod(self): print "Methode invoquée :",??? Le résultat attendu lors de l'exécution est : Methode invoquée : MaMethod
Est ce possible ?
Merci
09/11/2011, 10h35
panda31
Bonjour

Apprendre l'introspection : http://python.developpez.com/cours/D...tion/index.php

Petit exemple:
Code:

1 2 3 def myMethod(func): print "Methode en argument : " + func.__name__
L'appel :

Code:

myMethod(myMethod)

donne :

Citation:

Methode en argument : myMethod
09/11/2011, 11h22
panda31
Effectivement...
Pour trouver le nom de la méthode dans laquelle tu passes donc ?

Peux-tu détailler ce que tu veux faire stp ?

J'ai une petite idée mais à voir dans ton contexte :
Code:

1 2 3 4 5 6 7 8 class MyClass: def myMethod(self): print "Methode invoquée :", self.myMethod.__name__ mc = myClass() mc.myMethod()
09/11/2011, 12h06
awalter1
En fait, je souhaite une ligne générique qui puisse être copier/coller dans n'importe quelle méthode. Une sorte d'équivalent du "print self" pour la classe:
Code:

1 2 3 4 class MyClass: def MyMethod(): print "Ma Class : ",self Ma Class : <HMI.page.Page__>
cela me donne la classe dans laquelle s'est fait le print : Page__
Je voudrais le nom de la methode sans l'écrire explicitement dans le print.
Dans ta proposition, autant faire :

Code:

print "Methode invoquée :myMethod"

Merci
Citation:
Envoyé par panda31

Effectivement...
Pour trouver le nom de la méthode dans laquelle tu passes donc ?

Peux-tu détailler ce que tu veux faire stp ?

J'ai une petite idée mais à voir dans ton contexte :

Code:

1 2 3 4 5 6 7 8 class MyClass: def myMethod(self): print "Methode invoquée :", self.myMethod.__name__ mc = myClass() mc.myMethod()

Salut,

Je ne pense pas qu'on sache récupérer cette information en dehors de la pile/stack en cours d'exécution.
Avec inspect, çà donne une horreur du genre:
Code:

1 2 3 4 import inspect def current_function(): return inspect.stack()[1][3]
Utilisable ainsi:
Code:

1 2 3 4 5 class A: def __init__(self): print current_function() def myMethod(self): print current_function()
- W

Pourquoi ne pas faire faire le boulot par un décorateur ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
>>> def methode_verbeuse(methode):
...     def enrobage(*args,**kwargs):
...             print "methode %s invoquee" % (methode.__name__)
...             return methode(*args,**kwargs)
...     return enrobage
... 
>>> 
>>> class MaClasse(object):
...     def silencieuse(self):
...             print "code methode silencieuse"
...     @methode_verbeuse
...     def verbeuse(self):
...             print "code methode verbeuse"
... 
>>> 
>>> obj = MaClasse()
>>> 
>>> obj.silencieuse()
code methode silencieuse
>>> 
>>> obj.verbeuse()
methode verbeuse invoquee
code methode verbeuse

09/11/2011, 14h21
panda31

Je n'y ai jamais trop touché, mais c'est beau! Simple et beau. Merci plxpy d'avoir éclairé ma lanterne.:ccool:
09/11/2011, 15h21
plxpy

Citation:

... mais c'est beau! Simple et beau.

C'est Python !

Comme tu dis!

En revanche, j'ai testé rapidement en créant un décorateur qui permet ou non l'exécution d'une méthode. Je n'arrive pas à l'exécuter à cause d'un message d'erreur :

Citation:

C:\Documents and Settings\mmary\Bureau>python deco.py
myAssert
Traceback (most recent call last):
File "deco.py", line 19, in <module>
@enable(False)
TypeError: 'NoneType' object is not callable

Je suis en python 2.7.1.
Mon code :

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
# -*- coding: utf-8 -*-
 
def enable(condition):
	print "ENABLE"
	def decorated(func):
		print "DECORATED"
                @functools.wraps(func) 
		def wrapper(*args, **kwargs):
			print "WRAPPER"
			#pré-traitement
			if ( condition == True ):
				#traitement
				return func(*args, **kwargs)
			else : 
				print "Disabled"
			return wrapper
		return decorated
 
@enable(False)
def myFunction(*args, **kwargs):
	print "Arguments de myFunction : %s" % ( ', '.join(args) )
 
if __name__ == "__main__":
	myFunction("A", "B", "C", "D")

J'attends à obtenir le message Disabled, mais ça plante dès l'interprétation du tag de décoration @enable(False). Une idée ?

CODE ÉDITÉ :

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
25
26
27
28
29
30
31
# -*- coding: utf-8 -*-
import functools
 
def enable(condition):
	#print "ENABLE"
 
	def decorated(func):
		#print "DECORATED"
 
                @functools.wraps(func) 
		def wrapper(*args, **kwargs):
			#print "WRAPPER"
			#pré-traitement
			if ( condition == True ):
				#traitement
				return func(*args, **kwargs)
			else : 
				print u"'%s' is disabled" % ( func.__name__ )
		return wrapper
	return decorated
 
@enable(False)
def myFunction(*args, **kwargs):
	print "Arguments de myFunction : %s" % ( ', '.join(args) )
 
@enable(True)
def myFunction2(*args, **kwargs):
	print "Arguments de myFunction : %s" % ( ', '.join(args) )
if __name__ == "__main__":
	myFunction("A", "B", "C", "D")
	myFunction2("E", "F", "G", "H")

09/11/2011, 16h26
Petibidon

Hello,

Tes lignes 16 et 17 sont indentées une fois de trop.
09/11/2011, 16h34
panda31

Merci beaucoup. J'ai mis à jour mon script et ça marche maintenant. J'essaie de trouver des best practices sur le sujet et des use cases intelligents. Je pense que je vais mettre à jour mon framework maison avec ces joujous! :mrgreen:

ton probleme viens du faite qu'un decorateur doit retourner uen fonction qui elle se substituera a ta fonction d'origine :
dans ton exemple, dans ta fonction qui decore (cad la fonction 'enable') , tu declare une nouvelle fonction. mais tu ne la retourne pas !! .en faite, 'enable' doit retourner une fonction appelable qui sera substitué a ta fonction decoré.

ton code devien donc
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 def enable(condition): print( "ENABLE") def decorated(func): print( "DECORATED") def wrapper(*args, **kwargs): print( "WRAPPER") #pré-traitement if ( condition == True ): #traitement return func(*args, **kwargs) else : print( "Disabled") return wrapper return decorated @enable(False) def myFunction(*args, **kwargs): print ("Arguments de myFunction : %s" % ( ', '.join(args) ))
en faite, tu a decalé tes return . ta fonction enable retournais ... la fonction enable ^^

j'en ai profité pour le rendre compatible python 3 (ajout de () pour l'appel de print )
et j'ai retiré le "@functools.wraps(func)" qui me semblais inutile.

@panda :

Un exemple d'utilisation des décorateurs, le pattern singleton :

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
25
 
def singleton(cls):
    instances = {}
    def init(*a, **k):
        if cls not in instances:
            instances[cls] = cls(*a, **k)
        return instances[cls]
    return init
 
@singleton
class A:
    def __init__(self, x):
        self.x = x
 
#creation de deux object differents ?
a = A(5)
b = A(10)
# verification
print a.x
print b.x
# bigre !
# confirmation
b.x = 10
print a.x
# c'est donc bien un singleton

Sinon, pour voir un peu plus, tu peux jeter un oeil sur le framework pyramid qui en use et en abuse (et qui est cool !)

30/01/2012, 08h53
awalter1

Merci à tous de votre collaboration