Listen in Python

In diesem Artikel erklären wir Listen in Python.

Sie können verschiedene Operationen mit Listen und List-Comprehensions anhand von Codebeispielen lernen.

YouTube Video

Listen in Python

In Python wird die Datenstruktur, die oft als Array bezeichnet wird, normalerweise als 'Liste' implementiert. Python-Listen sind sehr flexibel und ermöglichen die folgenden Operationen:.

Eine Liste erstellen

1# Create an empty list
2my_list = []
3print(my_list)
4
5# Create a list with elements
6my_list = [1, 2, 3, 4, 5]
7print(my_list)

• Sie können eine Liste leer oder mit angegebenen Anfangselementen erstellen.

Zugreifen auf und Ändern von Listenelementen

1my_list = [1, 2, 3, 4, 5]
2print(my_list)  # [1, 2, 3, 4, 5]
3
4element = my_list[0]  # Get the element at index 0
5print(element)  # 1
6
7my_list[1] = 10  # Change the element at index 1 to 10
8print(my_list)  # [1, 10, 3, 4, 5]

• Listelemente können durch Angabe ihres Indexes abgerufen oder geändert werden.

Die Länge einer Liste ermitteln

1my_list = [1, 2, 3, 4, 5]
2
3length = len(my_list)
4print(my_list)
5print(length)

• Mit der Funktion len() können Sie die Anzahl der Elemente erhalten.

Elemente zu einer Liste hinzufügen und einfügen

1my_list = [1, 2, 3, 4, 5]
2
3my_list.append(6)
4print(my_list)

• Mit der Methode append() können Sie ein Element am Ende einer Liste hinzufügen.

1my_list = [1, 2, 3, 4, 5]
2
3my_list.insert(2, "A")  # Insert "A" at index 2
4print(my_list)

• Mit der Methode insert() können Sie ein Element an einer beliebigen Position einfügen.

Elemente aus einer Liste entfernen

1my_list = [1, 2, 3, 4, 5]
2
3del my_list[2]  # Delete the element at index 2
4print(my_list)
5
6removed_element = my_list.pop(0)  # Delete and return the element at index 0
7print(removed_element)
8print(my_list)

• Mit der Anweisung del oder der Methode pop() können Sie ein Element an einer bestimmten Position entfernen. Die Methode pop() gibt das entfernte Element zurück.

1my_list = [1, 2, 3, 4, 5]
2
3my_list.remove(5)  # Remove the first occurrence of 5 from the list
4print(my_list)

• Mit der Methode remove() können Sie das erste Vorkommen eines bestimmten Werts löschen.

Listen-Slicing

1my_list = [1, 2, 3, 4, 5]
2
3print(my_list[1:3])  # [2, 3]
4print(my_list[:3])   # [1, 2, 3]
5print(my_list[2:])   # [3, 4, 5]
6print(my_list[:])    # [1, 2, 3, 4, 5]

• Die Slicing-Syntax [start:end] erhält Elemente von start bis end - 1. Sie können entweder start oder end weglassen.

Eine Liste sortieren

1my_list = [2, 1, 5, 4, 3]
2print(my_list)  # [2, 1, 5, 4, 3]
3
4my_list.sort()  # Sort in ascending order (modifies the list)
5print(my_list)  # [1, 2, 3, 4, 5]
6
7my_list.sort(reverse=True)  # Sort in descending order
8print(my_list)  # [5, 4, 3, 2, 1]

• Mit der Methode sort() kann eine Liste aufsteigend oder absteigend sortiert werden.

1my_list = [3, 1, 4, 2]
2sorted_list = sorted(my_list)
3print(my_list)       # [3, 1, 4, 2]
4print(sorted_list)   # [1, 2, 3, 4]

• Mit der Funktion sorted() können Sie eine neue sortierte Liste erstellen, ohne die Original-Liste zu verändern.

Erstellen einer umgekehrten Liste

1my_list = [1, 2, 3, 4, 5]
2
3my_list.reverse()
4print(my_list)

• Mit der Methode reverse() kann die Reihenfolge der Elemente in einer Liste umgekehrt werden.

Listen-Komprehension

In Python können Sie die leistungsfähige List-Comprehension-Syntax verwenden, um Listen kurz und prägnant zu generieren. Mit List Comprehensions können Sie den Prozess zur Erzeugung neuer Listen mit for-Schleifen in einer einzigen Zeile schreiben. Sie können auch Bedingungen verwenden, um nur bestimmte Elemente herauszufiltern.

 1# Generate squares of numbers from 0 to 9
 2squares = [x**2 for x in range(10)]
 3print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 4
 5# Use a condition to extract squares of even numbers only
 6even_squares = [x**2 for x in range(10) if x % 2 == 0]
 7print(even_squares)  # [0, 4, 16, 36, 64]
 8
 9# Store either the square or the original number based on a condition
10squares_or_original = [x**2 if x % 2 == 0 else x for x in range(10)]
11print(squares_or_original)
12# Output: [0, 1, 4, 3, 16, 5, 36, 7, 64, 9]

• Mit List Comprehensions können Sie durch Schleifen und Bedingungen neue Listen kurz und prägnant erstellen. Durch die Verwendung von if und if-else können Sie Listenabstraktionen erstellen, die Elemente extrahieren oder je nach Bedingungen unterschiedliche Werte erzeugen.

Verkettung von Listen

 1# Concatenate two lists using the + operator
 2a = [1, 2, 3]
 3b = [4, 5, 6]
 4combined = a + b
 5print(combined)  # [1, 2, 3, 4, 5, 6]
 6
 7# Extend an existing list with another list
 8a = [1, 2, 3]
 9b = [4, 5, 6]
10a.extend(b)
11print(a)  # [1, 2, 3, 4, 5, 6]
12
13# Concatenate multiple lists using unpacking (*)
14a = [1, 2, 3]
15b = [4, 5, 6]
16c = [7, 8, 9]
17merged = [*a, *b, *c]
18print(merged)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

• In Python können Listen mit dem +-Operator, der extend()-Methode oder der Auspack-Syntax (*) verkettet werden. Üblicherweise werden + oder * zum Erstellen einer neuen Liste verwendet und extend(), um eine bestehende Liste zu aktualisieren.

Zusammenfassung

Listen sind eine grundlegende Datenstruktur in Python und werden in vielen Situationen verwendet. Es gibt viele flexible und nützliche Funktionen, und deren Beherrschung macht das Programmieren effizienter.

Sie können den obigen Artikel mit Visual Studio Code auf unserem YouTube-Kanal verfolgen. Bitte schauen Sie sich auch den YouTube-Kanal an.

YouTube Video