Dividir la lista en listas más pequeñas (dividir por la mitad)

Estoy buscando una manera de dividir fácilmente una lista de python por la mitad.

De modo que si tengo una matriz:

A = [0,1,2,3,4,5] 

Yo podría conseguir:

 B = [0,1,2] C = [3,4,5] 

 A = [1,2,3,4,5,6] B = A[:len(A)//2] C = A[len(A)//2:] 

Si quieres una función:

 def split_list(a_list): half = len(a_list)//2 return a_list[:half], a_list[half:] A = [1,2,3,4,5,6] B, C = split_list(A) 

Una solución un poco más genérica (puede especificar el número de piezas que desea, no solo dividir ‘por la mitad’):

EDITAR : publicación actualizada para manejar longitudes de listas impares

EDIT2 : actualización de la publicación de nuevo basado en los comentarios informativos de Brians

 def split_list(alist, wanted_parts=1): length = len(alist) return [ alist[i*length // wanted_parts: (i+1)*length // wanted_parts] for i in range(wanted_parts) ] A = [0,1,2,3,4,5,6,7,8,9] print split_list(A, wanted_parts=1) print split_list(A, wanted_parts=2) print split_list(A, wanted_parts=8) 
 f = lambda A, n=3: [A[i:i+n] for i in range(0, len(A), n)] f(A) 

n – la longitud predefinida de matrices de resultados

 def split(arr, size): arrs = [] while len(arr) > size: pice = arr[:size] arrs.append(pice) arr = arr[size:] arrs.append(arr) return arrs 

Prueba:

 x=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] print(split(x, 5)) 

resultado:

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

B,C=A[:len(A)/2],A[len(A)/2:]

Aquí es una solución común, dividir arr en parte de la cuenta

 def split(arr, count): return [arr[i::count] for i in range(count)] 

Si no te importa el pedido …

 def split(list): return list[::2], list[1::2] 

list[::2] obtiene cada segundo elemento de la lista a partir del elemento 0.
list[1::2] obtiene cada segundo elemento de la lista a partir del primer elemento.

 def splitter(A): B = A[0:len(A)//2] C = A[len(A)//2:] return (B,C) 

Probé, y se requiere la barra diagonal doble para forzar la división int en python 3. Mi publicación original era correcta, aunque wysiwyg se rompió en Opera, por alguna razón.

Existe una receta oficial de Python para el caso más generalizado de dividir una matriz en matrices más pequeñas de tamaño n .

 from itertools import izip_longest def grouper(n, iterable, fillvalue=None): "Collect data into fixed-length chunks or blocks" # grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx args = [iter(iterable)] * n return izip_longest(fillvalue=fillvalue, *args) 

Este fragmento de código es de la página de documentos de python itertools .

Usando el corte de la lista . La syntax es básicamente my_list[start_index:end_index]

 >>> i = [0,1,2,3,4,5] >>> i[:3] # same as i[0:3] - grabs from first to third index (0->2) [0, 1, 2] >>> i[3:] # same as i[3:len(i)] - grabs from fourth index to end [3, 4, 5] 

Para obtener la primera mitad de la lista, debe pasar del primer índice a len(i)/2

 >>> i[:len(i)/2] [0, 1, 2] 

..y el swap los valores alrededor para obtener la segunda mitad:

 >>> i[len(i)/2:] [3, 4, 5] 

Si bien las respuestas anteriores son más o menos correctas, es posible que tenga problemas si el tamaño de su matriz no es divisible entre 2, ya que el resultado de a / 2 es impar, es un flotante en Python 3.0 y anteriormente. versión si especifica from __future__ import division al comienzo de su script. En cualquier caso, es mejor ir a la división de enteros, es decir, a // 2 , para obtener la compatibilidad “hacia adelante” de su código.

Si tiene una lista grande, es mejor usar itertools y escribir una función para producir cada parte según sea necesario:

 from itertools import islice def make_chunks(data, SIZE): it = iter(data) # use `xragne` if you are in python 2.7: for i in range(0, len(data), SIZE): yield [k for k in islice(it, SIZE)] 

Puedes usar esto como:

 A = [0, 1, 2, 3, 4, 5, 6] size = len(A) // 2 for sample in make_chunks(A, size): print(sample) 

La salida es:

 [0, 1, 2] [3, 4, 5] [6] 

Gracias a @thefourtheye y @Bede Constantinides

Con sugerencias de @ChristopheD.

 def line_split(N, K=1): length = len(N) return [N[i*length/K:(i+1)*length/K] for i in range(K)] A = [0,1,2,3,4,5,6,7,8,9] print line_split(A,1) print line_split(A,2) 

Esto es similar a otras soluciones, pero un poco más rápido.

 # Usage: split_half([1,2,3,4,5]) Result: ([1, 2], [3, 4, 5]) def split_half(a): half = len(a) >> 1 return a[:half], a[half:] 
 #for python 3 A = [0,1,2,3,4,5] l = len(A)/2 B = A[:int(l)] C = A[int(l):] 

10 años después … pensé, ¿por qué no agregar otro?

 arr = 'Some random string' * 10; n = 4 print([arr[e:e+n] for e in range(0,len(arr),n)])