tester si fonction avec return a été exécutée

Version imprimable

Voir 40 message(s) de cette discussion en une page

Developpeurs, Bonjour!

J'aimerais savoir si une fonction a été exécutée ou pas et le cas échéant, récupérer les return en résultant :
Python 3.2

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
def test () :
    a = 10
    b = (20, 30)
    return ( a , b )
 
class ClassTest :
    # j aimerais entrer dans la boucle if que si test a ete executee    
    if test :
        print ( "ok mais je ne sais pas si test a ete executee?" )
        print ( "comment recuperer les return de test ici -sans utiliser global ?" )
 
    else :
        print ( "no" )

Merci pour toute info !

07/08/2011, 09h24
tyrtamos

Bonjour,

A mon avis, on devrait pouvoir faire ça avec un décorateur écrit sous forme de classe.

L'avantage de ce type de décorateur, c'est qu'il peut conserver des infos après chaque appel, par exemple sous forme de dictionnaire. On peut donc tester à n'importe quel endroit du code s'il y a eu un appel (dictionnaire non vide), et si oui, d'obtenir les résultats dans l'ordre où ils ont été obtenus. On peut aussi en même temps conserver les arguments passés à chaque appel.

Et si ce décorateur était utilisé pour décorer plusieurs fonctions du code, il pourrait conserver dans une variable de classe tous les appels avec pour chaque appel le nom de la fonction appelée, les arguments et le résultat de l'appel, le tout dans l'ordre des appels. Bref, c'est très puissant.

J'ai fait un tuto sur le sujet: http://python.jpvweb.com/mesrecettes...ateurs_modeles. Attention: c'est du Python 2.7.

Essaie de faire, et reviens ici si tu n'y arrives pas.

Tyrtamos
07/08/2011, 09h30
PauseKawa

Bonjour,

+1 pour les décorateurs.

Une autre idée est que la valeur par défaut d'un argument n'est évalué qu'une fois. A partir de là il est possible d'utiliser une liste en arguments pour stocker les résultats.
Comprendre que comme cela on a les résultats dans l'ordre ou la fonction a été appelée ainsi que le nombre de fois (len de la liste).

une combinaison avec un décorateur est intéressante non ?

@+

Edit: Pour ce qui est du titre une fonction fait toujours un return.
07/08/2011, 12h00
VinsS
Bonjour,

Peut-être que avec des parenthèses à test cela irait un peu mieux:
Code:

1 2 3 4 class ClassTest : # j aimerais entrer dans la boucle if que si test a ete executee if test :
Ici la condition est vraie parce que test existe dans l'espace de nom global, du moins dans l'exemple et n'est pas nul. Donc les deux print doivent s'exécuter à tous les coups. Mais test n'est pas appelée.
Code:

1 2 3 4 class ClassTest : # j aimerais entrer dans la boucle if que si test a ete executee if test ():
Comme ceci, test sera appelée, mais dans ton exemple, test renvoie toujours la même chose, on suppose qu'elle pourrait retourner False dans certains cas sinon c'est sans intérêt bien sûr.
07/08/2011, 12h38
VinsS

Je repense à python 3 et il m'est venu un doute, comme je l'utilise peu.

Donc j'ai testé, et je confirme

Citation:

vincent@tiemoko:~/Bureau$ python test.py
ok mais je ne sais pas si test a ete executee?
comment recuperer les return de test ici -sans utiliser global ?
vincent@tiemoko:~/Bureau$ python3 test.py
ok mais je ne sais pas si test a ete executee?
comment recuperer les return de test ici -sans utiliser global ?
07/08/2011, 12h53
PauseKawa

Je ne vois pas l’intérêt de tester if test() ou alors je n'ai pas compris la question.
De plus regarder dans les namespaces ne sert à rien (sans utiliser global ?) puisque a = test() / a = le return de test.

Autre chose

Code:

1
2
3
4
5
6
7
8
9
10
>>> def test():
...     pass
...     # return None implicite
... 
>>> if test():
...     print('ok')
... else:
...     print("Ah bon non, c'est None")
... 
Ah bon non, c'est None

07/08/2011, 13h06
fred1599

Citation:

Je ne vois pas l’intérêt de tester if test() ou alors je n'ai pas compris la question.

ça peut, mais pas dans ce cas en effet, par contre un return peut renvoyer une liste vide ou non, renvoyer True ou False, tuples vides ou non, etc...
07/08/2011, 14h04
PauseKawa

Aussi. Je voulais juste souligner (par rapport au titre) qu'en Python il n'y as pas de 'procédure'/'fonction'. Une fonction retourne toujours quelque chose, même si c'est None.
Mon questionnement c'est sur la réponse de VinsS (qui connais ses bases). Ou veux t'il en venir ?
07/08/2011, 14h24
fred1599
Pas toujours, on va dire que la normalité veut que se soit le cas, mais on peut tout aussi bien ne rien retourner
Code:

1 2 3 4 5 6 7 8 >>> def test(c): ... global var ... var = c ... >>> var = 12 >>> test(5) >>> var 5
Pour un dictionnaire, on peut lui attribuer clé et valeur sans retourner de valeur à la fin de la fonction, par exemple.
Code:

1 2 3 4 5 6 7 8 9 >>> def attribuer(a, b): ... dico[a] = b ... >>> dico = {} >>> for i, j in enumerate(["a", "b", "c", "d"]): ... attribuer(i, j) ... >>> dico {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
Citation:

Mon questionnement c'est sur la réponse de VinsS (qui connais ses bases). Ou veux t'il en venir ?

J'admets ne pas avoir tout compris non plus :)

Bonjour,

Voilà une solution avec un décorateur (Python 2.7):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import functools
 
###################################################
class mondecorateur(object):
    """ decorateur qui stocke les résultats d'appels des fonctions décorées """
    adrinst = {} # stocke les noms des fonctions décorées et l'adresse de l'instance de leur décorateur
    def __init__(self, fonc):
        self.fonc = fonc
        self.__class__.adrinst[fonc.func_name] = self # initialise adrinst
        functools.wraps(fonc)(self)
        self.nbappels = 0
        self.resultats = {}
    def __call__(self, *args, **kwargs):
        """ méthode appelée à chaque appel de la fonction décorée """
        # instructions avant l'appel de la fonction décorée
        result = self.fonc(*args, **kwargs)
        # instructions après l'appel de la fonction décorée
        self.nbappels += 1
        self.resultats[self.nbappels] = result
        return result

Utilisation:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@mondecorateur
def test (a,b) :
    return (a, b)
 
print mondecorateur.adrinst['test'].nbappels
print mondecorateur.adrinst['test'].resultats
 
test(1,2)
 
print mondecorateur.adrinst['test'].nbappels
print mondecorateur.adrinst['test'].resultats
 
test(5,7)
 
print mondecorateur.adrinst['test'].nbappels
print mondecorateur.adrinst['test'].resultats
 
test(9,3)
 
print mondecorateur.adrinst['test'].nbappels
print mondecorateur.adrinst['test'].resultats

Ce qui donne:

Code:

1
2
3
4
5
6
7
8
0
{}
1
{1: (1, 2)}
2
{1: (1, 2), 2: (5, 7)}
3
{1: (1, 2), 2: (5, 7), 3: (9, 3)}

On voit qu'au fur et à mesure des appels, le dictionnaire des résultats s'agrandit. On peut donc à n'importe quel moment récupérer le nombre d'appels réalisés, et dans l'ordre tous les résultats successivement obtenus.

Et si dans le même code on veut suivre une autre fonction, test2() par exemple, le même décorateur fonctionnera de la même façon sans qu'on ait à le réécrire, et le dictionnaire des résultats de ses appels sera obtenu par: mondecorateur.adrinst['test2'].resultats

Tyrtamos

Bonjour,

Et en plus simple ?

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#
#
class decorateur(object):
    def __init__(self, fonc=None, d={}):
        self.fonc = fonc
        self.d = d
    def __call__(self, *args, **kwargs):
        result = self.fonc(*args, **kwargs)
        if self.fonc.__name__ in self.d:
            self.d[self.fonc.__name__].append(result)
        else:
            self.d[self.fonc.__name__] = [result]
        return result
    def getitem(self, name):
        if name in self.d:
            return self.d[name]
    def getitemlen(self, name):
        if name in self.d:
            return len(self.d[name])
    def getmembers(self):
        return list(self.d.keys())
 
@decorateur
def Foo(a, b):
    return a*b
 
@decorateur
def Foo1(a, b):
    return a-b
 
Foo(1, 5)
Foo(5, 5)
 
print("Valeurs de Foo :", decorateur().getitem('Foo'))
print("Nombre de valeurs pour Foo :", decorateur().getitemlen('Foo'))
 
Foo1(5, 3)
 
d = decorateur()
 
print("Valeurs de Foo1 :", decorateur().getitem('Foo1'))
print("Nombre de valeurs pour Foo1 :", decorateur().getitemlen('Foo1'))
 
 
print("Valeurs de Foo2 :", d.getitem('Foo2'))
print("Nombre de valeurs pour Foo2 :", d.getitemlen('Foo2'))
 
print("Fonctions utilisées", d.getmembers())

Output

Code:

1
2
3
4
5
6
7
Valeurs de Foo : [5, 25]
Nombre de valeurs pour Foo : 2
Valeurs de Foo1 : [2]
Nombre de valeurs pour Foo1 : 1
Valeurs de Foo2 : None
Nombre de valeurs pour Foo2 : None
Fonctions utilisées ['Foo', 'Foo1']

C'est bien sur moins joli mais sans doute plus compréhensible non ?

@+

Edit: Erreur dans le code (None inutile, passé en default value), rectifié.

07/08/2011, 19h17
santaflam

Merci pour vos réponses!

@VinsS: pas possible de faire if test(): car j'exécuterais la fonction dans ce cas. Je veux seulement récupérer les return dans le cas où elle aurait été exécutée. J avais mis if test : de manière générique, en sachant que ça ne teste pas si elle a été exécutée ou pas.

La classe décorateur va certainement résoudre mon cas (faut que je potasse un peu, je débute). Et tester en Python 3.2, auquel je suis lié parce que c'est pour un script de l'appli graphique Blender. Je donnerai donc un feedback à cet égard.

La fonction test fait des calculs et renvoie listes et dicos. La classe est une classe de UI dans laquelle j'affiche les résultats des return.
07/08/2011, 20h42
VinsS

Citation:

Envoyé par VinsS

vincent@tiemoko:~/Bureau$ python test.py
ok mais je ne sais pas si test a ete executee?
comment recuperer les return de test ici -sans utiliser global ?
vincent@tiemoko:~/Bureau$ python3 test.py
ok mais je ne sais pas si test a ete executee?
comment recuperer les return de test ici -sans utiliser global ?

J'explique, ceci est le test du code de base TEL QUEL avec python 2 et 3 et démontrait que

if test:

sera toujours vrai puisque test est un objet non nul.

Mon explication était que pour vérifier le retour de 'def test' les parenthèses étaient indispensables et, ceci entendait bien sur que l'exemple donné avait été simplifié mais que 'def test()' aurait pu retourner autre chose que dans l'exemple bien sur

Citation:

Envoyé par VinsS

... mais dans ton exemple, test renvoie toujours la même chose, on suppose qu'elle pourrait retourner False dans certains cas sinon c'est sans intérêt bien sûr.

Nous sommes bien d'accord que l'exemple donné est un code qui ne sert à rien

Citation:

Envoyé par santaflam

... Je veux seulement récupérer les return dans le cas où elle aurait été exécutée.

Santaflam, nous sommes bien d'accord que le return "s'adresse à quelqu'un en réponse à sa question", non ?

Tu ne peux vérifier le contenu d'un return qu'en exécutant la fonction qui le génère. Les décorateurs dont on te parle, opportunément j'en conviens ne font pas autre chose q'appeler test() eux aussi.

Autre solution, si ta fonction test était elle aussi dans une classe et ses données résultantes des attributs-arguments de cette classe, tu te simplifierais la vie.

Citation:
Envoyé par PauseKawa
Autre chose
Code:

1 2 3 4 5 6 7 8 9 10 >>> def test(): ... pass ... # return None implicite ... >>> if test(): ... print('ok') ... else: ... print("Ah bon non, c'est None") ... Ah bon non, c'est None
Le cas présent c'est : 'if test:' pas 'if test():'

07/08/2011, 23h45
santaflam

Citation:

Envoyé par VinsS

Tu ne peux vérifier le contenu d'un return qu'en exécutant la fonction qui le génère

Il y a peut-être ambiguité dans mon explication: je veux vérifier si la fonction a été exécutée antérieurement. Si oui, j'en prends les return, si non je passe.
Vérifier le type du contenu de return (True False, liste ou autre) ne m'intéresse pas. En ceci ma fonction test simplifiée ici, colle à mon cas, car si la fonction s'exécute elle retourne de tte façon 2 éléments.
En aucun cas je ne peux, dans cette boucle if, exécuter la fonction, car celle-ci m'affiche une géométrie, et dans le cas où la fonction a déjà été exécutée j'aurais donc 2 fois la géométrie à l'écran (...).

Maintenant ma vision n'est peut-être pas réalisable, s'il faut réellement exécuter la fonction pour voir si elle a déjà été exécutée (je peux pas le dire autrement), alors faudra que je change le concept...
Sans doute comme suit en effet :

Citation:

Envoyé par VinsS

Autre solution, si ta fonction test était elle aussi dans une classe et ses données résultantes des attributs-arguments de cette classe, tu te simplifierais la vie.

Merci pour les idées !
08/08/2011, 01h47
fred1599
Citation:

Il y a peut-être ambiguité dans mon explication: je veux vérifier si la fonction a été exécutée antérieurement. Si oui, j'en prends les return, si non je passe.

C'est plus une ambiguïté à ce niveau, pour tester une fonction, faut bien qu'elle retourne quelque-chose.

à la rigueur:
Code:

1 2 3 4 5 6 def test(a, b): yield (a, b) liste = [(i, j) for i, j in test(4, 5)] if liste: # exécuter fonction
else:
# si liste vide, traitement

Citation:

Maintenant ma vision n'est peut-être pas réalisable, s'il faut réellement exécuter la fonction pour voir si elle a déjà été exécutée (je peux pas le dire autrement), alors faudra que je change le concept...

Je suppose... Car pour vérifier qu'une fonction s'est exécutée, il faut l'exécuter ;)

Citation:

Autre solution, si ta fonction test était elle aussi dans une classe et ses données résultantes des attributs-arguments de cette classe, tu te simplifierais la vie.

C'est une solution pas obligatoire, mais qui a l'avantage de rendre les choses propres et organisées.

Bonjour,

Citation:

Envoyé par santaflam

Il y a peut-être ambiguité dans mon explication: je veux vérifier si la fonction a été exécutée antérieurement. Si oui, j'en prends les return, si non je passe.

Citation:

Envoyé par santaflam

En aucun cas je ne peux, dans cette boucle if, exécuter la fonction, car celle-ci m'affiche une géométrie, et dans le cas où la fonction a déjà été exécutée j'aurais donc 2 fois la géométrie à l'écran (...)

Est ce a dire que vous voulez que votre fonction soit appelée librement une seule fois (affichage de la géométrie) et que vous souhaitez intercepter les appels (et return) suivant ?
Comme ceci ?
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 32 #!/usr/bin/env python # -*- coding: UTF-8 -*- # # class interceptor(object): def __init__(self, fonc=None, d={}): self.fonc = fonc self.d = d def __call__(self, *args, **kwargs): if self.fonc.__name__ in self.d: result = self.fonc(*args, **kwargs) self.d[self.fonc.__name__].append(result) return else: result = self.fonc(*args, **kwargs) self.d[self.fonc.__name__] = [result] # Ou self.d[self.fonc.__name__] = [] # si le premier résultat est indifférent. return result def getvalues(self, name): if name in self.d: return self.d[name] @interceptor def Foo(a, b): return a*b print(Foo(1, 2)) print(Foo(2, 2)) print(Foo(4, 2)) i = interceptor() print(i.getvalues('Foo'))
@+

Edit: Vous pouvez aussi faire en sorte que la fonction se bloque elle même.
Code:

1 2 3 4 5 6 7 8 9 >>> def Foo(a, b, l=[]): ... if len(l) == 0: ... l.append('1') ... return a*b ... >>> Foo(2, 3) 6 >>> Foo(2, 3) >>> Foo(2, 3)
A vous de voir si le return vous intéresse de faire un else et de récupérer les résultats.

@++

Autre approche

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> def Foo(a, b, l=[]):
...     result = a*b
...     l.append(result)
...     if len(l) == 1:
...         return result
... 
>>> Foo(1, 2)
2
>>> Foo(1, 2)
>>> Foo.__defaults__
([2, 2],)
>>> Foo(1, 2)
>>> Foo.__defaults__
([2, 2, 2],)

@++

J"allais oublier la condition

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> def Foo(a, b, l=[]):
...     result = a*b
...     l.append(result)
...     if len(l) == 1:
...         return result
...
>>> Foo.__defaults__[0]
[]
>>> if len(Foo.__defaults__[0]):
...     print('ok')
...
>>> Foo(1, 2)
2
>>> if len(Foo.__defaults__[0]):
...     print('ok')
...
ok

Voir 40 message(s) de cette discussion en une page