Listen, Tupel und Slicing
Beherrschen Sie Python-Listenoperationen und die Slicing-Syntax und lernen Sie die Unveränderlichkeit von Tupeln anhand praktischer Beispiele aus klassischen Programmieraufgaben kennen.
Listen, Tupel und Slicing ist eine kostenlose DSA Interview Prep-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des DSA Interview Prep-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der DSA Interview Prep-Kurs umfasst insgesamt 4 Lektionen.
Python-Listen: Dynamische Arrays
Eine Python-list ist ein dynamisches Array, das beliebige Elemente aufnehmen kann und automatisch wächst. Sie ist geordnet, veränderbar und ermöglicht sofortigen O(1)-Zugriff über den Index. Der Code zeigt die Grundlagen.
nums = [3, 1, 4, 1, 5]
print(nums[0]) # 3
print(nums[-1]) # 5 (last element)
nums.append(9)
print(len(nums)) # 6Häufige Operationen mit Listen
Diese sollten Sie im Schlaf beherrschen: append und pop am Ende haben die Komplexität O(1), aber insert am Anfang hat O(n). Vermeiden Sie remove in engen Schleifen – bei jedem Aufruf wird die Liste erneut durchsucht.
stack = []
stack.append(1)
stack.append(2)
stack.append(3)
print(stack.pop()) # 3 O(1)
print(stack) # [1, 2]
# insert at index 0 is O(n)
stack.insert(0, 0)
print(stack) # [0, 1, 2]Die Slice-Syntax erklärt
Ein Slice wird als lst[start:stop:step] geschrieben und endet direkt vor stop. Der klassische Trick: Ein Schritt von -1 kehrt eine Liste um, ohne sie zu verändern. Der Code geht jede Form durch.
a = [0, 1, 2, 3, 4, 5]
print(a[1:4]) # [1, 2, 3]
print(a[:3]) # [0, 1, 2]
print(a[3:]) # [3, 4, 5]
print(a[::2]) # [0, 2, 4] every other
print(a[::-1]) # [5, 4, 3, 2, 1, 0] reversedSlicing erstellt flache Kopien
Ein wichtiger Stolperstein: Slicing erstellt immer eine neue Liste, daher bleibt die ursprüngliche Liste unverändert, wenn Sie den Slice bearbeiten. Die Kopie ist jedoch flach, sodass darin enthaltene verschachtelte Listen weiterhin gemeinsam verwendet werden. Seien Sie hier aufmerksam.
original = [1, 2, 3]
copy = original[:] # shallow copy
copy[0] = 99
print(original) # [1, 2, 3] unchanged
# Nested list pitfall
nested = [[1, 2], [3, 4]]
shallow = nested[:]
shallow[0][0] = 99
print(nested) # [[99, 2], [3, 4]] changed!Tupel: Unveränderliche Sequenzen
Ein tuple verwendet runde Klammern und kann nach seiner Erstellung nicht mehr verändert werden. Da es hashbar ist, kann es als Schlüssel eines dict oder als Element eines set verwendet werden – ideal für (row, col)-Paare bei Problemen mit Gittern.
point = (3, 7)
print(point[0]) # 3
# Use as dict key
grid = {}
grid[(0, 0)] = 'start'
grid[(2, 3)] = 'end'
print(grid[(0, 0)]) # start
# Unpacking
x, y = point
print(x, y) # 3 7Wann Sie ein Tupel statt einer Liste verwenden
Wählen Sie ein tuple, wenn sich die Daten nicht ändern sollen, und eine list, wenn sie veränderbar sein sollen. Tupel benötigen außerdem etwas weniger Speicher, was sich in großen Heaps bei Dijkstra summiert.
import sys
a_list = [1, 2, 3, 4, 5]
a_tuple = (1, 2, 3, 4, 5)
print(sys.getsizeof(a_list)) # e.g. 104 bytes
print(sys.getsizeof(a_tuple)) # e.g. 80 bytes
# Tuple returned from function
def min_max(nums):
return min(nums), max(nums)
lo, hi = min_max([3, 1, 4, 1, 5])
print(lo, hi) # 1 5Off-by-one-Fehler beim Slicing
Off-by-one-Fehler sind die häufigste Falle bei Array-Problemen. Denken Sie daran: lst[i:j] liefert genau j-i Elemente. Um in der Mitte zu teilen, ist der linke Teil lst[:mid] und der rechte Teil lst[mid:].
lst = [1, 2, 3, 4, 5, 6]
mid = len(lst) // 2 # 3
left = lst[:mid] # [1, 2, 3]
right = lst[mid:] # [4, 5, 6]
print(left, right)
# How many elements?
print(len(lst[2:5])) # 3 (indices 2,3,4)Negative Indizes in Vorstellungsgesprächen
Python unterstützt negative Indizes: lst[-1] ist das letzte Element, lst[-2] das vorletzte. Verwenden Sie lieber lst[-1] als lst[len(lst)-1] – Interviewer achten auf die elegantere Variante.
s = 'abcde'
print(s[-1]) # 'e'
print(s[-3:]) # 'cde'
print(s[:-2]) # 'abc' (all except last 2)
nums = [10, 20, 30, 40]
print(nums[-2]) # 30
nums[-1] = 99
print(nums) # [10, 20, 30, 99]Sortieren und Vergleichen von Listen
Python verwendet beim Sortieren Timsort (O(n log n), stabil). lst.sort() verändert die Liste direkt; sorted(lst) gibt eine neue Liste zurück. Verwenden Sie die Option key für eine benutzerdefinierte Reihenfolge. Sehen Sie sich den Code an.
words = ['banana', 'fig', 'apple', 'kiwi']
words.sort(key=len)
print(words) # ['fig', 'kiwi', 'apple', 'banana']
nums = [3, 1, 4, 1, 5]
print(sorted(nums, reverse=True)) # [5, 4, 3, 1, 1]
print(nums) # unchanged: [3, 1, 4, 1, 5]Listen während der Iteration verändern
Eine klassische Falle: Fügen Sie niemals Elemente hinzu oder entfernen Sie Elemente, während Sie über eine Liste iterieren – andernfalls überspringen Sie Elemente oder das Programm stürzt ab. Erstellen Sie stattdessen mit einer Comprehension eine neue Liste.
# WRONG — skips elements
nums = [1, 2, 3, 4, 5]
for n in nums:
if n % 2 == 0:
nums.remove(n) # skips 4!
print(nums) # [1, 3, 5]... but 4 got skipped? Actually removes 2,4
# CORRECT — build new list
nums = [1, 2, 3, 4, 5]
nums = [n for n in nums if n % 2 != 0]
print(nums) # [1, 3, 5]Tupel-Unpacking in Schleifen
Tupel-Unpacking hält Schleifen übersichtlich: enumerate liefert (index, value), und zip durchläuft zwei Listen gemeinsam. Die *rest-Syntax übernimmt den verbleibenden Teil in eine eigene Variable. Sehen Sie sich den Code an.
nums = [10, 20, 30]
for i, v in enumerate(nums):
print(i, v)
# 0 10 / 1 20 / 2 30
a = [1, 2, 3]
b = ['x', 'y', 'z']
for x, y in zip(a, b):
print(x, y)
first, *rest = [1, 2, 3, 4]
print(first, rest) # 1 [2, 3, 4]Kurzer Test
Kurzer Test – zeigen Sie, was Sie über Python-Listen, Tupel und Slicing gelernt haben. Sie schaffen das. 💪
Zusammenfassung der Lektion
Zusammenfassung: lists sind dynamische Arrays mit O(1) für append, Slicing gibt immer eine neue Kopie zurück und tuples sind unveränderlich und hashbar. Als Nächstes: Dictionaries und Sets.
Häufig gestellte Fragen
Ist die Lektion „Listen, Tupel und Slicing“ kostenlos?
Ja — der vollständige Text von „Listen, Tupel und Slicing“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des DSA Interview Prep-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der DSA Interview Prep-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Listen, Tupel und Slicing“?
Beherrschen Sie Python-Listenoperationen und die Slicing-Syntax und lernen Sie die Unveränderlichkeit von Tupeln anhand praktischer Beispiele aus klassischen Programmieraufgaben kennen. Du übst DSA Interview Prep mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um DSA Interview Prep zu starten?
Keine Vorkenntnisse erforderlich. DSA Interview Prep auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Listen, Tupel und Slicing“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser DSA Interview Prep-Lektion Code schreiben und ausführen?
Ja. Jede DSA Interview Prep-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Listen, Tupel und Slicing
- Dictionaries und Sets in Python
- Comprehensions und Built-ins
- Funktionen, Closures und Lambda