Discussion :

[sopsag]

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 :

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
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)?

[kango]

bonjour,

je peux te proposer ceci:

Code :

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

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.

[sopsag]

génial !

Voici ma version

Code :

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

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 :

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

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

[Zavonen]

Code python :

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

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),[])

[eyquem]

Code :

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

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

[dividee]

Code :

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

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 :

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

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.

[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.

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 :

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

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 :

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
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 :

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
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 :

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
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 :

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
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

[dividee]

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 :

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

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 ;)

[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,

Code :

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

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...