Listen in Python bearbeiten

PythonPythonBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einleitung

In diesem Labor erhalten Sie praktische Erfahrung mit der Manipulation von Listen in Python, einer grundlegenden Datenstruktur zum Speichern geordneter Sammlungen von Elementen. Sie lernen, wie Sie Listen mit verschiedenen Methoden erstellen und darauf zugreifen, einschließlich eckiger Klammern und des list()-Konstruktors, und wie Sie Listen mit unterschiedlichen Datentypen handhaben.

Aufbauend auf der Erstellung und dem Zugriff auf Listen führt Sie dieses Labor durch das Hinzufügen und Entfernen von Elementen, das Modifizieren und Sortieren von Listeninhalten sowie das Durchführen von Abfragen und das Verschachteln von Listen. Am Ende dieses Labors werden Sie ein solides Verständnis dafür haben, wie Sie effektiv mit Listen arbeiten, um Daten in Ihren Python-Programmen zu verwalten und zu verarbeiten.

Listen erstellen und darauf zugreifen

In diesem Schritt lernen Sie, wie Sie Listen in Python erstellen und darauf zugreifen. Listen sind geordnete Sammlungen von Elementen und gehören zu den vielseitigsten Datentypen in Python.

Listen werden mit eckigen Klammern [] erstellt, wobei die Elemente durch Kommas getrennt sind. Eine leere Liste wird einfach mit [] erstellt.

Beginnen wir mit der Erstellung einer leeren Liste und der Überprüfung ihres Typs. Öffnen Sie das integrierte Terminal in der WebIDE und navigieren Sie zum Verzeichnis ~/project, falls Sie sich nicht bereits dort befinden.

Erstellen Sie eine neue Python-Datei namens list_creation.py im Verzeichnis ~/project mithilfe des Dateiexplorers der WebIDE. Öffnen Sie die Datei und fügen Sie den folgenden Code hinzu:

## Create an empty list
my_list = []
print(my_list)
print(type(my_list))

Speichern Sie die Datei. Führen Sie nun das Skript im Terminal aus:

python ~/project/list_creation.py

Sie sollten die folgende Ausgabe sehen:

[]
<class 'list'>

Als Nächstes erstellen wir eine Liste mit einigen Elementen. Listen können Elemente verschiedener Datentypen enthalten, aber es ist üblich, Elemente desselben Typs zu speichern.

Ändern Sie die Datei list_creation.py, um den folgenden Code einzufügen:

## Create a list with different data types
mixed_list = [1, 'hello', 3.14, True]
print(mixed_list)

## Create a list with elements of the same type
numbers = [10, 20, 30, 40, 50]
print(numbers)

Speichern Sie die Datei und führen Sie das Skript erneut aus:

python ~/project/list_creation.py

Die Ausgabe zeigt den Inhalt der Listen:

[]
<class 'list'>
[1, 'hello', 3.14, True]
[10, 20, 30, 40, 50]

Eine weitere Möglichkeit, Listen zu erstellen, ist die Verwendung des list()-Konstruktors. Dies ist besonders nützlich, um andere iterierbare Objekte (wie Strings oder Tupel) in Listen umzuwandeln.

Ändern Sie die Datei list_creation.py, um Folgendes hinzuzufügen:

## Create a list from a string
string_list = list("python")
print(string_list)

## Create a list from a tuple
my_tuple = (1, 2, 3, 4)
tuple_list = list(my_tuple)
print(tuple_list)

Speichern und führen Sie das Skript aus:

python ~/project/list_creation.py

Die Ausgabe enthält nun die aus dem String und dem Tupel erstellten Listen:

[]
<class 'list'>
[1, 'hello', 3.14, True]
[10, 20, 30, 40, 50]
['p', 'y', 't', 'h', 'o', 'n']
[1, 2, 3, 4]

Schließlich untersuchen wir den Zugriff auf Listenelemente mithilfe von Indizierung und Slicing. Ähnlich wie bei Strings und Tupeln kann auf Listenelemente über ihren Index (Position) zugegriffen werden. Die Indizes beginnen bei 0 für das erste Element. Negative Indizes zählen vom Ende der Liste, wobei -1 das letzte Element ist.

Slicing ermöglicht Ihnen den Zugriff auf einen Bereich von Elementen aus einer Liste. Die Syntax lautet list[start:stop:step], wobei start der Anfangsindex (einschließlich), stop der Endindex (ausschließlich) und step die Schrittweite zwischen den Elementen ist.

Ändern Sie die Datei list_creation.py, um den folgenden Code für den Zugriff auf Elemente hinzuzufügen:

## Accessing list elements
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi']
print(fruits[0])    ## Access the first element
print(fruits[-1])   ## Access the last element

## Slicing lists
print(fruits[1:4])  ## Get elements from index 1 up to (but not including) index 4
print(fruits[:3])   ## Get elements from the beginning up to index 3
print(fruits[2:])   ## Get elements from index 2 to the end
print(fruits[:])    ## Get a copy of the entire list
print(fruits[::2])  ## Get every second element
print(fruits[::-1]) ## Reverse the list

Speichern und führen Sie das Skript aus:

python ~/project/list_creation.py

Beobachten Sie die Ausgabe, um zu sehen, wie Indizierung und Slicing funktionieren:

[]
<class 'list'>
[1, 'hello', 3.14, True]
[10, 20, 30, 40, 50]
['p', 'y', 't', 'h', 'o', 'n']
[1, 2, 3, 4]
orange
kiwi
['apple', 'pear', 'banana']
['orange', 'apple', 'pear']
['pear', 'banana', 'kiwi']
['orange', 'apple', 'pear', 'banana', 'kiwi']
['orange', 'pear', 'kiwi']
['kiwi', 'banana', 'pear', 'apple', 'orange']

Sie haben erfolgreich Listen mit verschiedenen Methoden erstellt und über Indizierung und Slicing auf deren Elemente zugegriffen.

Listenelemente hinzufügen und entfernen

In diesem Schritt lernen Sie, wie Sie Elemente zu einer Liste hinzufügen und daraus entfernen. Da Listen veränderbar (mutable) sind, können Sie deren Inhalt nach der Erstellung einfach ändern.

Es gibt verschiedene Methoden, um Elemente zu einer Liste hinzuzufügen:

  • append(): Fügt ein einzelnes Element am Ende der Liste hinzu.
  • extend(): Fügt Elemente aus einem iterierbaren Objekt (wie einer anderen Liste, einem Tupel oder einem String) am Ende der Liste hinzu.
  • insert(): Fügt ein Element an einem bestimmten Index ein.

Erstellen Sie eine neue Python-Datei namens list_modification.py im Verzeichnis ~/project. Öffnen Sie die Datei und fügen Sie den folgenden Code hinzu, um das Hinzufügen von Elementen zu demonstrieren:

## Create a list
my_list = [1, 2, 3]
print("Original list:", my_list)

## Add an element using append()
my_list.append(4)
print("After append(4):", my_list)

## Add multiple elements using extend() with a list
another_list = [5, 6]
my_list.extend(another_list)
print("After extend([5, 6]):", my_list)

## Add multiple elements using extend() with a string
my_list.extend("abc")
print("After extend('abc'):", my_list)

## Insert an element using insert()
my_list.insert(1, 1.5) ## Insert 1.5 at index 1
print("After insert(1, 1.5):", my_list)

Speichern Sie die Datei und führen Sie das Skript im Terminal aus:

python ~/project/list_modification.py

Die Ausgabe zeigt, wie sich die Liste nach jeder Hinzufügeoperation ändert:

Original list: [1, 2, 3]
After append(4): [1, 2, 3, 4]
After extend([5, 6]): [1, 2, 3, 4, 5, 6]
After extend('abc'): [1, 2, 3, 4, 5, 6, 'a', 'b', 'c']
After insert(1, 1.5): [1, 1.5, 2, 3, 4, 5, 6, 'a', 'b', 'c']

Nun betrachten wir das Entfernen von Elementen aus einer Liste. Auch hierfür stehen mehrere Methoden zur Verfügung:

  • pop(): Entfernt und gibt das Element an einem bestimmten Index zurück. Wenn kein Index angegeben ist, wird das letzte Element entfernt und zurückgegeben.
  • remove(): Entfernt das erste Vorkommen eines angegebenen Werts.
  • clear(): Entfernt alle Elemente aus der Liste.
  • del-Anweisung: Entfernt ein Element an einem bestimmten Index, einen Slice oder die gesamte Liste.

Fügen Sie Ihrer Datei list_modification.py den folgenden Code hinzu, um das Entfernen von Elementen zu demonstrieren:

## Removing list elements
print("\n--- Removing Elements ---")
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
print("Original fruits list:", fruits)

## Remove the last element using pop()
popped_item = fruits.pop()
print("After pop():", fruits)
print("Popped item:", popped_item)

## Remove an element at a specific index using pop()
popped_item_at_index = fruits.pop(1) ## Remove element at index 1 ('apple')
print("After pop(1):", fruits)
print("Popped item at index 1:", popped_item_at_index)

## Remove a specific value using remove()
fruits.remove('banana') ## Removes the first 'banana'
print("After remove('banana'):", fruits)

## Remove a slice using del
del fruits[1:3] ## Remove elements from index 1 up to (but not including) index 3
print("After del fruits[1:3]:", fruits)

## Clear the entire list using clear()
fruits.clear()
print("After clear():", fruits)

## Create a new list to demonstrate deleting the entire list
numbers_to_delete = [1, 2, 3]
print("Numbers list before del:", numbers_to_delete)
del numbers_to_delete ## Deletes the variable and the list
## print("Numbers list after del:", numbers_to_delete) ## This would cause an error as the list no longer exists

Speichern Sie die Datei und führen Sie das Skript aus:

python ~/project/list_modification.py

Beobachten Sie die Ausgabe, um zu verstehen, wie jede Entfernungsmethode die Liste beeinflusst:

Original list: [1, 2, 3]
After append(4): [1, 2, 3, 4]
After extend([5, 6]): [1, 2, 3, 4, 5, 6]
After extend('abc'): [1, 2, 3, 4, 5, 6, 'a', 'b', 'c']
After insert(1, 1.5): [1, 1.5, 2, 3, 4, 5, 6, 'a', 'b', 'c']

--- Removing Elements ---
Original fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
After pop(): ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple']
Popped item: banana
After pop(1): ['orange', 'pear', 'banana', 'kiwi', 'apple']
Popped item at index 1: apple
After remove('banana'): ['orange', 'pear', 'kiwi', 'apple']
After del fruits[1:3]: ['orange', 'apple']
After clear(): []
Numbers list before del: [1, 2, 3]

Sie haben nun gelernt, wie Sie Elemente mithilfe verschiedener Methoden zu Listen hinzufügen und daraus entfernen.

Listen modifizieren und sortieren

In diesem Schritt lernen Sie, wie Sie vorhandene Elemente in einer Liste modifizieren und wie Sie Listen sortieren.

Sie können Listenelemente modifizieren, indem Sie einem bestimmten Index oder einem Slice einen neuen Wert zuweisen.

Erstellen Sie eine neue Python-Datei namens list_modify_sort.py im Verzeichnis ~/project. Öffnen Sie die Datei und fügen Sie den folgenden Code hinzu, um die Modifikation von Elementen zu demonstrieren:

## Create a list
my_list = ['a', 'b', 'c', 'd', 'e']
print("Original list:", my_list)

## Modify an element by index
my_list[0] = 'A'
print("After modifying index 0:", my_list)

## Modify a slice
my_list[1:3] = ['B', 'C']
print("After modifying slice [1:3]:", my_list)

## Replace a slice with a different number of elements
my_list[3:] = ['D', 'E', 'F', 'G']
print("After replacing slice [3:]:", my_list)

## Clear a slice
my_list[1:4] = []
print("After clearing slice [1:4]:", my_list)

## Clear the entire list by assigning an empty list to a slice
my_list[:] = []
print("After clearing entire list:", my_list)

Speichern Sie die Datei und führen Sie das Skript aus:

python ~/project/list_modify_sort.py

Die Ausgabe zeigt die Liste nach jeder Modifikation:

Original list: ['a', 'b', 'c', 'd', 'e']
After modifying index 0: ['A', 'b', 'c', 'd', 'e']
After modifying slice [1:3]: ['A', 'B', 'C', 'd', 'e']
After replacing slice [3:]: ['A', 'B', 'C', 'D', 'E', 'F', 'G']
After clearing slice [1:4]: ['A', 'D', 'E', 'F', 'G']
After clearing entire list: []

Nun erkunden wir das Sortieren von Listen. Python-Listen verfügen über eine integrierte Methode sort(), die die Liste direkt (in-place) sortiert. Standardmäßig wird aufsteigend sortiert.

Fügen Sie Ihrer Datei list_modify_sort.py den folgenden Code hinzu, um das Sortieren zu demonstrieren:

## Sorting lists
print("\n--- Sorting Lists ---")
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print("Original numbers list:", numbers)

## Sort the list in ascending order
numbers.sort()
print("After sort():", numbers)

## Sort the list in descending order using the reverse parameter
numbers.sort(reverse=True)
print("After sort(reverse=True):", numbers)

## Sorting a list of strings
words = ['banana', 'apple', 'Orange', 'Kiwi']
print("Original words list:", words)

## Default string sort (case-sensitive)
words.sort()
print("After sort() (case-sensitive):", words)

## Sort case-insensitively using the key parameter
words.sort(key=str.lower)
print("After sort(key=str.lower):", words)

## Sort by length using the key parameter
words.sort(key=len)
print("After sort(key=len):", words)

Speichern Sie die Datei und führen Sie das Skript aus:

python ~/project/list_modify_sort.py

Beobachten Sie die Ausgabe, um die verschiedenen Sortierverhalten zu sehen:

Original list: ['a', 'b', 'c', 'd', 'e']
After modifying index 0: ['A', 'b', 'c', 'd', 'e']
After modifying slice [1:3]: ['A', 'B', 'C', 'd', 'e']
After replacing slice [3:]: ['A', 'B', 'C', 'D', 'E', 'F', 'G']
After clearing slice [1:4]: ['A', 'D', 'E', 'F', 'G']
After clearing entire list: []

--- Sorting Lists ---
Original numbers list: [3, 1, 4, 1, 5, 9, 2, 6]
After sort(): [1, 1, 2, 3, 4, 5, 6, 9]
After sort(reverse=True): [9, 6, 5, 4, 3, 2, 1, 1]
Original words list: ['banana', 'apple', 'Orange', 'Kiwi']
After sort() (case-sensitive): ['Kiwi', 'Orange', 'apple', 'banana']
After sort(key=str.lower): ['apple', 'banana', 'Kiwi', 'Orange']
After sort(key=len): ['Kiwi', 'apple', 'Orange', 'banana']

Schließlich betrachten wir die Methode reverse(), die die Elemente der Liste direkt (in-place) umkehrt. Dies unterscheidet sich vom Sortieren in umgekehrter Reihenfolge.

Fügen Sie Ihrer Datei list_modify_sort.py den folgenden Code hinzu:

## Reversing a list
print("\n--- Reversing List ---")
letters = ['a', 'b', 'c', 'd']
print("Original letters list:", letters)

## Reverse the list
letters.reverse()
print("After reverse():", letters)

Speichern und führen Sie das Skript aus:

python ~/project/list_modify_sort.py

Die Ausgabe zeigt die umgekehrte Liste:

Original list: ['a', 'b', 'c', 'd', 'e']
After modifying index 0: ['A', 'b', 'c', 'd', 'e']
After modifying slice [1:3]: ['A', 'B', 'C', 'd', 'e']
After replacing slice [3:]: ['A', 'B', 'C', 'D', 'E', 'F', 'G']
After clearing slice [1:4]: ['A', 'D', 'E', 'F', 'G']
After clearing entire list: []

--- Sorting Lists ---
Original numbers list: [3, 1, 4, 1, 5, 9, 2, 6]
After sort(): [1, 1, 2, 3, 4, 5, 6, 9]
After sort(reverse=True): [9, 6, 5, 4, 3, 2, 1, 1]
Original words list: ['banana', 'apple', 'Orange', 'Kiwi']
After sort() (case-sensitive): ['Kiwi', 'Orange', 'apple', 'banana']
After sort(key=str.lower): ['apple', 'banana', 'Kiwi', 'Orange']
After sort(key=len): ['Kiwi', 'apple', 'Orange', 'banana']

--- Reversing List ---
Original letters list: ['a', 'b', 'c', 'd']
After reverse(): ['d', 'c', 'b', 'a']

Sie haben erfolgreich Listenelemente modifiziert und Listen mithilfe verschiedener Methoden sortiert/umgekehrt.

Listen abfragen und verschachteln

In diesem Schritt lernen Sie, wie Sie Informationen über Listenelemente abfragen und mit verschachtelten Listen arbeiten.

Sie können Listen abfragen, um herauszufinden, wie oft ein Element vorkommt oder um den Index eines Elements zu finden.

  • count(): Gibt zurück, wie oft ein bestimmter Wert in der Liste vorkommt.
  • index(): Gibt den Index des ersten Vorkommens eines bestimmten Werts zurück. Sie können optional einen Start- und Endindex angeben, um innerhalb einer Teilliste zu suchen.

Erstellen Sie eine neue Python-Datei namens list_query_nest.py im Verzeichnis ~/project. Öffnen Sie die Datei und fügen Sie den folgenden Code hinzu, um das Abfragen von Listen zu demonstrieren:

## Create a list with duplicate elements
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
print("Fruits list:", fruits)

## Count the occurrences of an element
apple_count = fruits.count('apple')
print("Count of 'apple':", apple_count)

banana_count = fruits.count('banana')
print("Count of 'banana':", banana_count)

tangerine_count = fruits.count('tangerine')
print("Count of 'tangerine':", tangerine_count)

## Find the index of an element
banana_index = fruits.index('banana')
print("Index of first 'banana':", banana_index)

## Find the index of an element starting from a specific index
second_banana_index = fruits.index('banana', 4) ## Search from index 4 onwards
print("Index of second 'banana' (starting from index 4):", second_banana_index)

## Trying to find an element that doesn't exist will raise a ValueError
## try:
##     fruits.index('grape')
## except ValueError as e:
##     print("Error:", e)

Speichern Sie die Datei und führen Sie das Skript aus:

python ~/project/list_query_nest.py

Die Ausgabe zeigt die Ergebnisse der count- und index-Operationen:

Fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
Count of 'apple': 2
Count of 'banana': 2
Count of 'tangerine': 0
Index of first 'banana': 3
Index of second 'banana' (starting from index 4): 6

Nun erkunden wir verschachtelte Listen. Eine verschachtelte Liste ist eine Liste, die andere Listen als Elemente enthält. Dies ermöglicht es Ihnen, komplexere Datenstrukturen wie Matrizen oder Tabellen zu erstellen.

Fügen Sie Ihrer Datei list_query_nest.py den folgenden Code hinzu, um verschachtelte Listen zu demonstrieren:

## Nested lists
print("\n--- Nested Lists ---")
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print("Matrix:", matrix)

## Access elements in a nested list
## Access the first inner list
first_row = matrix[0]
print("First row:", first_row)

## Access an element within an inner list
element = matrix[1][2] ## Access the element at row 1, column 2 (which is 6)
print("Element at matrix[1][2]:", element)

## Access another element
another_element = matrix[2][0] ## Access the element at row 2, column 0 (which is 7)
print("Element at matrix[2][0]:", another_element)

Speichern Sie die Datei und führen Sie das Skript aus:

python ~/project/list_query_nest.py

Die Ausgabe zeigt die verschachtelte Liste und wie auf ihre Elemente zugegriffen wird:

Fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
Count of 'apple': 2
Count of 'banana': 2
Count of 'tangerine': 0
Index of first 'banana': 3
Index of second 'banana' (starting from index 4): 6

--- Nested Lists ---
Matrix: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
First row: [1, 2, 3]
Element at matrix[1][2]: 6
Element at matrix[2][0]: 7

Schließlich werfen wir einen kurzen Blick auf die Listenoperatoren. Einige davon haben Sie bereits gesehen, aber es ist gut, sie im Kontext von Listen zu festigen.

Fügen Sie Ihrer Datei list_query_nest.py den folgenden Code hinzu:

## List operators
print("\n--- List Operators ---")

## Concatenation using +
list1 = [1, 2]
list2 = [3, 4]
combined_list = list1 + list2
print("list1 + list2:", combined_list)

## Repetition using *
repeated_list = [0] * 5
print("[0] * 5:", repeated_list)

## Membership testing using in and not in
print("3 in [1, 2, 3]:", 3 in [1, 2, 3])
print("5 in [1, 2, 3]:", 5 in [1, 2, 3])
print("5 not in [1, 2, 3]:", 5 not in [1, 2, 3])

Speichern und führen Sie das Skript aus:

python ~/project/list_query_nest.py

Die Ausgabe demonstriert die Verwendung von Listenoperatoren:

Fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
Count of 'apple': 2
Count of 'banana': 2
Count of 'tangerine': 0
Index of first 'banana': 3
Index of second 'banana' (starting from index 4): 6

--- Nested Lists ---
Matrix: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
First row: [1, 2, 3]
Element at matrix[1][2]: 6
Element at matrix[2][0]: 7

--- List Operators ---
list1 + list2: [1, 2, 3, 4]
[0] * 5: [0, 0, 0, 0, 0]
3 in [1, 2, 3]: True
5 in [1, 2, 3]: False
5 not in [1, 2, 3]: True

Sie haben erfolgreich gelernt, wie Sie Listen abfragen, mit verschachtelten Listen arbeiten und gängige Listenoperatoren verwenden.

Zusammenfassung

In diesem Lab haben Sie die Grundlagen der Listenmanipulation in Python gelernt. Sie haben damit begonnen, wie Listen mit eckigen Klammern [] und dem list()-Konstruktor erstellt werden, einschließlich der Erstellung leerer Listen und Listen mit verschiedenen Datentypen. Sie haben auch das Zugreifen auf Listenelemente mithilfe von Indizierung und Slicing geübt, was für das Abrufen bestimmter Elemente oder Teilmengen einer Liste unerlässlich ist.

Aufbauend auf Erstellung und Zugriff haben Sie untersucht, wie Listen durch Hinzufügen und Entfernen von Elementen mithilfe von Methoden wie append(), insert(), remove() und pop() modifiziert werden. Sie haben auch gelernt, wie vorhandene Elemente geändert werden, indem Sie neuen Werten bestimmte Indizes zuweisen. Darüber hinaus haben Sie das Sortieren von Listen in aufsteigender und absteigender Reihenfolge mithilfe der sort()-Methode und der sorted()-Funktion behandelt. Schließlich haben Sie sich mit dem Abfragen von Listen zur Überprüfung der Existenz von Elementen und zum Finden von Elementindizes befasst und das Konzept verschachtelter Listen zur Darstellung komplexerer Datenstrukturen erkundet.