Liste in kleinere Listen aufteilen (in zwei Hälften teilen)

Ich suche nach einer Möglichkeit, eine Python-Liste einfach in zwei Hälften zu teilen.

Wenn ich also ein Array habe:

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

Ich würde bekommen können:

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

Wenn Sie eine Funktion wünschen:

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)

Eine etwas allgemeinere Lösung (Sie können die Anzahl der gewünschten Teile angeben und nicht nur in zwei Hälften teilen):

BEARBEITEN : Der Beitrag wurde aktualisiert, um ungerade Listenlängen zu verarbeiten

EDIT2 : Aktualisiere den Beitrag erneut basierend auf Brians informativen Kommentaren

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 - die vordefinierte Länge der Ergebnisarrays

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

Prüfung:

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

Ergebnis:

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

Wenn Sie sich nicht für die Bestellung interessieren ...

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

list[::2]Ruft jedes zweite Element in der Liste ab dem 0. Element ab.
list[1::2]Ruft jedes zweite Element in der Liste ab dem ersten Element ab.

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

Hier ist eine gängige Lösung, die arr in count part aufteilt

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

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

 return (B,C)

Ich habe getestet, und der doppelte Schrägstrich ist erforderlich, um die int-Teilung in Python 3 zu erzwingen. Mein ursprünglicher Beitrag war korrekt, obwohl wysiwyg aus irgendeinem Grund in Opera pleite war.

Es gibt ein offizielles Python-Rezept für den allgemeineren Fall der Aufteilung eines Arrays in kleinere Arrays mit einer Größe 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)

Dieses Code-Snippet stammt von der Python-itertools-Dokumentseite .

Mit Liste schneiden . Die Syntax ist grundsätzlichmy_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]

Um die erste Hälfte der Liste zu erhalten, schneiden Sie vom ersten Index nach len(i)//2(wo //ist die Ganzzahldivision - also 3//2 will give the floored result of1 , instead of the invalid list index of1,5`):

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

..und tauschen Sie die Werte aus, um die zweite Hälfte zu erhalten:

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

Wenn Sie eine große Liste haben, ist es besser, itertools zu verwenden und eine Funktion zu schreiben, um jedes Teil nach Bedarf zu erhalten:

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

Sie können dies wie folgt verwenden:

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

size = len(A) // 2

for sample in make_chunks(A, size):
    print(sample)

Die Ausgabe ist:

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

Vielen Dank an @thefourtheye und @Bede Constantinides

10 Jahre später .. Ich dachte - warum nicht noch einen hinzufügen:

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

Obwohl die obigen Antworten mehr oder weniger korrekt sind, können Probleme auftreten, wenn die Größe Ihres Arrays nicht durch 2 teilbar a / 2ist Geben Sie from __future__ import divisionam Anfang Ihres Skripts an. In jedem Fall ist es besser, sich für eine Ganzzahldivision zu entscheiden, dh a // 2um die "Vorwärts" -Kompatibilität Ihres Codes zu erreichen.

Dies ähnelt anderen Lösungen, ist jedoch etwas schneller.

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

Mit Hinweisen von @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)

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

Eine weitere Sichtweise auf dieses Problem im Jahr 2020 ... Hier ist eine Verallgemeinerung des Problems. Ich interpretiere das 'Teilen einer Liste in zwei Hälften' als .. (dh nur zwei Listen und es darf kein Übergreifen auf ein drittes Array im Falle eines ungeraden Outs usw. geben). Wenn zum Beispiel die Array-Länge 19 ist und eine Division durch zwei mit dem Operator // 9 ergibt, erhalten wir zwei Arrays der Länge 9 und ein Array (Drittel) der Länge 1 (also insgesamt drei Arrays). Wenn wir möchten, dass eine allgemeine Lösung immer zwei Arrays ergibt, gehe ich davon aus, dass wir mit den resultierenden Duo-Arrays zufrieden sind, die nicht gleich lang sind (eines ist länger als das andere). Und dass davon ausgegangen wird, dass es in Ordnung ist, die Reihenfolge zu mischen (in diesem Fall abwechselnd).

"""
arrayinput --> is an array of length N that you wish to split 2 times
"""
ctr = 1 # lets initialize a counter

holder_1 = []
holder_2 = []

for i in range(len(arrayinput)): 

    if ctr == 1 :
        holder_1.append(arrayinput[i])
    elif ctr == 2: 
        holder_2.append(arrayinput[i])

    ctr += 1 

    if ctr > 2 : # if it exceeds 2 then we reset 
        ctr = 1 

Dieses Konzept funktioniert für eine beliebige Anzahl von Listenpartitionen, wie Sie möchten (Sie müssten den Code abhängig von der Anzahl der gewünschten Listenteile anpassen). Und ist ziemlich einfach zu interpretieren. Um die Dinge zu beschleunigen, können Sie diese Schleife sogar in Cython / C / C ++ schreiben, um die Dinge zu beschleunigen. Andererseits habe ich diesen Code in relativ kleinen Listen mit ~ 10.000 Zeilen ausprobiert und er endet in Sekundenbruchteilen.

Nur meine zwei Cent.

Vielen Dank!