Listen verstehen in Python 3

Einführung

A list is a data structure in Python that is a mutable, or changeable, ordered sequence of elements. Each element or value that is inside of a list is called an item. Just as strings are defined as characters between quotes, lists are defined by having values between square brackets [ ].

Listen sind großartig, wenn Sie mit vielen verwandten Werten arbeiten möchten. Sie ermöglichen es Ihnen, Daten zusammenzuhalten, die zusammengehören, Ihren Code zu kondensieren und dieselben Methoden und Operationen gleichzeitig auf mehreren Werten auszuführen.

Beim Nachdenken über Python-Listen und andere Datenstrukturen, die Arten von Sammlungen sind, ist es nützlich, alle verschiedenen Sammlungen zu berücksichtigen, die Sie auf Ihrem Computer haben: Ihre Auswahl an Dateien, Ihre Song-Playlists, Ihre Browser-Lesezeichen, Ihre E-Mails, die Sammlung von Videos, auf die Sie auf einem Streaming-Dienst zugreifen können, und mehr.

Voraussetzungen

Sie sollten Python 3 installiert und eine Programmierumgebung auf Ihrem Computer oder Server eingerichtet haben. Wenn Sie keine Programmierumgebung eingerichtet haben, können Sie sich auf die Installations- und Einrichtungsanleitungen für eine lokale Programmierumgebung oder für eine Programmierumgebung auf Ihrem Server beziehen, die für Ihr Betriebssystem (Ubuntu, CentOS, Debian usw.) geeignet ist.

Zeichenfolgenlisten

Um loszulegen, erstellen wir eine Liste, die Elemente des Zeichenfolgen-Datentyps enthält:

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

Wenn wir die Liste ausgeben, reagiert die Ausgabe genau wie die von uns erstellte Liste:

print(sea_creatures)

Output
['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

Als geordnete Sequenz von Elementen kann jedes Element in einer Liste einzeln über Indexierung aufgerufen werden. Listen sind ein zusammengesetzter Datentyp, der aus kleineren Teilen besteht, und sind sehr flexibel, weil sie Werte hinzufügen, entfernen und ändern können. Wenn Sie viele Werte speichern müssen oder über Werte iterieren möchten und diese Werte schnell ändern möchten, möchten Sie wahrscheinlich mit Listen-Datentypen arbeiten.

In diesem Tutorial gehen wir einige Möglichkeiten durch, wie wir mit Listen in Python arbeiten können.

Indexierung von Listen

Jedes Element in einer Liste entspricht einer Indexnummer, die einen ganzzahligen Wert hat und mit der Indexnummer 0 beginnt.

Für die Liste sea_creatures sieht die Indexaufschlüsselung wie folgt aus:

Der erste Eintrag, der String 'hai', beginnt am Index 0, und die Liste endet am Index 4 mit dem Eintrag 'anemone'.

Weil jedem Element in einer Python-Liste eine entsprechende Indexnummer zugeordnet ist, können wir Listen auf dieselbe Weise zugreifen und manipulieren wie andere sequenzielle Datentypen.

Jetzt können wir ein einzelnes Element der Liste aufrufen, indem wir auf seine Indexnummer verweisen:

print(sea_creatures[1])

Output
cuttlefish

Die Indexnummern für diese Liste reichen von 0–4, wie in der obigen Tabelle gezeigt. Um einzelne Elemente aufzurufen, würden wir also die Indexnummern wie folgt angeben:

sea_creatures[0] = 'shark'
sea_creatures[1] = 'cuttlefish'
sea_creatures[2] = 'squid'
sea_creatures[3] = 'mantis shrimp'
sea_creatures[4] = 'anemone'

Wenn wir die Liste sea_creatures mit einer Indexnummer aufrufen, die größer als 4 ist, wird sie außerhalb des Bereichs liegen, da sie ungültig sein wird:

print(sea_creatures[18])

Output
IndexError: list index out of range

Zusätzlich zu positiven Indexnummern können wir auch Elemente aus der Liste mit einer negativen Indexnummer abrufen, indem wir rückwärts von Ende der Liste aus zählen, beginnend bei -1. Dies ist besonders nützlich, wenn wir eine lange Liste haben und ein Element gegen Ende einer Liste genau bestimmen möchten.

Für dieselbe Liste sea_creatures sieht die Aufschlüsselung der negativen Indizes wie folgt aus:

Also, wenn wir das Element 'tintenfisch' ausdrucken möchten, indem wir seine negative Indexnummer verwenden, können wir dies folgendermaßen tun:

print(sea_creatures[-3])

Output
squid

Wir können String-Elemente in einer Liste mit anderen Zeichenketten mithilfe des +-Operators konkatenieren:

print('Sammy is a ' + sea_creatures[0])

Output
Sammy is a shark

Wir konnten das Zeichenfolgenelement am Index 0 mit der Zeichenfolge 'Sammy is a ' verknüpfen. Wir können auch den +-Operator verwenden, um 2 oder mehr Listen zusammenzuführen.

Mit Indexnummern, die Elementen in einer Liste entsprechen, können wir auf jedes Element einer Liste diskret zugreifen und mit diesen Elementen arbeiten.

Ändern von Elementen in Listen

Wir können Indizierung verwenden, um Elemente innerhalb der Liste zu ändern, indem wir eine Indexnummer auf einen anderen Wert setzen. Dies gibt uns eine größere Kontrolle über Listen, da wir die Elemente, die sie enthalten, ändern und aktualisieren können.

Wenn wir den Zeichenfolgenwert des Elements am Index 1 von 'cuttlefish' in 'octopus' ändern möchten, können wir dies folgendermaßen tun:

sea_creatures[1] = 'octopus'

Wenn wir jetzt sea_creatures drucken, wird die Liste anders sein:

print(sea_creatures)

Output
['shark', 'octopus', 'squid', 'mantis shrimp', 'anemone']

Wir können den Wert eines Elements auch ändern, indem wir eine negative Indexnummer verwenden:

sea_creatures[-3] = 'blobfish'
print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']

Jetzt wurde 'blobfish' anstelle von 'squid' an der negativen Indexnummer -3 (die der positiven Indexnummer 2 entspricht) platziert.

Die Möglichkeit, Elemente in Listen zu ändern, gibt uns die Möglichkeit, Listen auf effiziente Weise zu ändern und zu aktualisieren.

Liste schneiden

Wir können auch einige Elemente aus der Liste herausgreifen. Angenommen, wir möchten nur die mittleren Elemente von sea_creatures ausgeben, das können wir tun, indem wir einen Slice erstellen. Mit Slices können wir mehrere Werte aufrufen, indem wir eine Reihe von Indexnummern erstellen, die durch einen Doppelpunkt getrennt sind [x:y]:

print(sea_creatures[1:4])

Output
['octopus', 'blobfish', 'mantis shrimp']

Beim Erstellen eines Slices, wie z.B. [1:4], ist die erste Indexnummer der Startpunkt des Slices (einschließlich), und die zweite Indexnummer ist der Endpunkt des Slices (ausschließlich), daher werden in unserem obigen Beispiel die Elemente an den Positionen 1, 2 und 3 ausgegeben.

Wenn wir entweder das Ende der Liste einschließen möchten, können wir eine der Zahlen in der Syntax list[x:y] weglassen. Wenn wir beispielsweise die ersten 3 Elemente der Liste sea_creatures ausgeben möchten – was 'shark', 'octopus', 'blobfish' wäre –, können wir dies folgendermaßen tun:

print(sea_creatures[:3])

Output
['shark', 'octopus', 'blobfish']

Dies druckte den Anfang der Liste aus, direkt vor Index 3 stoppend.

Um alle Elemente am Ende einer Liste einzuschließen, würden wir die Syntax umkehren:

print(sea_creatures[2:])

Output
['blobfish', 'mantis shrimp', 'anemone']

Wir können auch negative Indexnummern verwenden, wenn wir Listen schneiden, ähnlich wie positive Indexnummern:

print(sea_creatures[-4:-2])
print(sea_creatures[-3:])

Output
['octopus', 'blobfish']
['blobfish', 'mantis shrimp', 'anemone']

Ein letzter Parameter, den wir beim Slicen verwenden können, heißt Stride, was angibt, wie viele Elemente nach dem ersten Element aus der Liste vorwärts verschoben werden sollen. Bisher haben wir den Stride-Parameter ausgelassen, und Python verwendet standardmäßig einen Stride von 1, sodass jedes Element zwischen zwei Indexnummern abgerufen wird.

Die Syntax für diese Konstruktion lautet liste[x:y:z], wobei z auf den Stride verweist. Lassen Sie uns eine größere Liste erstellen, sie dann slicen und dem Stride einen Wert von 2 geben:

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

print(numbers[1:11:2])

Output
[1, 3, 5, 7, 9]

Unsere Konstruktion zahlen[1:11:2] gibt die Werte zwischen den Indexnummern einschließlich 1 und ausschließlich 11 aus. Dann gibt der Stride-Wert von 2 dem Programm an, nur jedes zweite Element auszugeben.

Wir können die ersten beiden Parameter auslassen und nur den Stride allein als Parameter mit der Syntax liste[::z] verwenden:

print(numbers[::3])

Output
[0, 3, 6, 9, 12]

Wenn wir die Liste zahlen mit einem Stride von 3 ausgeben, werden nur jedes dritte Element gedruckt:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

Das Slicen von Listen mit positiven und negativen Indexnummern und Angabe des Strides ermöglicht es uns, Listen zu manipulieren und die gewünschte Ausgabe zu erhalten.

Listen mit Operatoren bearbeiten

Operatoren können verwendet werden, um Änderungen an Listen vorzunehmen. Wir werden die Verwendung der + und * Operatoren und ihrer zusammengesetzten Formen += und *= überprüfen.

Der + Operator kann verwendet werden, um zwei oder mehr Listen zusammenzuführen:

sea_creatures = ['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']
oceans = ['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

print(sea_creatures + oceans)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

Weil der + Operator konkatenieren kann, kann er verwendet werden, um ein Element (oder mehrere) in Listenform am Ende einer anderen Liste hinzuzufügen. Denken Sie daran, das Element in eckige Klammern zu setzen:

sea_creatures = sea_creatures + ['yeti crab']
print (sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

Der * Operator kann verwendet werden, um Listen zu multiplizieren. Vielleicht müssen Sie Kopien aller Dateien in einem Verzeichnis auf einen Server machen oder eine Wiedergabeliste mit Freunden teilen – in diesen Fällen müssten Sie Datensammlungen multiplizieren.

Lassen Sie uns die Liste sea_creatures mit 2 multiplizieren und die Liste oceans mit 3:

print(sea_creatures * 2)
print(oceans * 3)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']
['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

Indem wir den * Operator verwenden, können wir unsere Listen so oft replizieren, wie wir angeben.

Wir können auch zusammengesetzte Formen der + und * Operatoren mit dem Zuweisungsoperator = verwenden. Die zusammengesetzten Operatoren += und *= können verwendet werden, um Listen auf schnelle und automatisierte Weise zu füllen. Sie können diese Operatoren verwenden, um Listen mit Platzhaltern zu füllen, die Sie später mit vom Benutzer bereitgestellten Eingaben ändern können, zum Beispiel.

Lassen Sie uns ein Element in Listenform zur Liste sea_creatures hinzufügen. Dieses Element wird als Platzhalter fungieren, und wir möchten dieses Platzhalterelement mehrmals hinzufügen. Um dies zu tun, werden wir den += Operator mit einer for-Schleife verwenden.

for x in range(1,4):
    sea_creatures += ['fish']
    print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish', 'fish']

Für jede Iteration der for-Schleife wird ein zusätzliches Listenelement von 'fish' zur ursprünglichen Liste sea_creatures hinzugefügt.

Der *=-Operator verhält sich ähnlich:

sharks = ['shark']

for x in range(1,4):
    sharks *= 2
    print(sharks)

Output
['shark', 'shark']
['shark', 'shark', 'shark', 'shark']
['shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']

Die Operatoren + und * können verwendet werden, um Listen zu verketten und Listen zu multiplizieren. Die zusammengesetzten Operatoren += und *= können Listen verketten und Listen multiplizieren und die neue Identität an die ursprüngliche Liste übergeben.

Entfernen eines Elements aus einer Liste

Elemente können aus Listen entfernt werden, indem das del-Statement verwendet wird. Dies löscht den Wert an der angegebenen Indexnummer innerhalb einer Liste.

Aus der Liste sea_creatures entfernen wir das Element 'octopus'. Dieses Element befindet sich an der Indexposition 1. Um das Element zu entfernen, verwenden wir das del-Statement und rufen dann die Listenvariable und die Indexnummer dieses Elements auf:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1]
print(sea_creatures)

Output
['shark', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

Jetzt ist das Element an der Indexposition 1, der String 'octopus', nicht mehr in unserer Liste sea_creatures enthalten.

Wir können auch einen Bereich mit dem del-Statement angeben. Angenommen, wir möchten nicht nur das Element 'octopus', sondern auch 'blobfish' und 'mantis shrimp' entfernen. Wir können einen Bereich in sea_creatures mit dem del-Statement aufrufen, um dies zu erreichen:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1:4]
print(sea_creatures)

Output
['shark', 'anemone', 'yeti crab']

Durch die Verwendung eines Bereichs mit der del-Anweisung konnten wir die Elemente zwischen dem Indexwert von 1 (inklusiv) und dem Indexwert von 4 (exklusiv) entfernen, sodass wir eine Liste mit 3 Elementen hatten, nachdem 3 Elemente entfernt wurden.

Die del-Anweisung ermöglicht es uns, bestimmte Elemente aus dem Listen-Datentyp zu entfernen.

Erstellen einer Liste mit Listenelementen

Listen können mit Elementen definiert werden, die aus Listen bestehen, wobei jede eckige Liste innerhalb der größeren eckigen Klammern der übergeordneten Liste eingeschlossen ist:

sea_names = [['shark', 'octopus', 'squid', 'mantis shrimp'],['Sammy', 'Jesse', 'Drew', 'Jamie']]

Diese Listen innerhalb von Listen werden verschachtelte Listen genannt.

Um auf ein Element innerhalb dieser Liste zuzugreifen, müssen wir mehrere Indizes verwenden:

print(sea_names[1][0])
print(sea_names[0][0])

Output
Sammy
shark

Die erste Liste, da sie einem Element entspricht, wird den Indexwert 0 haben, der die erste Zahl im Aufbau sein wird, und die zweite Liste wird den Indexwert 1 haben. Innerhalb jeder inneren verschachtelten Liste werden separate Indexwerte vorhanden sein, die wir im zweiten Indexwert aufrufen werden:

sea_names[0][0] = 'shark'
sea_names[0][1] = 'octopus'
sea_names[0][2] = 'squid'
sea_names[0][3] = 'mantis shrimp'

sea_names[1][0] = 'Sammy'
sea_names[1][1] = 'Jesse'
sea_names[1][2] = 'Drew'
sea_names[1][3] = 'Jamie'

Bei der Arbeit mit Listen von Listen ist es wichtig, daran zu denken, dass Sie sich auf mehr als einen Indexwert beziehen müssen, um spezifische Elemente innerhalb der entsprechenden verschachtelten Liste abzurufen.

Fazit

Die Listen-Datentyp ist ein flexibler Datentyp, der im Verlauf Ihres Programms modifiziert werden kann. In diesem Tutorial wurden die grundlegenden Funktionen von Listen behandelt, einschließlich Indexierung, Slicing, Modifizierung und Listenkonkatenation.

Von hier aus können Sie mehr über die Arbeit mit Listen in Python erfahren, indem Sie „Wie man Listenmethoden verwendet“ lesen, und über Listenverständnisse, um Listen basierend auf vorhandenen Listen zu erstellen. Um mehr über Datentypen im Allgemeinen zu erfahren, können Sie unser Tutorial „Verständnis von Datentypen“ lesen.