Listen in Python erstellen

Die Erstellung von Listen in Python ist ziemlich einfach, entweder mit eckigen Klammern oder dem Listen-Konstruktor. Listen können Elemente verschiedener Datentypen halten, einschließlich Zahlen, Zeichenfolgen, Booleans und sogar anderer Listen. Um eine Liste zu erstellen, umschließt man eine durch Kommas getrennte Sequenz von Elementen in eckigen Klammern:

test_list = ['JBerries', 'is', 'awesome']
print(test_list)
# Ausgabe: ['JBerries', 'is', 'awesome']
print(type(test_list))
# Ausgabe <class 'list'>

mixed_list = [1, "hello", 3.14, True]
print(mixed_list)
# Ausgabe: [1, "hello", 3.14, True]

Alternativ können wir den list() Konstruktor verwenden. Dies ist besonders nützlich, um andere iterable Datentypen wie Tupel oder Zeichenfolgen in Listen umzuwandeln. Zum Beispiel:

my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)  # Ausgabe: [1, 2, 3]

my_string = "hello"
my_list_from_string = list(my_string)
print(my_list_from_string) # Ausgabe: ['h', 'e', 'l', 'l', 'o']

Listenmanipulation

Zugriff auf Listenelemente

Zugriff auf Elemente in einer Liste erfolgt über ihre Indexnummern. Python-Listen sind nullbasiert, was bedeutet, dass das erste Element den Index 0 hat.

test_list = ['JBerries', 'is', 'awesome']
first_element = test_list[0]
print(first_element)  
# Ausgabe: JBerries

second_element = test_list[1]
print(second_element)  
# Ausgabe: is

Um auf Elemente vom Ende einer Liste zuzugreifen, erlaubt Python die Verwendung negativer Indizes, wobei -1 auf das letzte Element verweist, -2 auf das zweitletzte Element und so weiter:

last_element = test_list[-1]
print(last_element)  
# Ausgabe: awesome

Wir können auch Slicing verwenden, um eine Teilmenge von Elementen aus einer Liste zu extrahieren. Die allgemeine Syntax für Slicing ist list[start:stop:step], wobei:

• start der Startindex des Slices (inklusiv) ist
• stop der Endindex des Slices (exklusiv) ist
• step die Schrittgröße zwischen den Elementen im Slice ist

Beispiel 1: Einfaches Slicing

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

In diesem Beispiel starten wir bei Index 1 (inklusiv) und stoppen bei Index 3 (exklusiv). Der resultierende Slice ist [2, 3].

Beispiel 2: Negative Indizes

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

In diesem Beispiel beginnen wir beim zweitletzten Element (-2) und gehen zum Ende der Liste (angezeigt durch :). Der resultierende Slice ist [4, 5].

Beispiel 3: Schrittgröße

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

In diesem Beispiel starten wir am Anfang der Liste und gehen bis zum Ende mit einer Schrittgröße von 2. Der resultierende Slice ist [1, 3, 5].

Beispiel 4: Umkehren einer Liste

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

In diesem Beispiel beginnen wir am Ende der Liste und gehen bis zum Anfang mit einer Schrittgröße von -1. Der resultierende Slice ist die umgekehrte Liste [5, 4, 3, 2, 1].

Hinzufügen oder Entfernen von Elementen

Du kannst Elemente zu einer Liste mit der Methode append() oder der Methode insert() hinzufügen. Die Methode append() fügt ein Element am Ende hinzu.

my_list = ['JBerries', 'is', 'awesome']
my_list.append('!')
print(my_list)  # Ausgabe: ['JBerries', 'is', 'awesome', '!']

Die Methode insert() ermöglicht es dir, ein Element an einem bestimmten Index hinzuzufügen:

my_list.insert(2, 'super')
print(my_list)  # Ausgabe: ['JBerries', 'is', 'super', 'awesome', '!']

Um Elemente zu entfernen, kann die Methode remove() verwendet werden, um die erste Vorkommen eines angegebenen Werts zu entfernen:

my_list.remove('super')
print(my_list)  # Ausgabe: ['JBerries', 'is', 'awesome', '!']

Die Methode pop() entfernt ein Element an einem bestimmten Index und gibt es zurück. Wenn kein Index angegeben ist, entfernt pop() das letzte Element:

removed_item = my_list.pop()
print(removed_item)  # Ausgabe: !
print(my_list)  # Ausgabe: ['JBerries', 'is', 'awesome']

Über eine Liste iterieren

Du kannst einfach über eine Liste mit einer for-Schleife iterieren.

for item in my_list:
    print(item)
# Ausgabe:
# JBerries
# is
# awesome

Du kannst auch die Funktion enumerate() verwenden, um auf sowohl Element als auch Index zuzugreifen:

for index, item in enumerate(my_list):
    print(index, item)
# Ausgabe:
# 0 JBerries
# 1 is
# 2 awesome

List Comprehension

List Comprehension ermöglicht, eine neue Liste zu generieren, indem man eine Operation auf jedes Element in einer bestehenden Liste anwendet.

uppercase_list = [item.upper() for item in my_list]
print(uppercase_list)  # Ausgabe: ['JBERIES', 'IS', 'AWESOME']

List Comprehension kann man auch verwenden, um Elemente zu filtern:

filtered_list = [item for item in my_list if len(item) > 2]
print(filtered_list)  # Ausgabe: ['JBerries', 'awesome']

Sortieren einer Liste

Die Methode sort() sortiert die Liste standardmäßig in aufsteigender Reihenfolge.

unsorted_list = ['JBerries', 'is', 'awesome', 'Python']
unsorted_list.sort()
print(unsorted_list)  # Ausgabe: ['JBerries', 'Python', 'awesome', 'is']

Um in absteigender Reihenfolge zu sortieren, setze den Parameter reverse auf True.

unsorted_list.sort(reverse=True)
print(unsorted_list)  # Ausgabe: ['is', 'awesome', 'Python', 'JBerries']

Du kannst auch die Funktion sorted() verwenden, die eine neue sortierte Liste zurückgibt, ohne die ursprüngliche Liste zu ändern:

new_sorted_list = sorted(unsorted_list)
print(new_sorted_list)  # Ausgabe: ['JBerries', 'Python', 'awesome', 'is']

Duplizieren (Kopieren) einer Liste

Das Duplizieren einer Liste kann auf verschiedene Arten erfolgen. Die einfachste Möglichkeit ist die Verwendung von Slicing.

original_list = ['JBerries', 'is', 'awesome']
duplicate_list = original_list[:]
print(duplicate_list)  # Ausgabe: ['JBerries', 'is', 'awesome']

Du kannst auch die Methode copy() oder den Konstruktor der Liste verwenden:

duplicate_list = original_list.copy()
print(duplicate_list)  # Ausgabe: ['JBerries', 'is', 'awesome']

duplicate_list = list(original_list)
print(duplicate_list)  # Ausgabe: ['JBerries', 'is', 'awesome']

Listen verbinden

Das Verbinden von Listen ermöglicht die Kombination von zwei oder mehr Listen in eine. Du kannst dazu den + Operator verwenden:

list_a = ['JBerries', 'is']
list_b = ['awesome', 'Python']
joined_list = list_a + list_b
print(joined_list)  # Ausgabe: ['JBerries', 'is', 'awesome', 'Python']

Die Methode extend() erleichtert es auch, Elemente von einer Liste zu einer anderen hinzuzufügen:

list_a.extend(list_b)
print(list_a)  # Ausgabe: ['JBerries', 'is', 'awesome', 'Python']

Um den Code lesbarer zu machen, kannst du die Methode itertools.chain() aus der itertools-Bibliothek für umfangreichere Listen verwenden:

import itertools

list_one = ['JBerries', 'is']
list_two = ['awesome', 'Python']
joined_iterable = itertools.chain(list_one, list_two)
joined_list = list(joined_iterable)
print(joined_list)  # Ausgabe: ['JBerries', 'is', 'awesome', 'Python']

Das war's! Du solltest jetzt ein solides Verständnis dafür haben, wie man mit Listen in Python arbeiten kann. Diesen Artikel haben wir auch auf unserer englischsprachigen Seite veröffentlicht: Everything About Lists in Python Viel Spaß beim Programmieren!