Générateurs en folie !

Version imprimable

Bonjour,

en voulant coder un petit truc de math sur les suites, je suis tombé sur un comportement que je ne m'explique pas :

J'ai un générateur A d'int (ie un fonction qui fait des yield et avec laquelle on peut faire for i in A(): ).

J'ai un autre générateur d'int D qui prend en paramètre un générateur d'int et qui renvoie la différence entre 2 éléments consécutifs de ce dernier.

J'aimerais fabriquer un troisième générateur qui ferait des appels récursifs des 2 précédents...

Bon, si ce n'est pas super clair, voici un exemple simplifié qui synthétise mon problème :

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
def A ( nb ):  # générateur d'int tout simple
    for i in xrange( nb ):
        yield i*i*i
 
def D ( suite ):  # générateur qui calcule la "dérivée" d'un autre générateur
    p = None
    for i in suite :
        if p is not None :
            yield i-p
        p = i
 
def print_suite ( suite ): # outil d'affichage
    print suite,'--->',
    for n in suite :
        print n,
    print             
 
def test1 ( nb ):  # fonction qui fait ce que je veux mais avec une profondeur de récursion codée "en dur"
    print_suite( A( nb ))
    print_suite( D( A( nb )))
    print_suite( D( D( A( nb ))))
    print_suite( D( D( D( A( nb )))))
 
def test2 ( nb,prof ):  # fonction qui devrait faire ce que je veux, mais en fait non...
    suite = A( nb )
    for i in xrange( prof ):
        print_suite( suite )
        suite = D( suite )
 
def test3 ( nb,prof ):  # autre tentative qui ne fonctionne pas non plus...
    suites = [A( nb )]
    for i in xrange( prof ):
        suites += [D( suites[-1] )]
    for s in suites :
        print_suite( s )
 
test1( 20 )    
test2( 20,4 )    
test3( 20,4 )

ce qui me donne l'affichage suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
<generator object A at 0x025D7F30> ---> 0 1 8 27 64 125 216 343 512 729 1000 1331 1728 2197 2744 3375 4096 4913 5832 6859
<generator object D at 0x025D7F58> ---> 1 7 19 37 61 91 127 169 217 271 331 397 469 547 631 721 817 919 1027
<generator object D at 0x025D7E90> ---> 6 12 18 24 30 36 42 48 54 60 66 72 78 84 90 96 102 108
<generator object D at 0x025D7F80> ---> 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6
<generator object A at 0x025D7F80> ---> 0 1 8 27 64 125 216 343 512 729 1000 1331 1728 2197 2744 3375 4096 4913 5832 6859
<generator object D at 0x025D7F58> --->
<generator object D at 0x025D7F80> --->
<generator object D at 0x025D7F58> --->
<generator object A at 0x025D7F80> ---> 0 1 8 27 64 125 216 343 512 729 1000 1331 1728 2197 2744 3375 4096 4913 5832 6859
<generator object D at 0x025D7F30> --->
<generator object D at 0x025D7F58> --->
<generator object D at 0x025D7E90> --->
<generator object D at 0x025D7FA8> --->

test1 fait bien ce que j'attends, mais il ne me permet pas de passer la profondeur de la récursion en paramètre. test2 et test3 le permettent mais ne fonctionnent pas : comme on voit, à part la première suite, ils n'affichent rien.

Je pense que je n'ai pas tout compris à propos des générateurs...

Si quelqu'un comprend pourquoi test2 et test3 ne font pas comme test1, ou comment coder une fonction qui fait comme test1 mais permet de choisir la profondeur de la récursion...

Merci d'avance

Dans tes fonctions 2 et 3, tu consommes à chaque fois le premier générateur (A()), avant de consommer les suivants, qui travaillent donc sur rien.

C’est une limitation connue des générateurs, il n’y a pas de moyen satisfaisant de les copier (cf. aussi http://bugs.python.org/issue11299).

La solution la plus simple dans ton cas est de n’afficher que le dernier itérateur*!

On peut utiliser itertools.tee(), mais celui-ci se contente de copier dans un cache interne les éléments générés par la copie la plus “en avance”, tant qu’ils n’ont pas été consommés par la copie la plus “en retard”, ce qui enlève l’un des principaux intérêts des générateurs (ne pas encombrer la mémoire).

Une autre solution (probablement adaptée à ton cas) consiste à utiliser des fonctions génératrices de générateurs (:mouarf:), ce qui pourrait donner ici:
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 def A ( nb ): # générateur d'int tout simple for i in xrange( nb ): yield i*i*i def D ( suite ): # générateur qui calcule la "dérivée" d'un autre générateur p = None for i in suite : if p is not None : yield i-p p = i def print_suite ( suite ): # outil d'affichage print suite,'--->', for n in suite : print n, print def _gen_n(nb, prof): gen = A(nb) for i in xrange(prof): gen = D(gen) return gen def test4(nb, prof): for i in xrange(prof): print_suite(_gen_n(nb, i)) test1( 20 ) test2( 20,4 ) test3( 20,4 ) test4( 20,4 )
Code:

1 2 3 4 <generator object A at 0x2710dc0> ---> 0 1 8 27 64 125 216 343 512 729 1000 1331 1728 2197 2744 3375 4096 4913 5832 6859 <generator object D at 0x2710d70> ---> 1 7 19 37 61 91 127 169 217 271 331 397 469 547 631 721 817 919 1027 <generator object D at 0x2710c80> ---> 6 12 18 24 30 36 42 48 54 60 66 72 78 84 90 96 102 108 <generator object D at 0x2710c30> ---> 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6

16/12/2013, 13h45
Captain'Flam

arf ! j'ai compris, j'ai corrigis et ça a marchi !

En fait c'est mon print_suite que me "consomme" mes générateurs...

Merci :ccool: