Listen in Python im Detail

Listen sind eine der wichtigsten Datenstrukturen in Python. Sie ermöglichen es dir, mehrere Werte in einer einzigen Variable zu speichern, auf diese zuzugreifen und sie flexibel zu verändern. In diesem Tutorial lernst du alles, was du über Listen wissen musst.

Listen erstellen

Es gibt mehrere Wege, eine Liste in Python zu erstellen:

# Leere Liste erstellen
meine_liste = []
andere_liste = list()

# Liste mit Werten erstellen
zahlen = [1, 2, 3, 4, 5]
namen = ["Anna", "Ben", "Clara"]
gemischt = [42, "Hallo", True, 3.14]

# Liste aus einem String erstellen
buchstaben = list("Python")
print(buchstaben)  # ['P', 'y', 't', 'h', 'o', 'n']

# Liste aus einem Range erstellen
eins_bis_zehn = list(range(1, 11))
print(eins_bis_zehn)  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Liste mit Wiederholungen
nullen = [0] * 5
print(nullen)  # [0, 0, 0, 0, 0]

Listen können beliebige Datentypen enthalten — sogar andere Listen!

Indizierung und Slicing

Jedes Element in einer Liste hat einen Index. Der erste Index ist 0, nicht 1.

fruechte = ["Apfel", "Banane", "Kirsche", "Dattel", "Erdbeere"]

# Einzelne Elemente abrufen
print(fruechte[0])   # Apfel (erstes Element)
print(fruechte[2])   # Kirsche (drittes Element)
print(fruechte[-1])  # Erdbeere (letztes Element)
print(fruechte[-2])  # Dattel (vorletztes Element)

# Slicing: Teile einer Liste
print(fruechte[1:3])   # ['Banane', 'Kirsche'] (Index 1 bis 2)
print(fruechte[:3])    # ['Apfel', 'Banane', 'Kirsche'] (Anfang bis Index 2)
print(fruechte[2:])    # ['Kirsche', 'Dattel', 'Erdbeere'] (Index 2 bis Ende)
print(fruechte[::2])   # ['Apfel', 'Kirsche', 'Erdbeere'] (jedes zweite)
print(fruechte[::-1])  # Liste umgekehrt

# Slicing mit Schritten
zahlen = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(zahlen[1:8:2])  # [1, 3, 5, 7] (von Index 1 bis 7, Schritt 2)

Wichtig: Beim Slicing ist der Endindex nicht enthalten. fruechte[1:3] gibt die Elemente an Index 1 und 2 zurueck, aber nicht an Index 3.

Listen verändern

Listen sind veränderbar (mutable). Du kannst Elemente hinzufügen, ändern und entfernen.

Elemente hinzufügen

tiere = ["Hund", "Katze"]

# Ein Element am Ende anfügen
tiere.append("Vogel")
print(tiere)  # ['Hund', 'Katze', 'Vogel']

# Ein Element an bestimmter Position einfügen
tiere.insert(1, "Hamster")
print(tiere)  # ['Hund', 'Hamster', 'Katze', 'Vogel']

# Mehrere Elemente auf einmal hinzufügen
tiere.extend(["Fisch", "Schlange"])
print(tiere)  # ['Hund', 'Hamster', 'Katze', 'Vogel', 'Fisch', 'Schlange']

# Alternativ mit dem +-Operator
tiere = tiere + ["Papagei"]
print(tiere)  # [..., 'Papagei']

# Mit += (verändert die ursprüngliche Liste)
tiere += ["Schildkröte"]
print(tiere)  # [..., 'Schildkröte']

Elemente ändern

farben = ["rot", "grün", "blau"]

# Ein einzelnes Element ändern
farben[1] = "gelb"
print(farben)  # ['rot', 'gelb', 'blau']

# Mehrere Elemente mit Slicing ändern
farben[0:2] = ["schwarz", "weiß"]
print(farben)  # ['schwarz', 'weiß', 'blau']

Elemente entfernen

Es gibt verschiedene Methoden, um Elemente aus einer Liste zu entfernen:

sprachen = ["Python", "Java", "C++", "JavaScript", "Ruby", "Python"]

# Nach Wert entfernen (nur das erste Vorkommen!)
sprachen.remove("Python")
print(sprachen)  # ['Java', 'C++', 'JavaScript', 'Ruby', 'Python']

# Nach Index entfernen und Wert zurückgeben
entfernt = sprachen.pop(2)
print(entfernt)   # JavaScript
print(sprachen)   # ['Java', 'C++', 'Ruby', 'Python']

# Letztes Element entfernen (ohne Index)
letztes = sprachen.pop()
print(letztes)    # Python
print(sprachen)   # ['Java', 'C++', 'Ruby']

# Mit del nach Index entfernen
del sprachen[0]
print(sprachen)  # ['C++', 'Ruby']

# Ganze Liste leeren
sprachen.clear()
print(sprachen)  # []

Achtung: remove() wirft einen ValueError, wenn das Element nicht in der Liste ist. Prüfe vorher mit in:

meine_liste = [1, 2, 3]

if 4 in meine_liste:
    meine_liste.remove(4)
else:
    print("Element nicht gefunden!")

Listen sortieren

zahlen = [3, 1, 4, 1, 5, 9, 2, 6]

# Liste dauerhaft sortieren (verändert die Original-Liste)
zahlen.sort()
print(zahlen)  # [1, 1, 2, 3, 4, 5, 6, 9]

# Absteigend sortieren
zahlen.sort(reverse=True)
print(zahlen)  # [9, 6, 5, 4, 3, 2, 1, 1]

# Neue sortierte Liste erstellen (Original bleibt unverändert)
original = [3, 1, 4, 1, 5]
sortiert = sorted(original)
print(original)  # [3, 1, 4, 1, 5] -- unverändert!
print(sortiert)  # [1, 1, 3, 4, 5]

# Liste umkehren
namen = ["Clara", "Anna", "Ben"]
namen.reverse()
print(namen)  # ['Ben', 'Anna', 'Clara']

# Sortieren mit eigener Funktion (key)
woerter = ["Banane", "Apfel", "Kirsche", "Ei"]
woerter.sort(key=len)  # Nach Wortlänge sortieren
print(woerter)  # ['Ei', 'Apfel', 'Banane', 'Kirsche']

# Groß-/Kleinschreibung ignorieren
namen = ["anna", "Ben", "Clara", "david"]
namen.sort(key=str.lower)
print(namen)  # ['anna', 'Ben', 'Clara', 'david']

Listen durchsuchen

zahlen = [10, 20, 30, 20, 40, 20]

# Prüfen, ob ein Element vorhanden ist
print(30 in zahlen)      # True
print(50 in zahlen)      # False
print(50 not in zahlen)  # True

# Index eines Elements finden
print(zahlen.index(30))   # 2 (erster Index von 30)
print(zahlen.index(20))   # 1 (erster Index von 20)

# Suche ab einem bestimmten Index
print(zahlen.index(20, 2))  # 3 (erster Index von 20 ab Position 2)

# Anzahl der Vorkommen zählen
print(zahlen.count(20))  # 3
print(zahlen.count(99))  # 0

Listen kopieren

Beim Kopieren von Listen muss man vorsichtig sein. Eine einfache Zuweisung erstellt keine Kopie!

# ACHTUNG: Das ist KEINE Kopie!
original = [1, 2, 3]
keine_kopie = original
keine_kopie.append(4)
print(original)     # [1, 2, 3, 4] -- Original wurde verändert!
print(keine_kopie)  # [1, 2, 3, 4]

Shallow Copy (Flache Kopie)

original = [1, 2, 3]

# Methode 1: copy()
kopie1 = original.copy()

# Methode 2: Slicing
kopie2 = original[:]

# Methode 3: list()
kopie3 = list(original)

kopie1.append(4)
print(original)  # [1, 2, 3] -- Original bleibt unverändert!
print(kopie1)    # [1, 2, 3, 4]

Deep Copy (Tiefe Kopie)

Bei verschachtelten Listen reicht eine flache Kopie nicht aus:

import copy

# Verschachtelte Liste
original = [[1, 2], [3, 4], [5, 6]]

# Shallow Copy -- innere Listen werden NICHT kopiert!
flache_kopie = original.copy()
flache_kopie[0].append(99)
print(original)      # [[1, 2, 99], [3, 4], [5, 6]] -- AUCH verändert!

# Deep Copy -- alles wird vollständig kopiert
original = [[1, 2], [3, 4], [5, 6]]
tiefe_kopie = copy.deepcopy(original)
tiefe_kopie[0].append(99)
print(original)     # [[1, 2], [3, 4], [5, 6]] -- unverändert!
print(tiefe_kopie)  # [[1, 2, 99], [3, 4], [5, 6]]

Nützliche eingebaute Funktionen

zahlen = [10, 5, 8, 3, 12, 7]

print(len(zahlen))  # 6 (Anzahl der Elemente)
print(min(zahlen))  # 3 (kleinstes Element)
print(max(zahlen))  # 12 (größtes Element)
print(sum(zahlen))  # 45 (Summe aller Elemente)

# Durchschnitt berechnen
durchschnitt = sum(zahlen) / len(zahlen)
print(durchschnitt)  # 7.5

# any() und all()
werte = [True, False, True]
print(any(werte))  # True (mindestens ein True)
print(all(werte))  # False (nicht alle True)

# enumerate() -- Index und Wert gleichzeitig
fruechte = ["Apfel", "Banane", "Kirsche"]
for index, frucht in enumerate(fruechte):
    print(f"{index}: {frucht}")
# 0: Apfel
# 1: Banane
# 2: Kirsche

# zip() -- Mehrere Listen gleichzeitig durchlaufen
namen = ["Anna", "Ben", "Clara"]
alter = [25, 30, 22]
for name, a in zip(namen, alter):
    print(f"{name} ist {a} Jahre alt")

Listen als Stack (Stapel)

Ein Stack funktioniert nach dem LIFO-Prinzip (Last In, First Out):

stack = []

# Elemente auf den Stack legen (push)
stack.append("Teller 1")
stack.append("Teller 2")
stack.append("Teller 3")
print(stack)  # ['Teller 1', 'Teller 2', 'Teller 3']

# Oberstes Element entfernen (pop)
oben = stack.pop()
print(oben)   # Teller 3
print(stack)  # ['Teller 1', 'Teller 2']

# Oberstes Element ansehen ohne zu entfernen (peek)
oberstes = stack[-1]
print(oberstes)  # Teller 2

Listen als Queue (Warteschlange)

Eine Queue funktioniert nach dem FIFO-Prinzip (First In, First Out). Für effiziente Queues verwende collections.deque:

from collections import deque

warteschlange = deque()

# Elemente hinten anfügen (enqueue)
warteschlange.append("Kunde 1")
warteschlange.append("Kunde 2")
warteschlange.append("Kunde 3")
print(warteschlange)  # deque(['Kunde 1', 'Kunde 2', 'Kunde 3'])

# Erstes Element entfernen (dequeue)
erster = warteschlange.popleft()
print(erster)           # Kunde 1
print(warteschlange)    # deque(['Kunde 2', 'Kunde 3'])

Warum deque statt list? Das Entfernen am Anfang einer normalen Liste mit pop(0) ist langsam (O(n)), weil alle nachfolgenden Elemente verschoben werden müssen. deque.popleft() ist dagegen sehr schnell (O(1)).

Verschachtelte Listen

Listen können andere Listen enthalten. Das ist besonders nützlich für tabellarische Daten:

# 2D-Liste (Matrix)
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Zugriff auf Elemente
print(matrix[0])     # [1, 2, 3] (erste Zeile)
print(matrix[1][2])  # 6 (zweite Zeile, drittes Element)

# Über eine verschachtelte Liste iterieren
for zeile in matrix:
    for element in zeile:
        print(element, end=" ")
    print()  # Neue Zeile
# Ausgabe:
# 1 2 3
# 4 5 6
# 7 8 9

# Schüler-Noten
schueler_noten = [
    ["Anna", 1.3, 2.0, 1.7],
    ["Ben", 2.7, 3.0, 2.3],
    ["Clara", 1.0, 1.3, 1.0]
]

for schueler in schueler_noten:
    name = schueler[0]
    noten = schueler[1:]
    schnitt = sum(noten) / len(noten)
    print(f"{name}: Durchschnitt {schnitt:.1f}")

Praxis: Einkaufsliste verwalten

Hier ist ein vollständiges Programm, das eine Einkaufsliste verwaltet:

def einkaufsliste():
    """Ein interaktives Einkaufslisten-Programm."""
    liste = []

    while True:
        print("\n--- Einkaufsliste ---")
        print("1. Artikel anzeigen")
        print("2. Artikel hinzufügen")
        print("3. Artikel entfernen")
        print("4. Liste sortieren")
        print("5. Liste leeren")
        print("6. Beenden")

        wahl = input("\nDeine Wahl: ")

        if wahl == "1":
            if not liste:
                print("Die Einkaufsliste ist leer.")
            else:
                print("\nDeine Einkaufsliste:")
                for i, artikel in enumerate(liste, 1):
                    print(f"  {i}. {artikel}")
                print(f"\nGesamt: {len(liste)} Artikel")

        elif wahl == "2":
            artikel = input("Welchen Artikel hinzufügen? ")
            if artikel:
                if artikel in liste:
                    print(f"'{artikel}' ist bereits auf der Liste!")
                else:
                    liste.append(artikel)
                    print(f"'{artikel}' wurde hinzugefügt.")

        elif wahl == "3":
            if not liste:
                print("Die Liste ist bereits leer.")
            else:
                artikel = input("Welchen Artikel entfernen? ")
                if artikel in liste:
                    liste.remove(artikel)
                    print(f"'{artikel}' wurde entfernt.")
                else:
                    print(f"'{artikel}' ist nicht auf der Liste.")

        elif wahl == "4":
            liste.sort()
            print("Liste wurde sortiert.")

        elif wahl == "5":
            liste.clear()
            print("Liste wurde geleert.")

        elif wahl == "6":
            print("Auf Wiedersehen!")
            break

        else:
            print("Ungültige Eingabe. Bitte 1-6 wählen.")

# Programm starten
einkaufsliste()

Übungen

Übung 1: Zahlen-Statistik

Schreibe ein Programm, das eine Liste von Zahlen entgegennimmt und folgendes ausgibt: Minimum, Maximum, Summe, Durchschnitt und die sortierte Liste.

# Deine Lösung hier
zahlen = [23, 7, 42, 15, 8, 31, 19]

# Erwartete Ausgabe:
# Minimum: 7
# Maximum: 42
# Summe: 145
# Durchschnitt: 20.71
# Sortiert: [7, 8, 15, 19, 23, 31, 42]

Übung 2: Duplikate entfernen

Schreibe eine Funktion, die Duplikate aus einer Liste entfernt, aber die ursprüngliche Reihenfolge beibehält.

def duplikate_entfernen(liste):
    # Deine Lösung hier
    pass

# Test
print(duplikate_entfernen([1, 3, 2, 3, 1, 4, 2]))
# Erwartete Ausgabe: [1, 3, 2, 4]

Übung 3: Listen verschmelzen

Schreibe eine Funktion, die zwei sortierte Listen zu einer einzigen sortierten Liste zusammenführt.

def verschmelzen(liste1, liste2):
    # Deine Lösung hier
    pass

# Test
print(verschmelzen([1, 3, 5], [2, 4, 6]))
# Erwartete Ausgabe: [1, 2, 3, 4, 5, 6]

Übung 4: Matrix transponieren

Schreibe eine Funktion, die eine 2D-Liste (Matrix) transponiert (Zeilen und Spalten tauschen).

def transponieren(matrix):
    # Deine Lösung hier
    pass

# Test
m = [[1, 2, 3], [4, 5, 6]]
print(transponieren(m))
# Erwartete Ausgabe: [[1, 4], [2, 5], [3, 6]]

# Statt:
quadrate = []
for x in range(10):
    quadrate.append(x ** 2)

# Besser:
quadrate = [x ** 2 for x in range(10)]

# Mit Bedingung:
gerade = [x for x in range(20) if x % 2 == 0]

# Verschachtelt (Matrix erstellen):
matrix = [[0 for spalte in range(3)] for zeile in range(3)]