Discussion :

[loichuss]

Bonjour,

Je voudrais bien utiliser les décorateurs dans mes scripts afin de simplement printer quand est ce que je rentre et sort d'une fonction ou méthode Rien de plus simple me direz vous.

La class inOut fonctionne bien pour une fonction, mais quand il s'agit d'une méthode au sein d'une class la bête ne fonctionne plus. J'ai l'impression que le problème est au niveau des attributs de la class qui ne sont pas envoyés.


Voici le code :

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
 
class inOut(object):
    def __init__(self, f):
        self.f = f
 
    def __call__(self, *args, **kwargs):
        print 'start'
        functionReturn = self.f(*args, **kwargs)
        print 'end'
        return functionReturn
 
class toto():
    def __init__(self):
        self.x = 5
 
    @inOut
    def bla(self):
        print self.x
 
maClass = toto()
maClass.bla()

Je pensais effectuer l'envoie des attributs comme cela @inOut(self), mais cela ne fonctionne pas.

Et malheureusement mes connaissances ne sont pas assez bonne pour trouver la solution.

Merci d'avance

[N.tox]

Les décorateurs représentent un exercice relativement difficile à maîtriser car demandant un certaine gymnastique mentale... A mon humble avis, tu veux démarrer un peu trop fort, je te conseil de bien comprendre les mécanismes les plus simple des décorateurs, avant de tester des constructions plus complexes les exploitant.

Sans avoir bien compris ce que tu cherchait à faire, voici un exemple dont le code est très proche de ce que tu as essayé :

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
>>> class Formater(object):
	def __init__(s, format_string):
		s.format_string = format_string
	def __call__(s,_callable):
		def wrapper(*args,**kwargs):
			return s.format_string.format(_callable(*args,**kwargs))
		return wrapper
 
 
>>> debug_decorator = Formater('DEBUG : {}')
>>> class Foo(object):
	x = 'fooooo'
        @debug_decorator
	def dbg(s):
		return str(s.x)
 
 
>>> a=Foo()
>>> a.dbg()
'DEBUG : fooooo'

[tyrtamos]

Bonjour,

Dans ton exemple, tu n'as pas besoin d'avoir un décorateur sous forme de classe: une fonction suffit.

Code :

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

1
2
3
4
5
6
7
def inOut(fonc):
    def appelfonc(*args, **kwargs):
        print "start"
        result = fonc(*args, **kwargs)
        print "end"
        return result
    return appelfonc

Appliqué au reste de ton code, le résultat affiché est bien:

Code :

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

1
2
3
start
5
end

On utilise les décorateurs sous forme de classe lorsqu'on a à stocker des infos intermédiaires mises à jour à chaque appel.

[loichuss]

Ah ba oui j'aurais pas trouvé tout seul...

Il est vrai que l'utilisation d'une class dans mon cas n'est pas obligatoire. Je pense donc continuer avec une fonction.

Merci beaucoup N.tox et tyrtamos je vais regarder cela de plus pres afin de mieux comprendre

[N.tox]

Je pensais avoir mis un lien, mais j'ai de toute évidence oublié :[*]thread traitant du sujet[/list]