Listen in Python bearbeiten

PythonPythonBeginner
Jetzt üben

Einführung

In diesem Lab sammeln Sie praktische Erfahrungen im Umgang mit Listen in Python. Listen sind eine grundlegende Datenstruktur zur Speicherung geordneter Sammlungen von Elementen. Sie lernen, wie man Listenelemente erstellt, darauf zugreift, hinzufügt, entfernt und modifiziert.

Darüber hinaus führt Sie dieses Lab durch fortgeschrittenere Operationen wie das Sortieren, Abfragen und Verschachteln von Listen. Am Ende dieses Labs werden Sie ein solides Verständnis dafür entwickelt haben, wie Sie effektiv mit Listen arbeiten können, um Daten in Ihren Python-Programmen zu verwalten und zu verarbeiten.

Dies ist ein Guided Lab, das schrittweise Anweisungen bietet, um Ihnen beim Lernen und Üben zu helfen. Befolgen Sie die Anweisungen sorgfältig, um jeden Schritt abzuschließen und praktische Erfahrungen zu sammeln. Historische Daten zeigen, dass dies ein Labor der Stufe Anfänger mit einer Abschlussquote von 100% ist. Es hat eine positive Bewertungsrate von 100% von den Lernenden erhalten.

Listen erstellen und darauf zugreifen

In diesem Schritt lernen Sie, wie man Listen erstellt und auf deren Elemente zugreift. Listen sind geordnete, veränderbare (mutable) 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. Beginnen wir mit der Erstellung einiger Listen.

Suchen Sie im WebIDE-Dateiexplorer auf der linken Seite die Datei list_creation.py im Verzeichnis ~/project und öffnen Sie diese. Fügen Sie den folgenden Code in die Datei ein:

## Create an empty list
empty_list = []
print("Empty list:", empty_list)
print("Type of empty_list:", type(empty_list))

## Create a list of numbers
numbers = [10, 20, 30, 40, 50]
print("Numbers list:", numbers)

## Lists can contain elements of different data types
mixed_list = [1, 'hello', 3.14, True]
print("Mixed data type list:", mixed_list)

## You can also create a list from another iterable, like a string
string_list = list("python")
print("List from a string:", string_list)

Nachdem Sie den Code hinzugefügt haben, speichern Sie die Datei. Um das Skript auszuführen, öffnen Sie das integrierte Terminal in der WebIDE und führen Sie den folgenden Befehl aus:

python ~/project/list_creation.py

Sie sollten die folgende Ausgabe sehen, die verschiedene Möglichkeiten zur Erstellung einer Liste demonstriert:

Empty list: []
Type of empty_list: <class 'list'>
Numbers list: [10, 20, 30, 40, 50]
Mixed data type list: [1, 'hello', 3.14, True]
List from a string: ['p', 'y', 't', 'h', 'o', 'n']

Als Nächstes untersuchen wir, wie man auf Elemente innerhalb einer Liste zugreift. Sie können auf Elemente über ihren Index (Position) zugreifen. Die Listenindizierung beginnt bei 0. Sie können auch negative Indizes verwenden, wobei -1 auf das letzte Element verweist.

Slicing (Teilbereichs-Extraktion) ermöglicht es Ihnen, einen Bereich von Elementen abzurufen. Die Syntax lautet list[start:stop:step].

Fügen Sie den folgenden Code am Ende Ihrer Datei list_creation.py hinzu:

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

## Access the first element (index 0)
print("First element:", fruits[0])

## Access the last element (index -1)
print("Last element:", fruits[-1])

## Slicing: get elements from index 1 up to (but not including) index 4
print("Slice [1:4]:", fruits[1:4])

## Slicing: get all elements from the beginning up to index 3
print("Slice [:3]:", fruits[:3])

## Slicing: get all elements from index 2 to the end
print("Slice [2:]:", fruits[2:])

## Slicing: get a copy of the entire list
print("Slice [:] (a copy):", fruits[:])

## Slicing with a step: get every second element
print("Slice [::2]:", fruits[::2])

## Slicing to reverse the list
print("Reversed list [::-1]:", fruits[::-1])

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

python ~/project/list_creation.py

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

Empty list: []
Type of empty_list: <class 'list'>
Numbers list: [10, 20, 30, 40, 50]
Mixed data type list: [1, 'hello', 3.14, True]
List from a string: ['p', 'y', 't', 'h', 'o', 'n']

--- Accessing Elements ---
Fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi']
First element: orange
Last element: kiwi
Slice [1:4]: ['apple', 'pear', 'banana']
Slice [:3]: ['orange', 'apple', 'pear']
Slice [2:]: ['pear', 'banana', 'kiwi']
Slice [:] (a copy): ['orange', 'apple', 'pear', 'banana', 'kiwi']
Slice [::2]: ['orange', 'pear', 'kiwi']
Reversed list [::-1]: ['kiwi', 'banana', 'pear', 'apple', 'orange']

Sie haben nun gelernt, wie man Listen erstellt und auf deren Inhalte zugreift.

Elemente hinzufügen, entfernen und ändern

In diesem Schritt lernen Sie, wie Sie Listen modifizieren können. Da Listen veränderbar (mutable) sind, können Sie deren Elemente nach ihrer Erstellung hinzufügen, entfernen oder ändern.

Zuerst konzentrieren wir uns auf das Hinzufügen von Elementen. Python bietet hierfür mehrere Methoden:

  • append(): Fügt ein einzelnes Element am Ende der Liste hinzu.
  • extend(): Fügt alle Elemente eines Iterierbaren (wie einer anderen Liste) am Ende hinzu.
  • insert(): Fügt ein Element an einem bestimmten Index ein.

Öffnen Sie die Datei list_modification.py im WebIDE-Dateiexplorer. Fügen Sie den folgenden Code hinzu:

## --- Adding Elements ---
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()
my_list.extend([5, 6])
print("After extend([5, 6]):", my_list)

## Insert an element at a specific position
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 sie im Terminal aus:

python ~/project/list_modification.py

Ihre Ausgabe sollte zeigen, wie die Liste mit jeder Operation wächst:

Original list: [1, 2, 3]
After append(4): [1, 2, 3, 4]
After extend([5, 6]): [1, 2, 3, 4, 5, 6]
After insert(1, 1.5): [1, 1.5, 2, 3, 4, 5, 6]

Als Nächstes üben wir das Entfernen von Elementen. Zu den wichtigsten Methoden gehören:

  • remove(): Entfernt das erste Vorkommen eines angegebenen Wertes.
  • pop(): Entfernt und gibt das Element an einem gegebenen Index zurück (oder das letzte Element, wenn kein Index angegeben ist).
  • del: Eine Anweisung zum Entfernen eines Elements oder eines Slice nach Index.
  • clear(): Entfernt alle Elemente aus der Liste.

Fügen Sie den folgenden Code am Ende von list_modification.py hinzu:

## --- Removing Elements ---
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple']
print("\n--- Removing Elements ---")
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 by its value using remove()
fruits.remove('pear')
print("After remove('pear'):", fruits)

## Remove an element by its index using del
del fruits[1] ## Deletes 'apple' at index 1
print("After del fruits[1]:", fruits)

## Clear all elements from the list
fruits.clear()
print("After clear():", fruits)

Schließlich können Sie bestehende Elemente ändern, indem Sie einem Index oder einem Slice einen neuen Wert zuweisen. Fügen Sie diesen letzten Codeblock zu list_modification.py hinzu:

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

## Change a single element
letters[0] = 'A'
print("After changing index 0:", letters)

## Change a slice of elements
letters[1:3] = ['B', 'C']
print("After changing slice [1:3]:", letters)

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

python ~/project/list_modification.py

Die vollständige Ausgabe demonstriert alle Modifikationstechniken, die Sie gelernt haben:

Original list: [1, 2, 3]
After append(4): [1, 2, 3, 4]
After extend([5, 6]): [1, 2, 3, 4, 5, 6]
After insert(1, 1.5): [1, 1.5, 2, 3, 4, 5, 6]

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

--- Changing Elements ---
Original letters list: ['a', 'b', 'c', 'd', 'e']
After changing index 0: ['A', 'b', 'c', 'd', 'e']
After changing slice [1:3]: ['A', 'B', 'C', 'd', 'e']

Sie sind nun versiert im Hinzufügen, Entfernen und Ändern von Elementen in einer Python-Liste.

Sortieren, Abfragen und Verschachtelung

In diesem letzten Schritt erkunden Sie fortgeschrittenere Listenoperationen, einschließlich des Sortierens, des Abrufens von Informationen und der Arbeit mit verschachtelten Listen (nested lists).

Beginnen wir mit dem Sortieren. Die Methode sort() modifiziert die Liste direkt (in-place). Sie können sowohl aufsteigend als auch absteigend sortieren.

Öffnen Sie die Datei list_operations.py im WebIDE. Fügen Sie den folgenden Code hinzu, um das Sortieren zu demonstrieren:

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

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

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

## The reverse() method simply reverses the order, it does not sort
letters = ['a', 'b', 'c', 'd']
print("\nOriginal letters list:", letters)
letters.reverse()
print("After reverse():", letters)

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

python ~/project/list_operations.py

Die Ausgabe zeigt die sortierten und umgekehrten Listen:

--- 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 letters list: ['a', 'b', 'c', 'd']
After reverse(): ['d', 'c', 'b', 'a']

Als Nächstes fragen wir eine Liste ab, um Informationen zu finden.

  • count(): Gibt die Häufigkeit (Anzahl) eines Wertes zurück.
  • index(): Gibt den Index des ersten Vorkommens eines Wertes zurück.

Fügen Sie den folgenden Code zu list_operations.py hinzu:

## --- Querying Lists ---
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
print("\n--- Querying Lists ---")
print("Fruits list:", fruits)

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

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

Schließlich betrachten wir verschachtelte Listen (nested lists). Eine verschachtelte Liste ist eine Liste, die andere Listen als ihre Elemente enthält. Dies ist nützlich für die Erstellung von 2D-Strukturen wie einer Matrix oder einem Raster (Grid).

Fügen Sie diesen letzten Codeblock zu list_operations.py hinzu:

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

## Access an entire inner list (a row)
first_row = matrix[0]
print("First row:", first_row)

## Access a specific element in the nested list
## To get the element '6', we access row 1, then column 2
element = matrix[1][2]
print("Element at matrix[1][2]:", element)

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

python ~/project/list_operations.py

Die vollständige Ausgabe demonstriert das Sortieren, Abfragen und den Zugriff auf verschachtelte Listen:

--- 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 letters list: ['a', 'b', 'c', 'd']
After reverse(): ['d', 'c', 'b', 'a']

--- Querying Lists ---
Fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
Count of 'apple': 2
Index of first 'banana': 3

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

Sie haben nun mehrere fortgeschrittene Techniken für die Arbeit mit Python-Listen gemeistert.

Zusammenfassung

In diesem Lab haben Sie die Grundlagen der Bearbeitung von Listen in Python gelernt. Sie begannen damit, Listen mithilfe von eckigen Klammern [] und dem list()-Konstruktor zu erstellen. Sie übten den Zugriff auf Listenelemente mittels Indexierung und Slicing, was für das Abrufen spezifischer Elemente oder Teilmengen einer Liste unerlässlich ist.

Anschließend haben Sie untersucht, wie Listen modifiziert werden können: durch Hinzufügen von Elementen mit append(), extend() und insert(), durch Entfernen von Elementen mit remove(), pop() und del sowie durch Ändern von Elementen mittels Index- und Slice-Zuweisung. Schließlich behandelten Sie fortgeschrittene Operationen, einschließlich des In-Place-Sortierens mit sort(), des Umkehrens mit reverse(), des Abrufens von Informationen mit count() und index() sowie der Strukturierung von Daten mit verschachtelten Listen (nested lists). Sie sind nun gut gerüstet, um Listen effektiv in Ihren Python-Projekten einzusetzen.

Morty Proxy This is a proxified and sanitized view of the page, visit original site.