tuplas - print lista python

Divide la lista en listas más pequeñas

Question

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

Entonces, si tengo una matriz:

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

Podría obtener:

B = [0,1,2]

C = [3,4,5]

Answer 1

Aquí hay una solución común, split arr into count part

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

Answer 2

Con consejos 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)

Answer 3

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

Answer 4

Hay una receta oficial de Python para el caso más generalizado de división de 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 pertenece a la página de documentación de python itertools .

Answer 5

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

Answer 6

Si no te importa el orden ...

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

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

Answer 7

Una solución un poco más genérica (puede especificar la cantidad de partes que desea, no solo dividirla ''a la mitad''):

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

EDIT2 : actualiza la publicación de nuevo en base a 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)

Answer 8

Usando la división de listas . La sintaxis 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, se corta del primer índice a len(i)/2 ...

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

..y cambiar los valores para obtener la segunda mitad:

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

Answer 9

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

Answer 10

#for python 3
    A = [0,1,2,3,4,5]
    l = len(A)/2
    B = A[:int(l)]
    C = A[int(l):]       

Answer 11

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)

Answer 12

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

Answer 13

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

 return (B,C)

Probé, y se requiere la barra 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.

Answer 14

f = lambda A, n=3: [A[i:i+n] for i in range(0, len(A), n)]
f(A)

n : la longitud predefinida de las matrices de resultados