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:

# These list elements are all of the same type
zoo = ['bear', 'lion', 'panda', 'zebra']
print(zoo)

# But these list elements are not
biggerZoo = ['bear', 'lion', 'panda', 'zebra', ['chimpanzees', 'gorillas', 'orangutans', 'gibbons']]
print(biggerZoo)

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.

# Import the `collections` library
____ ____

# Check if a dictionary is hashable
print(isinstance({}, collections.Hashable))

# Check if a float is hashable
print(isinstance(0.125, collections.Hashable))

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:

# Select the first list element
oneZooAnimal = biggerZoo[0]

# Print `oneZooAnimal`
print(____)

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.

# Pass -1 to the index operator on `biggerZoo`
monkeys = ___
print(monkeys)

# Pass -2 to the index operator on `biggerZoo`
zebra = ___
print(zebra)

# Run this code to trigger an "Index Out Of Range" Error
biggerZoo[6]

# Use the slice notation like this
someZooAnimals = biggerZoo[2: ]

# Print to see what you exactly select from `biggerZoo`
print(someZooAnimals)

# Try putting 2 on the other side of the colon
otherZooAnimals = biggerZoo[____]

# Print to see what you're getting back
print(otherZooAnimals)

# 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]Bereitgestellt von

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

# Print to see how the step value influences your result
print(biggerZoo[2::2])
print(biggerZoo[1::3])

# Import `choice` from the `random` library
from ____ import ____

# Construct your `list` variable with a list of the first 4 letters of the alphabet
list = ['_','_','_','_']

# Print your random 'list' element
print(choice(list))

# Import `randrange` from the `random` library
from ____ import ____

# Construct your `randomLetters` variable with a list of the first 4 letters of the alphabet
randomLetters = ['_','_', '_', '_']

# Select a random index from 'randomLetters`
randomIndex = randrange(0,len(randomLetters))

# Print your random element from `random`
print(randomLetters[randomIndex])

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.

# List of Strings to a String
listOfStrings = ['One', 'Two', 'Three']
strOfStrings = ''.join(listOfStrings)
print(strOfStrings)

# List Of Integers to a String
listOfNumbers = [1, 2, 3]
strOfNumbers = ''.join(str(n) for n in listOfNumbers)
print(strOfNumbers)

# Pass your list to `tuple()`
tuple(___)

# Transform your list into a set
set(___)

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

list(zip(helloWorld))

# Convert to a dictionary
helloWorldDictionary = dict(zip(helloWorld[0::2], helloWorld[1::2]))

# Print out the result
print(helloWorldDictionary)

a = [1, 2, 3, 4, 5]

# Create a list iterator object
i = iter(a)

# Zip and create a dictionary
print(dict(zip(i, i)))

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:

# Pass `justAList` to `len()`
len(____)

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:

# This is your list
list = [5, 6, 7, 8, 9]

# Check whether it's iterable
list.__iter__

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:

# Append [4,5] to `shortList`
shortList.append([4, 5])

# Use the print() method to show shortList
print(____)

# Extend `longerList` with [4,5]
longerList.extend([4, 5])

# Use the print() method to see longerList
print(____)

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:

# Concatenate `shortList` with `[4,5]`
plusList = shortList + [4,5]

#Use the `print()` method to see `plusList`
print(____)

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 :)

# Use sort() on the rooms list
____.sort()

# Print out rooms to see the result
print(____)

# Now use the sorted() function on orders
sorted(____)

# Print out orders
print(____)

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.

# Copy the grocery list by slicing and store it in the `newGroceries` variable
newGroceries = groceries[__]

# Copy the grocery list with the `list()` function and store it in a `groceriesForFriends` variable
groceriesForFriends = list(____)

# Import the copy library as c
import ____ as __

# Create a `groceriesForFamily` variable and assign the copied grocery list to it
groceriesForFamily =  c.copy(____)

# Use `deepcopy()` and assign the copied list to a `groceriesForKids` variable
groceriesForKids= c.deepcopy(____)

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

# This is your list
objectList = ['a','b',['ab','ba']]

# Copy the `objectList`
copiedList = objectList[:]

# Change the first list element of `copiedList`
copiedList[0] = 'c'

# Go to the third element (the nested list) and change the second element
copiedList[2][1] = 'd'

# Print out the original list to see what happened to it
print(objectList)

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:

[x**2 for x in range(10)]

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:

[x**2 for x in range(10) if x%2==0]

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:

myList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[(lambda x: x*x)(x) for x in myList]

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)]Bereitgestellt von

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.

# Count the occurrences of the number 4
print([1, 2, 9, 4, 5, 4, 1].count(4))

# Count the occurrences of the letter "a"
list = ["d", "a", "t", "a", "c", "a", "m", "p"]
list.count("a")

list= ["a","b","b"]
[[x,list.count(x)] for x in set(list)]

# Import `Counter` from the `collections` library
from collections import Counter

# This is your list
list = ["a","b","b"]

# Pass `list` to `Counter()`
Counter(list)

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

Nutze zip() in Kombination mit iter():

# Your list `x`
x = [1,2,3,4,5,6,7,8,9]

# Split `x` up in chunks of 3
y = zip(*[iter(x)]*3)

# Use `list()` to print the result of `zip()`
list(y)

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:

# Method to split up your lists into chunks
def chunks(list, chunkSize):
    """"Yield successive chunkSize-sized chunks from list."""
    for i in range(0, len(list), chunkSize):
        yield list[i:i + chunkSize]

# Use your `chunks` function to print out chunks of the same size
import pprint
pprnt.print(list(chunks(range(10, 75), 10)))

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:

# Set up your list and chunk size
list = range(0, 50)
chunk = 5

# Split up your list into chunks
[list[i:i + chunk] for i in range(0, len(list), chunk)]

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:

# This is your list
mylist = [[1,2,3],[4,5,6,7],[8,9,10]]

# Loop over your list and print all elements that are of size 3
for x in mylist:
      if len(x)==3:
        print(x)

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():

# This is your list
myList = [3,4,5,6]

# Loop over `myList` and print tuples of all indices and values 
for i, val in enumerate(myList):
     print(i, val)

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:

[x for x in myList if len(x)==3]

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

Mit sum() und einer leeren Liste als Startwert:

# Your initial list of lists
list = [[1,2],[3,4],[5,6]]

# Flatten out your original list of lists with `sum()`
sum(list, [])

Oder zwei alternative Wege:

# You can reduce the lists of lists of lists like this
from functools import reduce
print(reduce(lambda x,y: x+y,listOfLists))

# Or you can use list comprehension
print([item for sublist in listOfLists for item in sublist])

• 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)Bereitgestellt von

14. Wie bildest du die Schnittmenge zweier Listen?

# Intersect both lists with list comprehension
intersection = [list(filter(lambda x: x in list1, sublist)) for sublist in list2]

# Print the result of the intersection
print(____)

# An intersection of both lists, stored in `intersection`
intersection = [[x for x in sublist if x in list1] for sublist in list2]

# Print the result of the intersection
print(intersection)

# Make use of the list and set data structures
print(list(set(list1) & set(list2)))

# Use `intersection()`
print(list(set(list1).intersection(list2)))

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():

# Your list with duplicate values
duplicates = [1, 2, 3, 1, 2, 5, 6, 7, 8]

# Print the unique `duplicates` list
print(list(set(duplicates)))

# A list with small numbers 
smallNumbers = [1, 2, 3]

# Print the unique `duplicates` list without the small numbers
list(set(duplicates) - set(smallNumbers))

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:

import numpy
numpy.array([])

Oder initialisiere ein Array mit diesen Varianten:

# Make a NumPy array of four rows and two columns and filled with 0
numpy.zeros(shape=(4,2))

# Make a NumPy array of 1 values of three columns
numpy.ones(3)

# Make an empty NumPy array
numpy.empty(shape=(0,0))

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]Bereitgestellt von

for c in range(len(cost)):
   cost[c] = (cost[c] * cases[c] / sum(cases))
cost = sum(cost)
print(cost)

sum(cost[c] * cases[c] / sum(cases) for c in range(len(cost)))

sum(cost[c] * cases[c] for c in range(len(cost))) / sum(cases)

# See what `zip()` does to your `cost` and `cases`
print(list(zip(____, ____)))

# Calculate the weighted average
print(sum([x * y for x, y in zip(cost, cases)]) / sum(cases))

# Import numpy as np
import ____ as __

# Make a NumPy array
a = np.array([1,2,3,4,5])

# Return the 50th percentile of our NumPy array
p = np.percentile(a, 50)

#Print the result
print(____)

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

from operator import add
list(map(add, list1, list2))

[sum(x) for x in zip(list1, list2)]

# Import numpy as np
import ____ as __

# Make your lists into NumPy arrays
vector1 = np.array([1, 2, 3])
vector2 = np.array([4, 5, 6])

# Element-wise addition
sum_vector = vector1 + vector2 

# Print the result
print(____)

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!