18 Most Common Python List Questions

Was genau ist eine Python-Liste?

Listen sind eine der vier eingebauten Datenstrukturen in Python – neben Tuples, Dictionaries und Sets. Sie speichern eine geordnete Sammlung von Elementen, die auch unterschiedlichen Typs sein können, in der Praxis aber oft homogen sind. Elemente werden durch Kommas getrennt und in eckige Klammern gesetzt. Zum Beispiel:

Du siehst: Die zweite Variable biggerZoo ist eine Liste, die der Variable zoo ähnelt. Allerdings enthält biggerZoo zusätzlich eine weitere Liste mit unterschiedlichen Affenarten.

Da Listen in Python geordnete Sammlungen von Elementen/Objekten speichern, gehören sie zu den Sequenztypen – sie verhalten sich wie Sequenzen. Weitere Sequenztypen sind Strings und Tuples.

Was ist an Sequenztypen besonders? Kurz gesagt: Das Programm kann über sie iterieren! Deshalb nennt man Listen, Strings, Tuples und Sets „Iterables“.

Merke dir das unbedingt – das Konzept taucht auch in anderen Programmiersprachen für Data Science auf, etwa in Scala!

Jetzt wird’s praktisch! Lass uns tiefer einsteigen: Welche Fragen zu Listen beschäftigen dich als Python-Programmierer vielleicht? Hier ist die Übersicht aller Fragen, die wir in diesem Tutorial beantworten:

1. Wann nutzt du Python-Listen – und wann Tuples, Dictionaries oder Sets?

Die Einführung klingt eindeutig, solange du nur liest. In der Praxis – bei einem kleinen Skript oder einem ganzen Projekt – ist die Entscheidung für eine Liste oder einen anderen Sequenztyp oft weniger klar.

Aber: Die richtige Datenstruktur zu wählen, ist entscheidend!

Weiterlesen lohnt sich.

2. Wie wählst du ein Element aus einer Liste aus?

Wenn du mit Listen sinnvoll arbeiten willst, musst du wissen, wie du auf Elemente zugreifst.

Du greifst typischerweise zu, um Werte zu ändern, zu aktualisieren, zu löschen oder andere Operationen auszuführen. Der Zugriff erfolgt – wie bei allen Sequenztypen – über den Indexoperator [ ] mit einem Integer.

Ein Beispiel:

Führe den Code aus und sieh dir die Rückgabe an: Es wird das erste Element der Variable biggerZoo zurückgegeben. Etwas ungewohnt am Anfang: Indizes beginnen bei 0, nicht bei 1.

# Elemente von start bis vor end (end ist ausgeschlossen!)
a[start:end]

# Elemente von start bis zum Ende
a[start:]    

# Elemente vom Anfang bis vor end
a[:end]

# von start bis vor end, mit Schrittweite step
a[start:end:step]

3. Wie wandelst du Listen in andere Datenstrukturen um?

Manchmal ist eine Liste nicht ideal. Dann willst du sie in eine passendere Struktur umwandeln. Hier sind gängige Umwandlungen und ihre Lösungen.

helloWorld = ['hello','world','1','2']

4. Wie ermittelst du die Länge deiner Liste?

Übergebe deine Liste an len(), um die Länge zu erhalten.

Teste es hier. Wir haben justAList vorbereitet:

Hinweis: len() funktioniert nicht nur für Listen, sondern auch für andere Sequenzen/Sammlungen wie Dictionaries, Sets, Strings etc. Weitere Built-ins findest du hier.

5. Worin unterscheiden sich append() und extend()?

Zur Erinnerung ans Iterable-Konzept aus Abschnitt 1:

Merke: Ein Wert ist „iterierbar“, wenn dein Programm über ihn iterieren kann – er repräsentiert also eine Sequenz von Werten. Listen sind Sequenzen und damit Iterables.

Tipp: Du erkennst Iterables an der Methode .__iter__, z. B. so:

Jetzt zum Unterschied: extend() nimmt ein Iterable (Liste, Set, Tuple, String …) und hängt jedes Element einzeln an die Liste an.

append() hängt sein Argument als ein einziges Element hinten an – auch wenn es ein Iterable ist, wird es als ein Objekt angefügt.

Sieh dir die Beispiele an und experimentiere, um das Verhalten zu verstehen:

extend() ist effizienter, als mehrmals append() aufzurufen.

6. Wie verkettest du Listen?

Mit dem Operator + erhältst du eine neue Liste als Verkettung beider Listen – die Originale bleiben unverändert.

Hinweis: Nicht verwechseln mit append(). + ähnelt zwar extend(), ist aber nicht identisch. append() und extend() ändern die bestehende Liste, + erzeugt eine neue Variable.

Probier es aus und vergleiche mit den Beispielen oben:

7. Wie sortierst du eine Liste?

Zwei einfache Wege für auf- oder absteigende Sortierung:

• Mit der Methode sort()
• Oder mit der Funktion sorted() und übergebener Liste

sorted() funktioniert für jedes Iterable, also auch Strings, Sets, Dictionaries (bei Übergabe).

Tipp: Probier es aus! Wir haben rooms und orders vorbereitet. Sortiere beide mit beiden Techniken :)

Hinweis: sort() ändert die Originalliste. Nutze es, wenn du die alte Reihenfolge nicht brauchst.

8. Wie klonst oder kopierst du eine Liste?

Es gibt mehrere Wege:

• Per Slice kopieren: newList = oldList[:]
• Mit list(): newList = list(oldList)
• Mit der copy-Bibliothek:
  • copy()-Methode: newList = copy.copy(oldList)
  • Enthält die Liste Objekte und du willst diese mitkopieren: copy.deepcopy(): copy.deepcopy(oldList)

Probier es aus! Wir haben eine groceries-Liste vorbereitet, die du kopieren und mit Freundinnen teilen kannst.

Hinweis: Bei den „einfachen“ Kopiermethoden können Änderungen an verschachtelten Objekten durchschlagen. Mit deepcopy() verhinderst du das. Schau dir an, was passiert:

Wenn du Listen in Python bereits intensiver nutzt, liefern die nächsten Abschnitte kompakte Antworten auf komplexere Fragen.

Und falls du wissen willst, welche Vorteile Bibliotheken gegenüber der eingebauten Listenstruktur bieten, lies unbedingt weiter.

Weiter geht’s!

9. Wie funktioniert List Comprehension in Python?

List Comprehension ist eine elegante Art, Listen zu erzeugen. Für Mathe-Fans: Sie sehen mathematischen Listen ähnlich. Schau selbst:

Bedeutung: Nimm die Zahlen 0 bis 9 (10 ist ausgeschlossen) und multipliziere jede mit 2. Führe den Code aus und vergleiche das Ergebnis mit deiner Erwartung.

Nicht schwer, oder? Gehen wir einen Schritt weiter.

Jetzt willst du wie zuvor nur Zahlen multiplizieren, die durch 2 teilbar sind. Mit List Comprehension ist das simpel:

Du fügst eine Bedingung mit if hinzu. Ist sie TRUE, wird multipliziert. Hier: x ist ohne Rest durch 2 teilbar.

Allgemeiner kannst du mit List Comprehension Listen in andere Listen transformieren. Beispiel:

Hier transformierst du die vorhandene myList. Für jedes Element x führst du eine Operation aus.

(lambda x: x*x) ist eine anonyme Funktion zur Laufzeit. Du kannst sie gedanklich als „x*x“ betrachten. Da sie anonym ist, übergibst du x direkt: (lambda x: x*x)(x).

Alternativ so umschreiben:

f = lambda x: x*x
[f(x) for x in range(10)]

Du definierst die Lambda-Funktion und rufst sie dann für jedes Listenelement auf.

Hinweis: Neben List- gibt es auch Set- und Dictionary-Comprehensions.

Das war schon einiges – es gibt noch mehr zu entdecken, inkl. verschachtelter Comprehensions und Praxisbeispiele.

10. Wie zählst du Vorkommen von Listenelementen?

Listen erlauben Duplikate – manchmal willst du wissen, wie oft ein bestimmtes Element vorkommt oder wie oft jedes Element erscheint.

Hier sind beide Lösungen.

11. Wie teilst du eine Liste in gleich große Blöcke?

Nutze zip() in Kombination mit iter():

So funktioniert’s:

• iter() liefert einen Iterator über die Sequenz.
• [iter(x)] * 3 erzeugt eine Liste mit drei gleichen Iteratoren über x.
• Das vorangestellte * entpackt die Sequenz als Argumente, sodass zip() dreimal denselben Iterator erhält und jedes Mal ein Element zieht.

Noch unklar?

Schritt für Schritt:

1. Du hast drei Iteratoren, sinngemäß: [1,2,3,4,5,6,7,8,9], [1,2,3,4,5,6,7,8,9], [1,2,3,4,5,6,7,8,9]

2. Beim ersten Mal nimmt zip() je ein Element: [1][2][3]

Hinweis: Die Iteratoren merken sich die Position!

3. Beim zweiten Mal ergänzt zip() auf: [1, 4], [2, 5], [3, 6]

4. Beim dritten Mal: [1, 4, 7], [2, 5, 8], [3, 6, 9]

5. Diese drei Listen zu Blöcken „zipped“ ergeben: [1, 2, 3], [4, 5, 6], [7, 8, 9]

Als Funktion kannst du es so kapseln:

chunks() nimmt Liste und Blockgröße entgegen und liefert nacheinander Blöcke der gewünschten Größe.

range(0, len(list), chunkSize) startet bei 0, endet bei der Listenlänge und nutzt die Blockgröße als Schrittweite.

Für jeden Index wird list[i:i+chunkSize] zurückgegeben.

Hinweis: Mit pprint() kannst du schöner ausgeben.

Oder kurz mit List Comprehension statt Funktion:

12. Wie iterierst du über eine Liste?

Mit einer for-Schleife ganz einfach: Du führst für jedes Element eine Aktion aus.

In Python sieht das so aus:

Hier prüfen wir, ob die Länge eines Elements 3 ist. Da zwei Unterlisten je drei Elemente enthalten ([1,2,3] und [8,9,10]), werden nur diese gedruckt.

Hinweis: x kannst du beliebig benennen, etwa element.

Wenn du zusätzlich die Indizes brauchst, nutze enumerate():

enumerate(myList) liefert Index und Wert, die du in der Schleife entpackst (i, val).

Hinweis: Auch mit List Comprehension kannst du „iterieren“, das Ergebnis wird direkt erzeugt und ggf. ausgegeben:

13. Wie machst du aus Listen von Listen eine flache Liste?

Mit sum() und einer leeren Liste als Startwert:

Oder zwei alternative Wege:

• reduce() mit einer Lambda-Funktion, die Listen kumulativ mit + verketten lässt: ([1,2]+[3,4])+[5,6]. Merke: + verketten Listen.

• Oder per verschachtelter List Comprehension: Erst sublist in list (also [1,2], [3,4], [5,6]), dann item for item in sublist.

Als normale Schleife sähe das so aus:

list1 = []

for sublist in list:
  for item in sublist:
    list1.append(item)

14. Wie bildest du die Schnittmenge zweier Listen?

15. Wie entfernst du Duplikate aus einer Liste?

Wie eingangs beschrieben: Für eindeutige, ungeordnete Elemente ist ein Set ideal.

Erstelle ein Set mit set() aus jedem Iterable. Brauchst du später wieder eine Liste, übergib das Set an list().

Merke: Ein Iterable kann eine Liste, ein Dictionary usw. sein. Ob etwas iterierbar ist, prüfst du mit .__iter__.

So entfernst du alle Duplikate mit set():

Wie du siehst, bleibt die ursprüngliche Reihenfolge nicht erhalten, wenn du Mengen differenzierst. Sets sind ungeordnet – beim Zurückwandeln entsteht eine beliebige Reihenfolge.

Ist die Reihenfolge wichtig, brauchst du einen anderen Ansatz. Hier findest du Details.

16. Warum NumPy statt Python-Listen?

Vier Hauptgründe sprechen für NumPy-Arrays:

• Sie sind kompakter als Listen.
• Lese- und Schreibzugriffe sind schneller.
• Bequemer dank vieler Vektor- und Matrixoperationen „out of the box“.
• Effizienter, da performant implementiert.

17. Wie erstellst du leere NumPy-Arrays?

Ein leeres Array erstellst du so:

Oder initialisiere ein Array mit diesen Varianten:

Weitere Möglichkeiten findest du in der Dokumentation.

18. Wie rechnest du mit Listen?

Oft speichern wir Listen nicht nur, sondern rechnen damit. Hier die häufigsten Fragen dazu.

cost = [0.424, 0.4221, 0.4185, 0.4132, 0.413]
cases = [10, 20, 30, 40, 50]

list1=[1, 2, 3]
list2=[4, 5, 6]

Wie geht es weiter auf deiner Data-Science-Reise mit Python?

Du bist am Ende unseres interaktiven Tutorials zu Python-Listen angekommen. Das war einiges an Stoff – gut gemacht!

Listen sind nur ein kleiner, aber wichtiger Baustein auf deiner Reise. Es gibt so viel mehr zu entdecken! Unser interaktiver Kurs Intro to Python for Data Science ist ideal, wenn du mehr über Python im Data-Science-Kontext lernen willst: Von den Basics bis hin zu NumPy. Perfekt für alle mit wenig (Python-)Programmiererfahrung!

Wenn du schon fortgeschrittener bist, wirf einen Blick auf unseren Kurs Intermediate Python For Data Science – für alle, die ihre Data-Science- und Python-Kompetenzen aufs nächste Level bringen wollen. Du lernst weitere Bibliotheken wie matplotlib und pandas, vertiefst Logik, Control Flow und Filtering und arbeitest an einer praxisnahen Fallstudie.

Du nutzt Python schon für Data Science und willst noch weiter gehen? Dann könnte unser Kurs Importing Data Into Python spannend sein – oder lies unsere Tutorialreihe The importance of preprocessing in data science and the machine learning pipeline!