Creation d'une liste de sous liste

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:

---

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:

---

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

---

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

Ensuite j'ai eu comme idée:

Code:

---

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

Salut

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

Code:

---

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:

---

[x + 1 for x ...]

---

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?

Bonjour,

Et comme ça:

Code:

---

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

Salut !

Citation:

---

Envoyé par alcibiade

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

Code:

---

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:

---

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

---

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

Code:

---

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

Citation:

---

Envoyé par alcibiade

cela me donne

Code:

---

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

---

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

---

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:

---

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

Citation:

---

Envoyé par alcibiade

Ensuite j'ai eu comme idée:

Code:

---

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.

y a ça aussi ...

Code:

---

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

---

Allez, à mon tour:

Code:

---

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:

---

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

---

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:

---

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:

---

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

---

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

Code:

---

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)

---

Citation:

---

Envoyé par 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.

---

Voilà:

Code:

---

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

---

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:

---

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)

---

Citation:

---

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

---

Code:

---

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

---

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

comme si ça n’était pas

Code:

---

li[i:i+n]

---

Mon dernier mot sera donc

Code:

---

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)

---

Citation:

---

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

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:

---

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:

---

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

Citation:

---

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:

---

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.

voici une autre solution

Code:

---

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

---

améliorer

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

Code:

---

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:

---

1 2 3

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

---

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

pour finir

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

Code:

---

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:

---

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

---

ceci dit dividee tu as raison

je suis trop compliqué

Code:

---

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?