Syntaxe élégante pour une fusion de compréhension de liste

Version imprimable

Bonjour,

voici petit cas d'école :

j'ai une fonction qui renvoie une liste et je voudrait construire une liste qui soit la fusion (ou concaténation) des listes qu'elle renvoie.

Voici un petit code d'exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def get ( x ):
    # juste une fonction qui renvoie une liste (on se fiche de quoi...)
    return [ i*i for i in xrange( x,x+x/2 )]
 
def test1 ( n ):
    # construction par compréhension --> élégant mais pas ce que je veux... 
    return [ get( i ) for i in xrange( n ) ]
 
def test2 ( n ):
    # syntaxe lourde mais ce que je veux...
    res = []
    for i in xrange( n ):
        res += get( i )
    return res
 
print test1( 8 )
print test2( 8 )
 
[[], [], [4], [9], [16, 25], [25, 36], [36, 49, 64], [49, 64, 81]]
[4, 9, 16, 25, 25, 36, 36, 49, 64, 49, 64, 81]

A vous pythonistes chevronnés : comment obtenir ce que je veux (test2) avec une syntaxe légère et élégante (à la test1)?

20/08/2010, 17h39
kango
bonjour,

je peux te proposer ceci:
Code:

1 2 3 4 5 6 def extend(l1, l2): l1.extend(l2) return l1 def test(n): return reduce(extend, [get(i) for i in xrange(n)])
qui nécessite la création d'une fonction supplémentaire.

list.extend renvoie en fait None et ne peut pas être utilisée dans ce contexte comme argument de reduce.

:ccool: génial !

Voici ma version

Code:

1
2
def test3 ( n ):
    return reduce( lambda a,b : a.extend( b ) or a , [ get( i ) for i in xrange( n )])

peut être un trop compacte pour le coup...

Mais voici

Code:

1
2
3
def test4 ( n ):
    concat = lambda a,b : a.extend( b ) or a
    return reduce( concat , [ get( i ) for i in xrange( n )])

un peu plus lisible.

merci

Code:

1
2
3
4
5
6
7
8
9
10
def get ( x ):
    # juste une fonction qui renvoie une liste (on se fiche de quoi...)
    return [ i*i for i in xrange( x,x+x/2 )]
 
def test1 ( n ):
    # construction par compréhension --> élégant mais pas ce que je veux... 
    return [ get( i ) for i in xrange( n ) ]
 
print test1( 8 )
print sum(test1(8),[])

Code:

1
2
def hop(n):
    return [ i*i for x in xrange(n) for i in xrange( x,x+x/2 ) ]

Code:

1 2 3 4 5 6 >>> from itertools import chain >>> def test2(n): ... return list(chain(*(get(i) for i in range(n)))) ... >>> test2(8) [4, 9, 16, 25, 25, 36, 36, 49, 64, 49, 64, 81]
ou
Code:

1 2 3 4 5 >>> def test2(n): ... return list(chain.from_iterable(get(i) for i in range(n))) ... >>> test2(8) [4, 9, 16, 25, 25, 36, 36, 49, 64, 49, 64, 81]
list() est seulement nécessaire si tu souhaites vraiment avoir une liste au lieu d'un itérateur comme valeur de retour. Je préfère habituellement retourner l'itérateur, et laisser à l'appelant le soin d'appeler list() si nécessaire.

La solution de Zavonen (avec sum) est élégante, mais beaucoup plus lente.

Je connaissais chain() mais je ne m’en rappelais pas.
Cette fonction me plait bien, elle est susceptible d’être fort utile dans certains cas.
C’est une bonne chose d’évoquer les fonctions très utiles du module itertools.
Mais je pense qu’il est plus justifié d’utiliser chain() quand on doit faire une itération.

Dans le cas présent par exemple, le résultat de l’expression de Zavonen sum(test1(8),[]) me semble meilleure en donnant tout de suite le résultat de façon courte et sans avoir à faire un import ni créer une deuxième fonction test2().

—--------------------------------

Ma solution manque un peu de généricité. Mais on peut facilement lui en donner:

Code:

1
2
def hop(f,n):
    return [ f(i) for x in xrange(n) for i in xrange( x,x+x/2 ) ]

On peut même compliquer un peu en indiquant des arguments différents pour chaque valeur de x itérant dans xrange(n) :

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
def f(i,a,b):
    return float(i)*(abs(b-a))**(i/10.)
 
def g(i,a,b):
    return a/(float(i)-b+100)
 
def h(i,u,v):
    return min(u,v*i,3*u-2*v)
 
 
 
 
def hop2(func, n, argus):
    return [ func(i,a,b) for (x,(a,b)) in zip(xrange(n),argus)
             for i in xrange( x,x+x/2 )   ]
 
 
argus = ((4,6),(13,400),(2,4.1),(0.03,0.78),(0,0),(2.5,7),(0.8,-3),(1000,3000))
# len(argus) est 8
n = 5
print 'Avec n = '+str(n)+'\n'
for func in (f,g,h):
    print hop2(func,n,argus),'\ntaille = '+str(len(hop2(func,n,argus)))+'\n'
 
 
 
#---------------------------------------
print
longu = 0
for (x,(a,b)) in  zip(xrange(n),argus):
    print 'x = '+str(x)+'  range(x,x+x/2) = range('+\
          str(x)+','+str(x+x/2)+') = '+ repr(range(x,x+x/2)).ljust(10)
    longu += len(range(x,x+x/2))
print 'somme des longueurs des range(x,x+x/2) = '+str(longu)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Avec n = 5
 
[2.3199245173080025, 2.751944263927205, 0.0, 0.0] 
taille = 4
 
[0.020429009193054137, 0.00029348464097045585, 0.0, 0.0] 
taille = 4
 
[-2.1999999999999993, -1.47, 0, 0] 
taille = 4
 
 
x = 0  range(x,x+x/2) = range(0,0) = []        
x = 1  range(x,x+x/2) = range(1,1) = []        
x = 2  range(x,x+x/2) = range(2,3) = [2]       
x = 3  range(x,x+x/2) = range(3,4) = [3]       
x = 4  range(x,x+x/2) = range(4,6) = [4, 5]    
somme des longueurs des range(x,x+x/2) = 4

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Avec n = 7
 
[2.3199245173080025, 2.751944263927205, 0.0, 0.0, 10.606601717798211, 14.793766465655029, 13.366614050531597, 17.821594493116187, 23.276456406597077] 
taille = 9
 
[0.020429009193054137, 0.00029348464097045585, 0.0, 0.0, 0.025510204081632654, 0.025252525252525252, 0.007339449541284404, 0.007272727272727273, 0.007207207207207207] 
taille = 9
 
[-2.1999999999999993, -1.47, 0, 0, -6.5, -6.5, -18, -21, -24] 
taille = 9
 
 
x = 0  range(x,x+x/2) = range(0,0) = []        
x = 1  range(x,x+x/2) = range(1,1) = []        
x = 2  range(x,x+x/2) = range(2,3) = [2]       
x = 3  range(x,x+x/2) = range(3,4) = [3]       
x = 4  range(x,x+x/2) = range(4,6) = [4, 5]    
x = 5  range(x,x+x/2) = range(5,7) = [5, 6]    
x = 6  range(x,x+x/2) = range(6,9) = [6, 7, 8] 
somme des longueurs des range(x,x+x/2) = 9

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Avec n = 8
 
[2.3199245173080025, 2.751944263927205, 0.0, 0.0, 10.606601717798211, 14.793766465655029, 13.366614050531597, 17.821594493116187, 23.276456406597077, 1431.5912555890015, 3498.758636618491, 8417.236030403594] 
taille = 12
 
[0.020429009193054137, 0.00029348464097045585, 0.0, 0.0, 0.025510204081632654, 0.025252525252525252, 0.007339449541284404, 0.007272727272727273, 0.007207207207207207, -0.3456619426201175, -0.3457814661134163, -0.3459010722933241] 
taille = 12
 
[-2.1999999999999993, -1.47, 0, 0, -6.5, -6.5, -18, -21, -24, -3000, -3000, -3000] 
taille = 12
 
 
x = 0  range(x,x+x/2) = range(0,0) = []        
x = 1  range(x,x+x/2) = range(1,1) = []        
x = 2  range(x,x+x/2) = range(2,3) = [2]       
x = 3  range(x,x+x/2) = range(3,4) = [3]       
x = 4  range(x,x+x/2) = range(4,6) = [4, 5]    
x = 5  range(x,x+x/2) = range(5,7) = [5, 6]    
x = 6  range(x,x+x/2) = range(6,9) = [6, 7, 8] 
x = 7  range(x,x+x/2) = range(7,10) = [7, 8, 9] 
somme des longueurs des range(x,x+x/2) = 12

À quoi ça sert ?
Je n’en sais rien. Juste pour le fun :lefou:

21/08/2010, 02h40
dividee
Citation:

Envoyé par eyquem

Je connaissais chain() mais je ne m’en rappelais pas.
Cette fonction me plait bien, elle est susceptible d’être fort utile dans certains cas.
C’est une bonne chose d’évoquer les fonctions très utiles du module itertools.
Mais je pense qu’il est plus justifié d’utiliser chain() quand on doit faire une itération.

Je l'ai déjà écrit dans une autre discussion je crois, mais chain.from_iterable est un idiome Python pour "aplatir" une liste de listes. Dans beaucoup d'autres langages, cette fonction s'appelle flatten.
sum(LL, []) en est un autre, mais il est particulièrement inefficace. La différence est du même ordre que celle entre la concaténation de chaînes et la méthode join. A chaque sous-liste, il doit recopier tous les éléments déjà traités dans une nouvelle liste avant de rajouter les nouveaux. L'algorithme est donc O(n²) alors que chain.from_iterable est O(n).
Si tu veux tester:
Code:

1 2 3 4 5 6 >>>>>> LL = [[None]]*1000000 >>> len(list(chain.from_iterable(LL))) # après 1/4 de seconde 1000000 >>> len(sum(LL,[])) # sois patient ;)
23/08/2010, 12h22
sopsag
Merci pour cette quintessence de pur jus de crâne pythonifiant !

Au delà de la simple réponse à ma question, je découvre de nouveaux horizons...

Mais très concrètement,
Citation:
Envoyé par eyquem

Code:

1 2 def hop(n): return [ i*i for x in xrange(n) for i in xrange( x,x+x/2 ) ]
Ta solution est super courte mais elle brise l'abstraction de la fonction get.
Je te remercie pour tous tes exemples, mais cette fonction get avec son petit coté matheux n'était là que pour illustrer ma question.
Dans mon vrai code, elle ne ressemble pas du tout à ça...
En fait, ma vraie question était de savoir s'il y moyen de concaténer des listes au fur et à mesure qu'elles arrivent dans un boucle.
--> Voir mon exemple "# syntaxe lourde mais ce que je veux...".

Dans la mesure ou je n'ai jamais beaucoup de listes à concaténer, la version avec sum est finalement celle qui correspond le mieux à ce que je cherchais...