Liste in gleich große Teile aufteilen

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Antworten
anogayales
User
Beiträge: 456
Registriert: Mittwoch 15. April 2009, 14:11

Hallo allerseits,

ich möchte in Liste in n Unterlisten aufteilen, sprich:

Code: Alles auswählen

input_list = range(5)
print input_list
print split(input_list, 3)

Code: Alles auswählen

[0, 1, 2, 3, 4]
[[0], [1], [2, 3, 4]]
Falls die Rechnung nicht ganz aufgeht, sollen die Elemente an die letzte Liste gehängt werden. Naiv hab ich das ganze hier implementiert:

Code: Alles auswählen

def split(list, number_of_chunks):
    chunk_size = len(list) / number_of_chunks
    remainder = len(list) % number_of_chunks
    
    temp_list = [list[(x*chunk_size):(x*chunk_size)+chunk_size] for x in range(number_of_chunks)]
    
    if remainder != 0:
        temp_list[-1] = temp_list[-1] + list[-remainder:]
    
    
    return temp_list
Nun möchte ich aber die unschöne List-Comprehension entfernen.
Geht das irgendwie eleganter?
(Mir ist klar, dass ich mit list die interne python Funktion überschreibe.)

Grüße,
anogayales
BlackJack

@anogayales: Man könnte die LC etwas anders formulieren, aber wichtiger erscheint mir sich auch um die "Randfälle" zu kümmern, zum Beispiel kleine Listen bei denen `chunksize` 0 ist oder gar die leere Liste.

Code: Alles auswählen

def split(sequence, number_of_chunks):
    if not sequence:
        return []
    
    chunk_size, remainder = divmod(len(sequence), number_of_chunks)
    
    if chunk_size:
        result = [sequence[x:x+chunk_size]
                  for x in xrange(0, number_of_chunks * chunk_size, chunk_size)]
    else:
        result = [[]]
    
    if remainder:
        result[-1].extend(sequence[-remainder:])
    
    return result
anogayales
User
Beiträge: 456
Registriert: Mittwoch 15. April 2009, 14:11

Vielen Dank!

Es geht darum eine Liste in gleich große Teile aufzuteilen, damit mehrere Prozessoren mit dem jeweiligen Listenteil rechnen können. Vielleicht wäre es auch sinnvoll die restlichen Elemente in den anderen Listen gleichmäßig zu verteilen.

Bietet einem das multiprocessing Modul schon so eine art "Aufteilung" an oder ist meine Überlegung richtig, diese Listenteile selbst zu erstellen?

Grüße,
anogayales
BlackJack

@anogayales: Schau Dir mal die Methoden von `multiprocessing.Pool` an.
Antworten