fonction non itérable

Version imprimable

Bonsoir,

J'essaye de rendre une fonction directement iterable. Le code ci-dessous marche pour une instance mais pas pour une fonction ! Pourquoi ? Voyez vous comment faire ?
Code:

1 2 3 4 5 6 7 8 9 10 def iterbug(): ipipo= lambda: iter((1,)) class X:pass x= X() x.__iter__= ipipo iter(x) # ca marche def f():pass f.__iter__= ipipo iter(f) # TypeError: 'function' object is not iterable
Merci d'avance

29/12/2013, 21h54
mont29

Je ne crois pas que rendre une fonction iterable ait beaucoup de sens… Je crois qu’il vaut mieux soit créer un objet “callable” qui soit aussi iterable, soit faire de la fonction un générateur (avec le mot-clé yield)!
29/12/2013, 21h59
fred1599

Je plussoie mont29, j'allais répondre la même chose, on peut itérer soit des conteneurs, soit des générateurs, voir la documentation...
29/12/2013, 22h12
shaiHulud

Citation:

Je ne crois pas que rendre une fonction iterable ait beaucoup de sens

Pourquoi ? Quelle différence avec le callable iterable que tu suggères ?

Dans mon cas, j'ai un framework qui itère récursivement sur des "taches" renvoyant des "taches" (par exemple des generateurs). Pouvoir inclure les fonctions dans ce framework d'itération a pour moi du sens. Cela étant, je reconnais que je pourrai transformer mon framework d'iterables en un framework de callable (et y inclure des iterable via leur .next)

Quoi qu'il en soit, j'ai un objet qui supporte le protocole iterable et que python ne reconnait pas comme tel. Comment ? Pourquoi ? Le protocole est il restreint aux instances ? coin-coin ?
30/12/2013, 00h50
fred1599

C'est logique, x est une instance d'une classe créée par tes soins, où tu implémentes une méthode spéciale __iter__.

Seulement une fonction est un objet spécifique python qui n'est pas créer avec la méthode spéciale __iter__.

Si tu veux créér un objet représentant une fonction sur mesure, il faudra là fabriquer sans doute avec la méthode __call__.
30/12/2013, 12h34
shaiHulud

Je ne trouve pas cela si logique ! Je n'ai pas vraiment implémenté une méthode __iter__, j'ai juste mis un attribut __iter__ (différent des autres méthodes spéciales nécessitant une vrai méthode et pas juste un attribut). Une fonction n'est pas un objet ? La doc précise

Citation:

objects of any classes you define with an __iter__() or __getitem__()

Je pensais que le duck typing était la règle pour savoir ce qui est itérable ou pas en Python. Ce n'est donc pas aussi simple que hasattr(x,'__iter__') !

Merci à tous les deux pour vos réponses !
30/12/2013, 12h55
mont29

Les fonctions sont des objets très particuliers, qui ne sont pas sensés contenir de données. Donc itérer dessus n’a pas de sens, et l’interpréteur considère que cette classe (function) n’est pas iterable (pas plus que ne le sera un int, un float, etc.). La seule différence, c’est que tu peux attribuer des membres arbitraires à une fonction, alors que c’est impossible pour les types basiques comme int ou float.
30/12/2013, 13h46
shaiHulud

Citation:

qui ne sont pas sensés contenir de données

Elle peut avoir des attributs ! Et quand bien même elle n'en contient pas, elle en renvoie (d'ailleurs un générateur ne contient pas de données non plus!)
Du coup, comment déterminer en Python si un objet est itérable ?

Voilà un exemple constituant un objet callable.

Je ne sais pas si c'est cela que tu cherches à faire, mais je vois rien d'autre

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> class A(object):
...     def __init__(self, function):
...         self.func = function
...     def __call__(self, *args):
...         self.args = args
...         return self.func(*self.args)
...     def __iter__(self):
...         return iter(self.args)
... 
>>> a = A(lambda x:x)
>>> a(12)
12
>>> iter(a)
<tupleiterator object at 0xb7441ccc>
>>> iter(a).next()
12

30/12/2013, 14h18
shaiHulud
C'est a peu près ce que je cherche à faire, avec la méthode __iter__
Code:

1 2 3 def __iter__(self): return iter(itertools.starmap(self.__call__,((),)))

Un peu dans ce genre

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class A:
    def __init__(self, func):
        self.func = func
    def __call__(self, *args):
        self.args = args
        for arg in self.args:
            yield self.func(arg)
    def __iter__(self):
        return iter(self.__call__(*self.args))
 
a = A(lambda x:x)
iterator = iter(a(12, 5, 9))
for val in iterator:
    print val

30/12/2013, 15h39
shaiHulud

Oui, je veux transformer une fonction en un générateur qui yield une fois f().

Mais ce sont surtout les performances qui m'inquiètent : un __call__ + un générateur complètement inutile car on appelle la fonction une fois (même si on l'appelait plusieurs fois, ça serait à l'identique, sans avoir besoin d'en conserver la mémoire interne)...

iter(itertools.starmap(f,((),))) sera infiniment plus rapide que la generatorfunction A(f).__call__() que tu proposes; surtout si f est builtin
30/12/2013, 17h09
fred1599

itertools.starmap(f,((),)) est strictement identique à ma méthode spéciale __call__, la résultante est un générateur.

iter(itertools.starmap(f,((),)), on en revient strictement au même que iter(self.__call__(*self.args)), seulement oui la fonction iter() est inutile dans un sens comme dans l'autre, car on l'itère avec une boucle for ou un next().

Du coup si tu dégages ta fonction iter() et ma méthode spéciale __iter__, le résultat sera strictement identique.

Sois tu crées un itérateur, soit un générateur, mais pas les deux...

Si tu le fais sur ma méthode spéciale __iter__, dans ce cas on écrase la fonction next pour la mettre à sa sauce.

Si tu veux un générateur, tu utilises le mot clé yield.

Je n'ai pas l'impression !

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
import time
from collections import *
from itertools import *
class A:
    def __init__(self, func):
        self.func = func
    def __call__(self, *args):
        self.args = args
        for arg in self.args:
            yield self.func(arg)
f= object #builtin fonction à itérer
 
N= 10000
t0= time.clock()
[deque(A(f)(),maxlen=0) for k in xrange(N)]
t1= time.clock()
print "class", t1-t0
t0= time.clock()
[deque(starmap(f,((),)),maxlen=0) for k in xrange(N)]
t1= time.clock()
print "starmap" t1-t0

Citation:

N= 10000
class 0.0178
starmap 0.0099

N= 1000000
class 2.15
starmap 1.27

Et même sans ré-instancier A(f) à chaque fois, ça n'est pas équivalent. Tu payes forcément l'accès à l'attribut func et le wrappage dans __call__ + le fait que ce soit un generateur

Par contre je n'arrive pas à faire marcher

Code:

1
2
3
4
5
6
7
8
9
10
11
 
class B:
    def __init__(self, func):
        self.func = func
    def __iter__(self):
        return self        
    def next(self):
        return self.func()
from functools import partial
exhaust= partial(deque,maxlen=0)
[exhaust(iter(B(f))) for k in xrange(N)]