Eine list ist eine veränderbare Sammlung von Elementen in einer Sequenz.
Wie die meisten Sammlungen (siehe die eingebauten tuple, dict und set) können Listen Referenzen auf beliebige (oder mehrere) Datentypen enthalten, auch auf andere Listen.
Wie bei jedem Sequenztyp kannst du auf Elemente über 0-based index von links und -1-based index von rechts zugreifen.
Listen können vollständig oder teilweise über die Slice-Notation oder <list>.copy() kopiert werden.
Listen unterstützen sowohl allgemeine als auch veränderbare Sequenzoperationen wie min()/max(), <list>.index(), <list>.append() und <list>.reverse().
Über die Elemente einer Liste kannst du mit dem Konstrukt for item in <list> iterieren.
for index, item in enumerate(<list>) kannst du verwenden, wenn du sowohl den Index als auch den Wert eines Elements brauchst.
Unter der Haube sind lists als dynamische Arrays implementiert, ähnlich wie Javas ArrayList-Typ, und werden meist verwendet, um Gruppen ähnlicher Daten (Strings, Zahlen, Mengen usw.) unbekannter Länge zu speichern.
Listen sind eine extrem flexible und nützliche Datenstruktur, und viele eingebaute Methoden und Operationen in Python liefern Listen als Ergebnis.
Erstellung
Eine list kannst du als Literal mit eckigen [] Klammern und Kommas zwischen den Elementen deklarieren:
>>> no_elements = []
>>> no_elements
[]
>>> one_element = ["Guava"]
>>> one_element
['Guava']
>>> elements_separated_with_commas = ["Parrot", "Bird", 334782]
>>> elements_separated_with_commas
['Parrot', 'Bird', 334782]
Zur besseren Lesbarkeit kannst du Zeilenumbrüche verwenden, wenn eine list viele Elemente oder verschachtelte Datenstrukturen enthält:
>>> lots_of_entries = [
"Rose",
"Sunflower",
"Poppy",
"Pansy",
"Tulip",
"Fuchsia",
"Cyclamen",
"Lavender"
]
>>> lots_of_entries
['Rose', 'Sunflower', 'Poppy', 'Pansy', 'Tulip', 'Fuchsia', 'Cyclamen', 'Lavender']
# Each data structure is on its own line to help clarify what they are.
>>> nested_data_structures = [
{"fish": "gold", "monkey": "brown", "parrot": "grey"},
("fish", "mammal", "bird"),
['water', 'jungle', 'sky']
]
>>> nested_data_structures
[{'fish': 'gold', 'monkey': 'brown', 'parrot': 'grey'}, ('fish', 'mammal', 'bird'), ['water', 'jungle', 'sky']]
Der Konstruktor list() kann leer oder mit einem Iterable als Argument verwendet werden.
Der Konstruktor durchläuft die Elemente des Iterables und fügt sie der list der Reihe nach hinzu:
>>> no_elements = list()
>>> no_elements
[]
# The tuple is unpacked and each element is added.
>>> multiple_elements_from_tuple = list(("Parrot", "Bird", 334782))
>>> multiple_elements_from_tuple
['Parrot', 'Bird', 334782]
# The set is unpacked and each element is added.
>>> multiple_elements_from_set = list({2, 3, 5, 7, 11})
>>> multiple_elements_from_set
[2, 3, 5, 7, 11]
Die Ergebnisse, wenn du den list()-Konstruktor mit einem string oder einem dict verwendest, können überraschend sein:
# String elements (Unicode code points) are iterated through and added *individually*.
>>> multiple_elements_string = list("Timbuktu")
>>> multiple_elements_string
['T', 'i', 'm', 'b', 'u', 'k', 't', 'u']
# Unicode separators and positioning code points are also added *individually*.
>>> multiple_code_points_string = list('अभ्यास')
>>> multiple_code_points_string
['अ', 'भ', '्', 'य', 'ा', 'स']
# The iteration default for dictionaries is over the keys, so only key data is inserted into the list.
>>> source_data = {"fish": "gold", "monkey": "brown"}
>>> multiple_elements_dict_1 = list(source_data)
['fish', 'monkey']
Weil der list()-Konstruktor nur Iterables (oder nichts) als Argumente akzeptiert, lösen Objekte, die nicht iterierbar sind, einen Typfehler aus.
Folglich ist es viel einfacher, eine list mit einem einzigen Element über die Literal-Schreibweise zu erstellen.
# Numbers are not iterable, and so attempting to create a list with a number passed to the constructor fails.
>>> one_element = list(16)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
# Tuples *are* iterable, so passing a one-element tuple to the constructor does work, but it's awkward
>>> one_element_from_iterable = list((16,))
>>> one_element_from_iterable
[16]
Zugriff auf Elemente
Auf Elemente in Listen (sowie auf Elemente in anderen Sequenztypen wie str und tuple) kannst du über 0-based index und die Klammer-Notation zugreifen.
Indizes können von left --> right (beginnend bei null) oder von right --> left (beginnend bei -1) verlaufen.
Index von links ⟹
|
0
👇🏾 |
1
👇🏾 |
2
👇🏾 |
3
👇🏾 |
4
👇🏾 |
5
👇🏾 |
| P |
y |
t |
h |
o |
n |
👆🏾
-6 |
👆🏾
-5 |
👆🏾
-4 |
👆🏾
-3 |
👆🏾
-2 |
👆🏾
-1 |
|
⟸ Index von rechts |
>>> breakfast_foods = ["Oatmeal", "Fruit Salad", "Eggs", "Toast"]
# Oatmeal is at index 0 or index -4.
>>> breakfast_foods[0]
'Oatmeal'
>>> breakfast_foods[-4]
'Oatmeal'
# Eggs are at index -2 or 2
>>> breakfast_foods[-2]
'Eggs'
>>> breakfast_foods[2]
'Eggs'
# Toast is at -1
>>> breakfast_foods[-1]
'Toast'
Auf einen Abschnitt der Elemente innerhalb einer list kannst du über die Slice-Notation (<list>[start:stop]) zugreifen.
Ein Slice ist eine Elementfolge an der Position index, für die start <= index < stop gilt.
Das Slicing gibt eine Kopie der herausgeschnittenen Elemente zurück und verändert die ursprüngliche list nicht.
Ein step-Parameter kann ebenfalls verwendet werden [start:stop:step], um die Elemente der list zu „überspringen" oder zu filtern (zum Beispiel wählt ein step von 2 jedes zweite Element im Bereich aus):
>>> colors = ["Red", "Purple", "Green", "Yellow", "Orange", "Pink", "Blue", "Grey"]
# If there is no step parameter, the step is assumed to be 1.
>>> middle_colors = colors[2:6]
>>> middle_colors
['Green', 'Yellow', 'Orange', 'Pink']
# If the start or stop parameters are omitted, the slice will
# start at index zero, and will stop at the end of the list.
>>> primary_colors = colors[::3]
>>> primary_colors
['Red', 'Yellow', 'Blue']
Arbeiten mit Listen
Die eingebaute Funktion sum() gibt bei einer Liste die Summe aller Zahlen in der Liste zurück:
>>> number_list = [1, 2, 3, 4]
>>> sum(number_list)
10
Du kannst auch die Länge einer Liste mit der Funktion len() ermitteln:
>>> long_list = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
>>> len(long_list)
10
Listen können auch auf verschiedene Weise kombiniert werden:
# Using the plus + operator unpacks each list and creates a new list, but it is not efficient.
>>> new_via_concatenate = ["George", 5] + ["cat", "Tabby"]
>>> new_via_concatenate
['George', 5, 'cat', 'Tabby']
# Likewise, using the multiplication operator * is the equivalent of using + n times.
>>> first_group = ["cat", "dog", "elephant"]
>>> multiplied_group = first_group * 3
>>> multiplied_group
['cat', 'dog', 'elephant', 'cat', 'dog', 'elephant', 'cat', 'dog', 'elephant']
Listen stellen einen Iterator bereit und können auf dieselbe Weise wie andere Sequenztypen durchlaufen werden.
# Looping through the list and printing out each element.
>>> colors = ["Orange", "Green", "Grey", "Blue"]
>>> for item in colors:
... print(item)
...
Orange
Green
Grey
Blue
Für eine ausführlichere Erklärung von loops und iterators schließe das Konzept loops ab.
Lernübung
