Discussion :

[alcibiade]

Bonjour tout le monde,
Je veux créer une liste de ce type:
M=[ [1,2,3],[4,5,6]]

J'ai eu plusieurs idées (mauvaises!!) comme:

Code :

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

1
2
3
4
5
 
M=[]
for x in range(2):
M.append([])
M[x]=x+1,x+2,x+3

cela me donne

Code :

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

1
2
 
[(1, 2, 3), (2, 3, 4)]

Déjà pourquoi des parenthèses j'aimerais bien savoir??

Ensuite j'ai eu comme idée:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
>>> for x in range(1,7):
...     M.append([x,x+1,x+2])
... 
>>> M
[[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8]]
>>> M=M[::3]
>>> M
[[1, 2, 3], [4, 5, 6]]
>>>

Mais comme vous voyez c'est artificiel et pas très convaincant. J'ai cherché d'autre solutions mais toutes aussi veines. La difficulté c'est que je ne comprend pas comment x peu prendre la valeur 4,5,6 apres avoir pris 1,2,3.
Toute aide serait la bienvenue je vous remercie d'avance

[Antoine_935]

Salut

Voici un petit exemple Ce n'est, bien entendu, pas la seule manière de faire.

Code :

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

1
2
3
4
5
6
7
8
>>> liste = [] # Créer une liste vide
>>>
>>> for i in xrange(10):
...     liste.append([x for x in range(i * 3, (i + 1) * 3)])
...
>>> liste
[[0, 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]]

Si tu veux commencer à 1 et finir à 30:

Code :

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

[x + 1 for x ...]

[alcibiade]

J'ai déjà bien avancé, mais si je veux faire la même chose sans la fonction xrange. Juste avec range. Je pense qu'il faut reprendre l'idée du for à l'intérieur des [] mais avec range tout seul ça ne marche pas pourquoi?

[tyrtamos]

Bonjour,

Et comme ça:

Code :

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

1
2
3
4
 
print [[i, i+1, i+2] for i in xrange(0,20,3)]
 
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13, 14], [15, 16, 17], [18, 19, 20]]

Sinon, xrange et range font la même chose dans une boucle for, c'est à dire renvoient la valeur suivante à chaque boucle (ce sont des "itérateurs"). La seule différence est que range fabrique une liste complète en début de boucle, ce que ne fait pas xrange.

Par contre, en dehors d'une boucle for, range() permet de construire directement une liste (print range(0,5) => [0, 1, 2, 3, 4]), ce que ne permet pas xrange().

Tyrtamos

[nardo47]

Salut !

J'ai eu plusieurs idées (mauvaises!!) comme:

Code :

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

1
2
3
4
5
 
M=[]
for x in range(2):
M.append([])
M[x]=x+1,x+2,x+3

Pas loin d'être bon. Il aurait suffi d'écrire à la place de ta dernière ligne :

Code :

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

1
2
 
M[x] = [x+1, x+2, x+3]

ou mieux, à la place des 2 dernières lignes:

Code :

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

1
2
 
M.append([x+1, x+2, x+3])

Après, tu aurais eu M=[[1, 2, 3], [2, 3, 4]], mais c'est un problème qui se serait résolu en utilisant l'argument step de range (ce que fait Tyrtamos).

cela me donne

Code :

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

1
2
 
[(1, 2, 3), (2, 3, 4)]

Déjà pourquoi des parenthèses j'aimerais bien savoir??

C'est ce qu'on appelle en Python des tuples.
Il s'agit d'une liste immutable (qu'on ne peut modifier).
Python rajoute des parenthèses quand il voit des valeurs séparées par des virgules. Ce petit truc permet des choses bien sympathiques, du genre le retour de plusieurs variables par une fonction. E.g.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
>>> def retourmultiple():
...     return 1, 2 # On pourrait écrire aussi return (1, 2) mais Python le fait tout seul.
...
>>> a, b = retourmultiple()
>>> a
1
>>> b
2
>>> x = retourmultiple()
>>> x
(1, 2)

Il me semble que l'habitude est prise ici de donner comme référence le tuto de Gérard Swinnen pour toute explication, tuto que tu trouveras dans la page "Tutoriels Python" (le bouton en haut de cette page).

Ensuite j'ai eu comme idée:

Code :

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

1
2
3
4
5
 
>>> for x in range(1,7):
...     M.append([x,x+1,x+2])
... 
>>> M=M[::3]

Mais comme vous voyez c'est artificiel et pas très convaincant.

Effectivement, même si on voit bien que tu as de la ressource.

La solution de Tyrtamos est, à mon humble avis, la meilleure pour ton problème.

J'ajouterais que l'utilisation de xrange est préférable, à tel point que Python3 supprime la fonction range et renomme xrange en range.

[josmiley]

y a ça aussi ...

Code :

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

[range(i,i+3) ]for i in range(1,31,3)]

[eyquem]

Allez, à mon tour:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def M1(n,N):
    return map(lambda a: range(a,a + n), xrange(1, N*n+1,n))
 
def M2(n,N):
    return map(lambda a:range(1+n*a,1+n*(a+1)), xrange(N))
 
def M3(n,N):
    import numpy as np
    F = array(range(1,n+1))
    A = array([n for i in range(n)])
    return [ list(F + i*A) for i in xrange(N)]
 
for f in (M1,M2,M3):
    print f(2,8),'\n',f(3,4),'\n',f(5,4),'\n'

Code :

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

1
2
3
4
5
6
7
8
9
10
11
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, 14]] 
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]] 
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20]] 
 
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, 14]] 
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]] 
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20]] 
 
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, 14]] 
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]] 
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]

[eyquem]

J'ai cherché une solution de découpe d'une première liste ne contenant que les valeurs:

par exemple
n,N = 2,4
xrange(1,n*N + 1) est [1, 2, 3, 4, 5, 6, 7, 8]
et j'ai cherché une fonction qui isole les éléments de cette liste par groupes de 2

Mais en restant dans Python, je n'ai pas trouvé.
Suis intéressé si quelqu'un sait.




Dans numpy, cette approche est facile. Et la plus lisible, je trouve.

Code :

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

1
2
3
4
from numpy import *
 
n,N = 3,5
print [ list(row) for row in (arange(n*N) + 1).reshape(N,n)]

Résultat

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

Explications:
par exemple avec n,N = 3,5

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
 
arange(n*N) crée un tableau 
[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ]
 
arange(n*N) + 1 donne
[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ]
 
(arange(n*N) + 1).reshape(5,3) réorganise en
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]
 [13 14 15]]
 
row en est une ligne
list(row) fait de row une liste (virgules)

[dividee]

J'ai cherché une solution de découpe d'une première liste ne contenant que les valeurs:

par exemple
n,N = 2,4
xrange(1,n*N + 1) est [1, 2, 3, 4, 5, 6, 7, 8]
et j'ai cherché une fonction qui isole les éléments de cette liste par groupes de 2

Mais en restant dans Python, je n'ai pas trouvé.
Suis intéressé si quelqu'un sait.

Voilà:

Code :

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

1
2
3
4
5
>>> from itertools import groupby
>>> l
[1, 2, 3, 4, 5, 6, 7, 8]
>>> [list(v) for _,v in groupby(l, lambda x : (x-1)//2)]
[[1, 2], [3, 4], [5, 6], [7, 8]]

[eyquem]

Salut dividee,



Je connaissais groupby() mais j’ai trouvé cette fonction disproportionnée pour cette résolution parce que groupby() retourne un objet trop sophistiqué pour l’objectif somme toute assez sommaire.

L’objet renvoyé par groupby(iterable,fonction) est d'un type spécial 'itertools.groupby'
C’est une collection de tuples (clé, groupe)
dont le premier élément est un résultat de la fonction utilisée comme clé sur les éléments de l’itérable,
et le second élément est encore un objet inusuel constituant un rassemblement que l’on est obligé de passer à la moulinette de list() ou tuple() si on veut en obtenir quelque chose.

Il faut notamment, en plus de l’itérable, disposer d’une fonction pour faire les regroupements. Fonction qui ne peut être trouvée que dans des cas simples comme le cas en question.

Or j’aimerais bien voir quelle fonction permettrait de découper la liste suivante en sous-listes:
li = [77,33,'huit','soleil',2356,('a','z'),34,289,'orange',[1,3,5,2],1000,'fin'] ??
Aucune des solutions que nous avons proposées jusqu’à présent ne permet de le faire, me semble-t-il.


Je souhaitais trouver un procédé qui ne fasse véritablement que découper la liste, c’est à dire en se limitant à sectionner la liste en traitant ses éléments les uns après les autres, sans rien de plus.
J'ai finalement réussi à trouver des solutions pour le faire, même pour une liste hétérogène et non totalement numérique comme celle ci-dessus.
Je ne crois pas qu’on puisse faire plus court que la dernière solution.

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
li = [77,33,'huit','soleil',2356,('a','z'),34,289,'orange',[1,3,5,2],1000,'fin']
 
def M(li,n):
    return [ [li[j] for j in xrange(i,i+n)] for i in xrange(0,len(li),n) ]
print M(li,3)
 
 
def M(li,n):
    it = iter(li)
    return [ [it.next() for k in xrange(n)] for i in xrange(0,len(li),n) ]
print M(li,4)
 
def M(li,n):
    it = iter(li)
    return [ [it.next() for k in xrange(n)] for i in li[::n] ]
print M(li,2)

[[77, 33, 'huit'], ['soleil', 2356, ('a', 'z')], [34, 289, 'orange'], [[1, 3, 5, 2], 1000, 'fin']]

[[77, 33, 'huit', 'soleil'], [2356, ('a', 'z'), 34, 289], ['orange', [1, 3, 5, 2], 1000, 'fin']]

[[77, 33], ['huit', 'soleil'], [2356, ('a', 'z')], [34, 289], ['orange', [1, 3, 5, 2]], [1000, 'fin']]

[eyquem]

Code :

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

li[j] for j in xrange(i,i+n)]

n’importe quoi.........................

comme si ça n’était pas

Code :

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

li[i:i+n]

Mon dernier mot sera donc

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
li = [77,33,'huit','soleil',2356,('a','z'),34,289,'orange',[1,3,5,2],1000,'fin']
print li
print
 
def M(li,n):
    return [ li[i:i+n] for i in xrange(0,len(li),n) ]
 
print M(li,3)
print
print M(li,4)
print
print M(li,6)

[77, 33, 'huit', 'soleil', 2356, ('a', 'z'), 34, 289, 'orange', [1, 3, 5, 2], 1000, 'fin']

[[77, 33, 'huit'], ['soleil', 2356, ('a', 'z')], [34, 289, 'orange'], [[1, 3, 5, 2], 1000, 'fin']]

[[77, 33, 'huit', 'soleil'], [2356, ('a', 'z'), 34, 289], ['orange', [1, 3, 5, 2], 1000, 'fin']]

[[77, 33, 'huit', 'soleil', 2356, ('a', 'z')], [34, 289, 'orange', [1, 3, 5, 2], 1000, 'fin']]

Ce n’était pas la peine d’aller chercher midi à quatorze heure.

[dividee]

groupby retourne un objet sophistiqué ? C'est une question d'appréciation; il retourne un itérateur sur des couples (clé, itérateur). Et on n'est pas obligé de le passer à la moulinette de list() ou tuple(), si on ne désire qu'itérer dessus, ce qui est tout de même assez fréquent.

Cela dit, c'est vrai que la solution avec groupby ne traite pas le problème général du découpage en sous-listes de taille donnée. Le problème avec les trois solutions que tu proposes, c'est qu'elles ne fonctionnent que si la longueur de la liste est un multiple de l'argument n.

Je propose ceci, qui retourne une dernière liste incomplète si nécessaire:

Code :

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

1
2
3
4
5
>>> def splitBy(li, n=1):
... 	return [li[i:i+n] for i in xrange(0, len(li), n)]
... 
>>> splitBy(range(10),4)
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9]]

Ou ceci, qui retourne une liste de tuples, ne retourne pas le dernier tuple s'il est incomplet, mais a l'avantage de fonctionner avec tout itérable et pas seulement les listes et les tuples:

Code :

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

1
2
3
4
5
>>> def splitBy(it, n=1):
... 	return zip(*[iter(it)]*n)
... 
>>> splitBy(xrange(10),4)
[(0, 1, 2, 3), (4, 5, 6, 7)]

Cette fonction se trouve d'ailleurs dans la doc Python (http://docs.python.org/library/functions.html?#zip):

The left-to-right evaluation order of the iterables is guaranteed. This makes possible an idiom for clustering a data series into n-length groups using zip(*[iter(s)]*n).

Ou bien, en 'paddant' l'itérable avec des None:

Code :

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

1
2
3
4
5
6
>>> from itertools import chain
>>> def splitBy(it, n=1):
... 	return zip(*[chain(iter(it),[None]*(n-1))]*n)
... 
>>> splitBy(xrange(10),4)
[(0, 1, 2, 3), (4, 5, 6, 7), (8, 9, None, None)]

On peut aussi utiliser itertools.izip() à la place de zip(), pour retourner un itérateur au lieu d'une liste.

[denis2]

voici une autre solution

Code :

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

1
2
3
4
5
6
7
 
l = []
 
for x in range(5):
    l.append([x+2*x,x+2*x+1,x+2*x+2])
 
print l

[denis2]

améliorer

base pour le chiffre de démarage
range pour le nombre de sous listes ajoutée

Code :

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

1
2
3
4
5
6
7
8
 
l = []
base = 1
 
for x in range(5):
    l.append([x+2*x+base,x+2*x+1+base,x+2*x+2+base])
 
print l

resultat

Code :

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

1
2
3
 
 
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]]

[dividee]

Pourquoi x+2*x au lieu de 3*x ??

[denis2]

pour finir

x + 2 car : x + (nombre d'éléments dans la sous liste )-1
décortique ceci:

Code :

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

1
2
3
4
5
 
def Generateur(depart,elements,sous_listes):
    return [[x+(elements-1)*x+elem[0]+depart for elem in enumerate(range(elements))] for x in range(sous_listes)]
 
print Generateur(1,10,4)

resultat

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, 35, 36, 37, 38, 39, 40]]

[denis2]

ceci dit dividee tu as raison

je suis trop compliqué

Code :

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

1
2
3
4
def Generateur(depart,elements,sous_listes):
    return [[x*elements+elem[0]+depart for elem in enumerate(range(elements))] for x in range(sous_listes)]
 
print Generateur(1,10,4)

c'est ty pas beau python?