Wie man Listen in Python aufteilt: Einfache Beispiele und fortgeschrittene Methoden

Python-Listen sind dynamische, veränderbare Array-Datentypen, die zum Speichern geordneter Elemente verwendet werden. Das Aufteilen von Listen ist in Python echt häufig und wichtig, um Daten effizient zu bearbeiten und zu analysieren. 

Du kannst mehr über Datenanalyse lernen, indem du den Lernpfad Datenanalyst mit Python machst, um deine Fähigkeiten zu verbessern. Da geht's um die verschiedenen Methoden zum Aufteilen von Listen in Python, inklusive praktischer Beispiele und Best Practices. 

Wenn du diese Techniken beherrschst, kannst du deine Programmierfähigkeiten verbessern und deine Skripte effizienter und wartungsfreundlicher machen. Lass uns loslegen.

Die schnelle Antwort: Wie man eine Liste in Python teilt

• Der einfachste Weg, eine Liste in Python zu teilen, ist das Slicing mit dem Operator :. Zum Beispiel können wir eine Liste so teilen: split_list = my_list[:5], was die Liste am fünften Index teilt. 

• Der Rest dieses Artikels befasst sich mit anderen Methoden zum Aufteilen einer Liste, darunter Listenkomprimierungen, itertools, numpy und mehr. Jede Methode hat ihre eigenen Vorteile und passt zu verschiedenen Anwendungsfällen, wie wir gleich sehen werden.

Die gängigste Methode: Eine Liste mit Slicing teilen

Python split list at index ist wahrscheinlich die gängigste Technik zum Teilen von Listen. Die Slicing-Methode sorgt dafür, dass die Python-Liste an der angegebenen Stelle in Unterlisten aufgeteilt wird. Hier ist eine Schritt-für-Schritt-Anleitung, wie du Slicing in Python umsetzen kannst.

• Die Liste festlegen: Angenommen, du hast eine Liste [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] und möchtest sie an einem bestimmten Index n teilen.
• Identifiziere den Split-Index: Gib den Index n an, an dem du die Liste teilen möchtest.
• Mach den ersten Schnitt: Mach im folgenden Code first_slice, damit es die Elemente vom Anfang der Liste bis zum Index n enthält, aber diesen nicht mit reinpackt.
• Mach den zweiten Schnitt: Definiere second_slice, um alle Elemente vom Index n bis zum Ende der Liste einzuschließen.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Index where the list will be split
n = 4

# Slice the list from the beginning to the nth index (not inclusive)
first_slice = my_list[:n]

# Slice the list from the nth index to the end
second_slice = my_list[n:]

# Print the first slice of the list
print("First slice:", first_slice)

# Print the second slice of the list
print("Second slice:", second_slice)

# Expected output:
# First slice: [1, 2, 3, 4]
# Second slice: [5, 6, 7, 8, 9, 10]

Listensplitting in Python verstehen

Beim List Slicing in Python geht's darum, eine oder mehrere Teillisten aus der Hauptliste rauszuziehen. Wenn du eine Liste in Python aufteilen willst, musst du die Slicing-Syntax verstehen, um die richtige Teileliste besser zu verstehen. Die Syntax für das Slicing lautet slice[start:stop:step].

1. Start zeigt an, wo der Index für das Slicing anfängt.
2. Stop zeigt an, dass der Index des Slicings zu Ende ist.
3. Der Schritt gibt die Abstände zwischen den Schnitten an (Standardwert: 1).

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list from index 2 to 7 (index 2 inclusive, index 7 exclusive)
# This will include elements at index 2, 3, 4, 5, and 6
sublist = my_list[2:7]

# Print the sliced sublist
print(sublist) 

# Expected output: [3, 4, 5, 6, 7]

Nach dem Code oben fängt das Slicing bei Index 2 an und geht bis Index 6, weil die Teil-Liste Index 7 nicht hat.

Die Vorteile von Python-Split-Listen in Sachen Lesbarkeit und Effizienz von Code sind:

• Datenmanagement einfacher machen: Durch die Aufteilung der Daten in überschaubare Teile können Datenwissenschaftler Trainings- und Testdaten im maschinellen Lernen einfach trennen.
• Mehr Modularität: Das Schreiben von Funktionen mit bestimmten Teillisten macht deinen Code modularer.
• Leistung optimieren: Wenn du kleinere Listenabschnitte nimmst, geht die Verarbeitung schneller als mit ganzen Listen.
• Verbesserung der Speichereffizienz: Die Methode erstellt Blöcke, ohne die zugrunde liegenden Daten zu kopieren, was sie speichereffizient macht.

Verschiedene Techniken zum Teilen von Listen in Python

Es gibt verschiedene Möglichkeiten, eine Liste in Python zu teilen. Hier sind ein paar typische Beispiele, die ein Datenfachmann in seiner Arbeit erleben kann.

Mit Listenslicing arbeiten

Beim Aufteilen von Listen in Python benutzt man den Operator :, um die Liste an der angegebenen Stelle zu teilen. Diese Methode nutzt die Indizierungstechnik, um den Anfang und das Ende des Slicings festzulegen.

Zu den verschiedenen Techniken zum Schneiden gehören die folgenden:

Positives Index-Slicing

Diese Methode nutzt die positiven Indexwerte, von links nach rechts, um auf die Elemente in der Liste zuzugreifen.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list from index 2 to 7 (index 2 inclusive, index 7 exclusive)
# This will include elements at index 2, 3, 4, 5, and 6
sublist = my_list[2:7]

# Print the sliced sublist
print(sublist) 

# Expected output: [3, 4, 5, 6, 7]

Negatives Index-Slicing

Diese Python-Methode zum Teilen von Listen nutzt negative Indexwerte, die beim letzten Element der Liste anfangen und von rechts nach links gehen.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list to get the last 5 elements
sublist = my_list[-5:]

# Print the sliced sublist containing the last 5 elements
print(sublist)

# Slice the list to get all elements except the last 3
sublist = my_list[:-3]

# Print the sliced sublist containing all but the last 3 elements
print(sublist)

# Expected output:
# [6, 7, 8, 9, 10]
# [1, 2, 3, 4, 5, 6, 7]

Mit der Schritt-für-Schritt-Methode

Dieser Ansatz nutzt bestimmte Bedingungen, um die Liste beim Zugriff auf verschiedene Elemente aufzuteilen.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list to get every second element, starting from the beginning
sublist = my_list[::2]

# Print the sliced sublist containing every second element
print(sublist) 

# Slice the list to get every second element, starting from index 1
sublist = my_list[1::2]

# Print the sliced sublist containing every second element, starting from index 1
print(sublist) 

# Slice the list to get the elements in reverse order
sublist = my_list[::-1]

# Print the sliced sublist containing the elements in reverse order
print(sublist) 

# Expected output:
# [1, 3, 5, 7, 9]
# [2, 4, 6, 8, 10]
# [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Indizes weglassen

Diese Methode teilt die Python-Liste auf, indem sie nur die benötigten Elemente in einer Liste zurückgibt.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list from the start to index 5 (index 5 not inclusive)
sublist = my_list[:5]

# Print the sliced sublist containing elements from the start to index 4
print(sublist) 

# Slice the list from index 5 to the end
sublist = my_list[5:]

# Print the sliced sublist containing elements from index 5 to the end
print(sublist) 

# Slice the list to get the entire list
sublist = my_list[:]

# Print the sliced sublist containing the entire list
print(sublist) 

# Expected output:
# [1, 2, 3, 4, 5]
# [6, 7, 8, 9, 10]
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Listenkomprimierungen verwenden

Mit Python-Listenkomprimierung kann man eine Liste anhand der Werte der vorhandenen Liste in Teile aufteilen.

# Define a function to split a list into chunks of a specified size
def split_list(lst, chunk_size):
    # Use a list comprehension to create chunks
    # For each index 'i' in the range from 0 to the length of the list with step 'chunk_size'
    # Slice the list from index 'i' to 'i + chunk_size'
    return [lst[i:i + chunk_size] for i in range(0, len(lst), chunk_size)]

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Split the list into chunks of size 3 using the split_list function
chunks = split_list(my_list, 3)

# Print the resulting list of chunks
print(chunks)

# Expected output:
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]]

Der obige Code teilt die Python-Liste in drei Teile mit der Größe n, um eine neue Liste mit drei Werten zurückzugeben.

Mit Itertools arbeiten

Python-Listenaufteilung mit itertools nutzt das Python-Modul, um Daten durch Iteration umzuwandeln.

# Import the islice function from the itertools module
from itertools import islice
# Define a function to yield chunks of a specified size from an iterable
def chunks(iterable, size):
    # Create an iterator from the input iterable
    iterator = iter(iterable)
    
    # Loop over the iterator, taking the first element in each iteration
    for first in iterator:
        # Yield a list consisting of the first element and the next 'size-1' elements from the iterator
        yield [first] + list(islice(iterator, size - 1))

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Convert the generator returned by the chunks function into a list of chunks
chunked_list = list(chunks(my_list, 3))

# Print the resulting list of chunks
print(chunked_list)

# Expected output:
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]]

Mit numpy

Die numpy-Bibliothek in Python ist super, um Arrays in Unterlisten aufzuteilen. Die Funktion .array_split() macht Teilungen möglich, wenn du die Anzahl der Teilungen angibst.

# Import the numpy library and alias it as np
import numpy as np

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Use numpy's array_split function to split the list into 3 chunks
chunks = np.array_split(my_list, 3)

# Convert each chunk back to a regular list and print the resulting list of chunks
print([list(chunk) for chunk in chunks])

# Expected output:
# [[np.int32(1), np.int32(2), np.int32(3), np.int32(4), np.int32(5)], [np.int32(6), np.int32(7), np.int32(8), np.int32(9), np.int32(10)], [np.int32(11), np.int32(12), np.int32(13), np.int32(14), np.int32(15)]]

Listen in Teile aufteilen

Mit der folgenden Python-Funktion kann man auch eine Liste in Teile aufteilen. Diese Blöcke können je nach Bedarf des Benutzers individuell angepasst werden.

# Define a function to split a list into chunks of a specified size
def split_into_chunks(lst, chunk_size):
    chunks = []  # Initialize an empty list to store chunks
    
    # Iterate over the list with a step of chunk_size
    for i in range(0, len(lst), chunk_size):
        # Slice the list from index 'i' to 'i + chunk_size' and append it to chunks
        chunks.append(lst[i:i + chunk_size])
    
    return chunks  # Return the list of chunks

# Define a list of integers from 1 to 16
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]

# Split the list into chunks of size 4 using the split_into_chunks function
chunks = split_into_chunks(my_list, 4)

# Print the resulting list of chunks
print(chunks)

# Expected output:
# [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

Listen nach bestimmten Kriterien aufteilen

Wenn du eine Liste in Python aufteilen willst, kannst du ein paar Regeln/Bedingungen für die Teilliste festlegen. Mit dieser Methode kannst du eine Unterliste erstellen, die diese Bedingungen erfüllt.

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# List comprehension to filter elements divisible by 3
div_3 = [x for x in my_list if x % 3 == 0]

# List comprehension to filter elements not divisible by 3
not_div_3 = [x for x in my_list if x % 3 != 0]

# Print the list of elements divisible by 3
print(div_3)

# Print the list of elements not divisible by 3
print(not_div_3)

# Expected output:
# [3, 6, 9, 12, 15]
# [1, 2, 4, 5, 7, 8, 10, 11, 13, 14]

Verwendung von for-Schleifen

For-Schleifen kann man in Python auch nutzen, um Listen nach bestimmten Bedingungen und durch Wiederholung aufzuteilen.

# Define a function to split a list into sub-lists of size n
def split_by_n(lst, n):
    # Use a list comprehension to create sub-lists
    # For each index 'i' in the range from 0 to the length of the list with step 'n'
    # Slice the list from index 'i' to 'i + n'
    return [lst[i:i + n] for i in range(0, len(lst), n)]

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Split the list into sub-lists of size 5 using the split_by_n function
sub_lists = split_by_n(my_list, 5)

# Print the resulting list of sub-lists
print(sub_lists) 

# Expected output:
# [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]]

Die Funktion zip() benutzen

Du kannst auch die Funktion zip() in Python nutzen, um Listen durch Paare zu teilen.

# Define two lists: list1 containing integers from 1 to 10, and list2 containing letters from 'a' to 'j'
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list2 = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

# Use the zip function to pair corresponding elements from list1 and list2 into tuples
paired = list(zip(list1, list2))

# Print the list of paired tuples
print(paired)

# Expected output:
# [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f'), (7, 'g'), (8, 'h'), (9, 'i'), (10, 'j')]

Die Funktion enumerate() benutzen

Die Funktion enumerate() teilt Python-Listen anhand von Indexbedingungen auf. Diese Funktion nutzt Iteration, um eine Liste in gleich große Teile aufzuteilen.

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Define the chunk size for splitting the list
chunk_size = 5

# Create a list of empty lists, one for each chunk
split_list = [[] for _ in range(chunk_size)]

# Iterate over the elements and their indices in my_list
for index, value in enumerate(my_list):
    # Calculate the index of the sublist where the current value should go using modulo operation
    sublist_index = index % chunk_size
    
    # Append the current value to the corresponding sublist in split_list
    split_list[sublist_index].append(value)

# Print the list of sublists after splitting my_list into chunks
print(split_list)

# Expected output:
# [[1, 6, 11], [2, 7, 12], [3, 8, 13], [4, 9, 14], [5, 10, 15]]

Python-Zeichenkette in Liste aufteilen

Mit der split()-Methode

Die Methode split() teilt eine Zeichenfolge in Python anhand eines bestimmten Trennzeichens in eine Liste auf. Die Methode gibt die Teilzeichenfolgen entsprechend der Anzahl der Trennzeichen in der angegebenen Zeichenfolge zurück.

# Define a string
myString = "Goodmorning to you"

# Split the string into a list of words based on whitespace (default separator)
my_list = myString.split()

# Print the resulting list
print(my_list) 

# Expected output: ['Goodmorning', 'to', 'you']

Mit der Methode splitlines()

Die Methode splitlines() teilt eine Zeichenkette in Python anhand des Zeilenumbruchzeichens in eine Liste auf.

# Define a string with newline characters
myString = "Goodmorning\nto\nyou"

# Split the string into a list of lines based on newline characters
my_list = myString.splitlines()

# Print the resulting list
print(my_list)

# Expected output: ['Goodmorning', 'to', 'you']

Mit der Methode partition()

Die Methode partition() teilt Strings in Python anhand des angegebenen Trennzeichens in Listen auf. Diese Methode gibt drei Teile zurück: die Zeichenfolge vor dem Trennzeichen, das Trennzeichen selbst und alles nach dem Trennzeichen als Liste.

# Define a string with a delimiter '/'
myString = "Goodmorning/to you"

# Use the partition() method to split the string into three parts based on the first occurrence of '/'
my_list = myString.partition('/')

# Print the resulting tuple
print(my_list)

# Expected output: ('Goodmorning', '/', 'to you')

Verwendung regulärer Ausdrücke

In Python kann man reguläre Ausdrücke auch nutzen, um eine Zeichenkette in eine Liste aufzuteilen. Das folgende Beispiel zeigt, wie du das mit Leerzeichen machen kannst.

# Import the 're' module for regular expressions
import re

# Define a string
myString = "Goodmorning to you"

# Use re.split() to split the string based on whitespace ('\s' matches any whitespace character)
# Returns a list of substrings where the string has been split at each whitespace
my_list = re.split('\s', myString)

# Print the resulting list
print(my_list)

# Expected output: ['Goodmorning', 'to', 'you']

Vergleichstabelle

Hier ist eine Tabelle, damit du auf einen Blick sehen kannst, wann verschiedene Techniken nützlich sein könnten. In der Praxis kann dieselbe Technik in vielen Fällen ohne große Unterschiede in der Leistung funktionieren, sodass die Hinweise darauf, wann eine bestimmte Technik am nützlichsten ist, vielleicht etwas übertrieben sind.