forma alternativa de dividir una lista en grupos de n

Question

Digamos que tengo una lista de longitud arbitraria, L:

L = list(range(1000)) 

¿Cuál es la mejor manera de dividir la lista en grupos de n? Esta es la mejor estructura que he sido capaz de llegar a, y por alguna razón no se siente como que es la mejor manera de llevar a cabo la tarea:

n = 25 
for i in range(0, len(L), n): 
    chunk = L[i:i+25] 

¿Hay un built-in para hacer esto ¿Estoy perdido?

Edit: Las primeras respuestas están volviendo a trabajar mi bucle for en un listcomp, que no es la idea; básicamente me estás devolviendo mi respuesta exacta en una forma diferente. Estoy viendo si hay un medio alternativo para lograr esto, como un hipotético .split en las listas o algo así. También hago utilizar esto como un generador de código que escribí anoche:

def split_list(L, n): 
    assert type(L) is list, "L is not a list" 
    for i in range(0, len(L), n): 
     yield L[i:i+n] 

Answer 1

Un Python recipe (En Python 2.6, utilice itertools.izip_longest):

def grouper(n, iterable, fillvalue=None): 
    "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx" 
    args = [iter(iterable)] * n 
    return itertools.zip_longest(*args, fillvalue=fillvalue) 

Ejemplo de uso:

>>> list(grouper(3, range(9))) 
[(0, 1, 2), (3, 4, 5), (6, 7, 8)] 
>>> list(grouper(3, range(10))) 
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, None, None)] 

Si desea que el último grupo sea más corto que los otros en lugar de acolchado con fillvalue, entonces podrías, por ejemplo cambiar el código como el siguiente:

>>> def mygrouper(n, iterable): 
...  args = [iter(iterable)] * n 
...  return ([e for e in t if e != None] for t in itertools.zip_longest(*args)) 
... 
>>> list(mygrouper(3, range(9))) 
[[0, 1, 2], [3, 4, 5], [6, 7, 8]] 
>>> list(mygrouper(3, range(10))) 
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]] 

Answer 2

¿Qué tal:

>>> n = 2 
>>> l = [1,2,3,4,5,6,7,8,9] 
>>> [ l[i:i+n] for i in range(0, len(l), n) ] 
[[1, 2], [3, 4], [5, 6], [7, 8], [9]] 

Answer 3

n = 25  
list_of_lists = [L[i:i+n] for i in range(0, len(L), n)] 

le da la lista de listas [[0..24], [25..49], ..]

Si len(L) % n no es 0, el último elemento (list_of_lists[-1]) durará len (L)% n.

Answer 4

Y si la forma que elija sus principales intereses, random.sample (población, k), devolver una lista k longitud de elementos únicos elegidos de la secuencia de la población. Usado para muestreo aleatorio sin reemplazo.

Answer 5

Aquí van:

list_of_groups = zip(*(iter(the_list),) * group_size) 

Ejemplo:

print zip(*(iter(range(10)),) * 3) 
[(0, 1, 2), (3, 4, 5), (6, 7, 8)] 

Si el número de elementos no es divisible por N, pero todavía quiere incluirlos puede utilizar izip_longest pero sólo está disponible desde python 2.6

El resultado es un generador, por lo que debe convertirlo en una lista si quieres imprimirlo

Finalmente, si no tiene python 2.6 y pegado con una versión más antigua, pero aún quieren tener el mismo resultado se puede utilizar el mapa:

print map(None, *(iter(range(10)),) * 3) 
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, None, None)] 

me gustaría añadir un poco de comparación de velocidad entre los diferentes métodos presentados hasta el momento:

python -m timeit -s 'from itertools import izip_longest; L = range(1000)' 'list(izip_longest(*(iter(L),) * 3))' 
10000 loops, best of 3: 47.1 usec per loop 

python -m timeit -s 'L = range(1000)' 'zip(*(iter(L),) * 3)' 
10000 loops, best of 3: 50.1 usec per loop 

python -m timeit -s 'L = range(1000)' 'map(None, *(iter(L),) * 3)' 
10000 loops, best of 3: 50.7 usec per loop 

python -m timeit -s 'L = range(1000)' '[L[i:i+3] for i in range(0, len(L), 3)]' 
10000 loops, best of 3: 157 usec per loop 

python -m timeit -s 'import itertools; L = range(1000)' '[list(group) for key, group in itertools.groupby(L, lambda k: k//3)]' 
1000 loops, best of 3: 1.41 msec per loop 

la lista por comprensión y el grupo por métodos son claramente más lento de lo postal, izip_longest y mapa

Answer 6

itertools.groupby es una herramienta bien, aquí hay una manera de dividir una lista de números enteros simplemente usando división entera:

>>> for key, group in itertools.groupby(range(10), lambda k: k//3): 
... print key, list(group) 
... 
0 [0, 1, 2] 
1 [3, 4, 5] 
2 [6, 7, 8] 
3 [9] 

(La lista tiene que comenzar con 0 a comenzar con un grupo completo.)

Answer 7

He aquí la versión recursividad. Es ineficiente porque Python tiene límites de recursión, pero esta versión ilustra que cada tarea se puede resolver a través de la recursión.

def split_to_groups(l, n): 
    assert (len(l)/n) < 998, "Can't split to {} groups".format(len(l)/n) 
    if l == []: 
     return [] 
    else: 
     f = [l[:n]] 
     f.extend(split_to_groups(l[n:], n)) 
     return f