So verwendest du die Python-Methode pop()

Die Methode pop() ist eine wichtige Funktion in Python, die bei der Datenmanipulation eingesetzt wird, um ein bestimmtes Element aus einer Liste oder einem Dictionary zu entfernen und zurückzugeben. Python-Programmierende nutzen pop() gern, weil sich damit Datenstrukturen wie Listen und Dictionaries besonders einfach anpassen lassen.

Bevor wir ins Detail gehen, empfehle ich dir den Kurs Introduction to Python von DataCamp, um die Grundlagen der Python-Sprache zu lernen. Das Python Cheat Sheet for Beginners hilft dir außerdem, Pythons Syntax und verschiedene Funktionen schnell nachzuschlagen und zu verstehen.

Kurzantwort: So verwendest du pop() in Python

Die Methode pop() wird in Listen und Dictionaries genutzt, um gezielte Einträge zu entfernen und deren Wert zurückzugeben. Ich zeige dir kurz für beides ein Beispiel. Im ersten Beispiel siehst du, wie du mit pop() ein Element aus einer Liste entfernst. Der folgende Code gibt 5 aus.

# Create a list
my_list = [1, 2, 3, 4, 5]

# Removes and returns the last element of the list
last_element = my_list.pop()
print(last_element)

Das nächste Beispiel zeigt, wie du mit pop() einen bestimmten Schlüssel aus einem Dictionary entfernst. Der folgende Code gibt 3 aus.

# Create a dictionary
my_dict = {'a': 1, 'b': 2, 'c': 3}

# Removes and returns the value associated with the key 'b'
value = my_dict.pop('c')
print(value)

pop() mit Listen verwenden

Die Methode pop() entfernt aus einer Liste das angegebene Element und gibt es zurück. Die Syntax für pop() mit Listen siehst du unten.

list.pop([index])

Bei Listen kann pop() optional einen Index als Parameter erhalten. Wenn du keinen Parameter angibst, entfernt und liefert pop() das letzte Element der Liste.

Wenn du stattdessen einen Index angibst, beachte, dass bei einem ungültigen Index ein IndexError ausgelöst wird. Schauen wir uns die verschiedenen Anwendungsfälle von pop() mit Listen an.

pop() verwenden, um ein Element per Index zu entfernen

Du kannst im Aufruf von pop() einen positiven oder negativen Index übergeben, um das zu entfernende Element festzulegen. In Python beginnen positive Indizes bei 0 am Anfang der Liste. Negative Indizes starten bei -1 am Ende.

Die folgenden Beispiele zeigen drei Varianten, Elemente aus einer Liste zu entfernen. In allen Fällen gibt der Code 5 aus.

# Create a list
my_list = [1, 2, 3, 4, 5]

# Removes and returns the last element of the list
last_element = my_list.pop()
print(last_element)

# Create a list
my_list = [1, 2, 3, 4, 5]

# Remove specific element using negative index
removed_element = my_list.pop(-1) 
print(removed_element)  

# Create  a list
my_list = [1, 2, 3, 4, 5]

# Remove specific element using negative index
removed_element = my_list.pop(4) 
print(removed_element) 

Du kannst pop() in einer Schleife verwenden, um bei jedem Durchlauf das letzte Element zu entfernen, bis die Liste leer ist. Das folgende Beispiel zeigt pop() in Schleifen. Der Code gibt List is now empty aus.

# Create a list
my_list = [1, 2, 3, 4, 5]

# Create a function to remove items from the list
while my_list:
    element = my_list.pop()
    print(f"Removed element: {element}")
print("List is now empty:", my_list)

Diese Technik ist in vielen Situationen hilfreich. Stell dir zum Beispiel eine Aufgabenliste vor, die du nacheinander abarbeitest. Mit pop() entfernst du jede erledigte Aufgabe und behältst so den Fokus auf dem, was noch ansteht. 

pop() mit verschachtelten Listen

Mit pop() kannst du auch Elemente aus verschachtelten Listen entfernen. Dabei wird die angegebene innere Liste aus der äußeren Liste entfernt und zurückgegeben. Der folgende Code gibt [7, 8, 9] aus.

# Define a nested list
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Pop an element from the outer list
removed_list = nested_list.pop()
print(removed_list)

Wenn du ein bestimmtes Element aus einer inneren Liste entfernen willst, gib zuerst den Index dieser inneren Liste an. Der Code unten gibt 9 aus, das letzte Element der Liste am Index 2.

# Define a nested list
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Pop an element from an inner list
removed_element = nested_list[2].pop()
print(removed_element)

Index out of range bei pop() behandeln

Wenn du versuchst, ein Element mit einem Index außerhalb des gültigen Bereichs der Liste zu entfernen, wird ein IndexError ausgelöst. Um das zu vermeiden, prüfe zuerst die Länge der Liste und verwende dann einen passenden Index. Alternativ kannst du einen try-except-Block nutzen, um den Fehler abzufangen. Der folgende Code gibt in beiden Fällen Index out of range aus.

# Create a list
my_list = [1, 2, 3]

# Check length before popping
index = 4

# Ensure the index is within the valid range of the list
if 0 <= index < len(my_list):
    # Removes and returns the element at the specified index
    element = my_list.pop(index)  
    print(f"Popped element: {element}")
else:
    print("Index out of range")

# Create a list
my_list = [1, 2, 3]

# Using try-except block to handle out-of-range index
try:
    # Attempt to remove and return the element at index 5
    element = my_list.pop(5)
except IndexError:
    # Catches the IndexError if the index is out of range
    print("Index out of range")

pop() mit Dictionaries verwenden

Mit Dictionaries entfernt pop() einen angegebenen Schlüssel und gibt dessen Wert zurück. Die Syntax dafür siehst du unten.

dict.pop(key[, default])

Wie du siehst, verlangt pop() bei Dictionaries einen Schlüssel als Parameter. Die Methode gibt den zum Schlüssel gehörenden Wert zurück und entfernt das Schlüssel-Wert-Paar aus dem Dictionary. 

Du kannst außerdem einen optionalen Standardwert angeben, der zurückgegeben wird, wenn der Schlüssel nicht existiert. Ist der Schlüssel nicht vorhanden und kein Standardwert angegeben, wird ein KeyError ausgelöst. Mit Standardwert wird stattdessen dieser Wert zurückgegeben.

Standardwert im Python-Dictionary

Bei der Verwendung von pop() mit Dictionaries kannst du einen Standardwert angeben, der zurückgegeben wird, wenn der Schlüssel nicht gefunden wird. So vermeidest du in der Regel den KeyError. Der folgende Code gibt Not Found aus, da der Schlüssel d nicht vorhanden ist.

# Create a dictionary
my_dict = {'a': 1, 'b': 2, 'c': 3}

# Remove a specific key and provide default value
value = my_dict.pop('d', 'Not Found')

# Prints the returned value
print(value)

pop() mit verschachtelten Dictionaries

Wie bei Listen kannst du pop() auch in verschachtelten Dictionaries verwenden. Verschachtelte Dictionaries sind Dictionaries innerhalb von Dictionaries. Der folgende Code gibt {'x': 7, 'y': 8, 'z': 9} aus.

# Define a nested dictionary
nested_dict = {
    'a': {'x': 1, 'y': 2, 'z': 3},
    'b': {'x': 4, 'y': 5, 'z': 6},
    'c': {'x': 7, 'y': 8, 'z': 9}
}

# Pop a key-value pair from the outer dictionary
removed_dict = nested_dict.pop('c')
print(removed_dict)

Du kannst auch einen inneren Wert aus einem bestimmten Dictionary entfernen, indem du dessen Schlüssel angibst. Der folgende Code gibt 2 aus.

# Define a nested dictionary
nested_dict = {
    'a': {'x': 1, 'y': 2, 'z': 3},
    'b': {'x': 4, 'y': 5, 'z': 6},
    'c': {'x': 7, 'y': 8, 'z': 9}
}

# Pop a key-value pair from an inner dictionary
popped_inner_value = nested_dict['a'].pop('y')
print(popped_inner_value)

KeyError im Python-Dictionary behandeln

Eine weitere gängige Methode, den KeyError eleganter zu behandeln, ist ein try-except-Block, der den Fehler abfängt. Das folgende Beispiel zeigt die try-except-Technik mit der Methode pop().

# Create a dictionary
my_dict = {'a': 1, 'b': 2, 'c': 3}

# Create the try-except block to catch the error
try:
    value = my_dict.pop('d')
except KeyError:
    print("Key not found")

Du kannst auch das Schlüsselwort in verwenden, um vor dem Entfernen zu prüfen, ob ein Schlüssel existiert. Der folgende Code nutzt diese Methode und gibt Key not found. aus.

# Create a dictionary
my_dict = {'a': 1, 'b': 2}

# Check key existence before popping
key = 'c'
if key in my_dict:
    value = my_dict.pop(key)
    print(f"Popped value: {value}")
else:
    print("Key not found.")

Performance-Aspekte

In diesem Abschnitt schauen wir uns die Performance-Auswirkungen der Methode pop() bei Listen und Dictionaries an.

Listen-Operationen

Die Laufzeitkomplexität von pop() bei Listen hängt vom Index des zu entfernenden Elements ab. Wenn du pop() ohne Argument oder mit -1 aufrufst, um das letzte Element zu entfernen, arbeitet es in O(1), weil nur das letzte Element entfernt wird und die übrigen unverändert bleiben.

Wenn wir mit pop() das erste oder ein beliebiges anderes Element entfernen, ist die Laufzeit O(n), da ein Element entfernt und die restlichen Elemente verschoben werden müssen. Sieh dir unser Tutorial Analyzing Complexity of Code through Python an, um mehr über Zeitkomplexität in Python zu erfahren.

Dictionary-Operationen

Die Methode pop() ist bei Dictionaries durch die Implementierung der zugrunde liegenden Hashtabelle sehr effizient. In der Regel ist pop() bei Dictionaries eine O(1)-Operation.

Diese Komplexität ergibt sich daraus, dass ein Dictionary Schlüssel in einer Hashtabelle speichert und Einfügen, Löschen und Nachschlagen jeweils konstante Zeit benötigen. Beachte außerdem: Beim Einsatz von pop() im Dictionary musst du immer den zu entfernenden Schlüssel angeben. Lies unser Tutorial A Guide to Python Hashmaps, um mehr über Hashtabellen zu erfahren.

Alternativen zu Pythons pop()

Auch wenn pop() effektiv Elemente aus Listen und Dictionaries entfernt, gibt es Alternativen.

Das Schlüsselwort del verwenden

Mit dem Schlüsselwort del entfernst du ein Element aus einer Liste, indem du dessen Index angibst. del kann auch verwendet werden, um bestimmte Schlüssel-Wert-Paare aus Dictionaries zu löschen.  Beachte: Im Gegensatz zu pop() gibt del das entfernte Element nicht zurück. 

Die folgenden Beispiele zeigen, wie du mit del Elemente aus einer Liste und einem Dictionary entfernst. Nach dem Entfernen des Elements am Index 2 gibt der Code die neue Liste [1, 2, 4, 5] aus.

# Initialize a list with integers from 1 to 5
my_list = [1, 2, 3, 4, 5]

# Remove item at index 2
del my_list[2]
print(my_list)

Der folgende Code gibt {'a': 1, 'c': 3} aus.

# Create a dictionary
my_dict = {'a': 1, 'b': 2, 'c': 3}

# Remove the key 'b' and its associated value from the dictionary
del my_dict['b']
print(my_dict)

Die Methode remove() verwenden

Die Methode remove() gilt nur für Listen, wenn du ein Element anhand seines Werts statt per Index entfernen möchtest. Erscheint der Wert mehrfach, wird die erste Vorkommnis entfernt. Der folgende Code ergibt [1, 3, 4, 5].

# Initialize a list with integers from 1 to 5
my_list = [1, 2, 3, 4, 5]

# Remove the element with the value 2 from the list
my_list.remove(2)
print(my_list)

Fazit

Die Methode pop() ist eine besonders einfache und vielseitige Funktion in Python, um Elemente aus Listen und Dictionaries zu entfernen – mit zahlreichen praktischen Einsatzmöglichkeiten in der Programmierung. Gerade bei Listen und Dictionaries ist pop() hilfreich, weil der entfernte Eintrag zurückgegeben wird – häufig genau das Verhalten, das du brauchst.

Als Data Analyst empfehle ich dir die Skill Tracks Python Fundamentals und Python Programming von DataCamp, um deine Python-Kompetenzen für die Datenanalyse auszubauen. Außerdem lohnt sich der Career Track Data Analyst with Python, damit du kontinuierlich praxisnahe, berufsrelevante Kompetenzen aufbaust.