Listen in Python 3 verstehen

Einführung

Eine Liste ist eine Datenstruktur in Python, die eine veränderbare oder änderbare, geordnete Folge von Elementen ist. Jedes Element oder jeder Wert, der sich in einer Liste befindet, wird als Element bezeichnet. So wie Zeichenfolgen als Zeichen zwischen Anführungszeichen definiert sind, werden Listen definiert, indem Werte zwischen eckigen Klammern [ ] stehen.

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 verdichten und dieselben Methoden und Operationen gleichzeitig auf mehrere Werte anzuwenden.

Wenn man an Python-Listen und andere Datenstrukturen denkt, die Arten von Sammlungen sind, ist es nützlich, alle unterschiedlichen Sammlungen zu berücksichtigen, die man auf seinem Computer hat: die Vielzahl von Dateien, die man hat, die Musik-Playlists, die Lesezeichen im Browser, die E-Mails, die Sammlung von Videos, auf die man über einen Streaming-Dienst zugreifen kann, 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 auf die Installations- und Einrichtungsanleitungen für eine lokale Programmierumgebung oder für eine Programmierumgebung auf Ihrem Server verweisen, die für Ihr Betriebssystem (Ubuntu, CentOS, Debian usw.) geeignet ist.

Zeilenlisten

Um zu beginnen, erstellen wir eine Liste, die Elemente vom Datentyp String enthält:

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

Wenn wir die Liste ausdrucken, entspricht die Ausgabe genau der Liste, die wir erstellt haben:

print(sea_creatures)

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

Als eine geordnete Sequenz von Elementen kann jedes Element in einer Liste einzeln über Indizes aufgerufen werden. Listen sind ein zusammengesetzter Datentyp, der aus kleineren Teilen besteht, und sind sehr flexibel, da sie Werte hinzugefügt, entfernt und geändert werden können. Wenn Sie viele Werte speichern oder über Werte iterieren müssen und diese Werte leicht ändern möchten, werden Sie wahrscheinlich mit Listen-Datentypen arbeiten wollen.

In diesem Tutorial werden wir einige der Möglichkeiten durchgehen, wie wir mit Listen in Python arbeiten können.

Listen indizieren

Jeder Artikel in einer Liste entspricht einer Indexnummer, die einen ganzzahligen Wert darstellt, beginnend mit der Indexnummer 0.

Für die Liste sea_creatures sieht die Indexaufteilung folgendermaßen aus:

Das erste Element, der String 'shark', beginnt am Index 0, und die Liste endet am Index 4 mit dem Element 'anemone'.

Da jedes Element in einer Python-Liste eine entsprechende Indexnummer hat, können wir Listen auf die gleiche Weise zugreifen und manipulieren wie bei anderen sequentiellen Datentypen.

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

print(sea_creatures[1])

cuttlefish

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

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 Indizes-Nummer aufrufen, die größer als 4 ist, wird sie außerhalb des Bereichs liegen, da sie nicht gültig sein wird:

print(sea_creatures[18])

IndexError: list index out of range

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

Für die gleiche Liste sea_creatures sieht die negative Indexaufteilung folgendermaßen aus:

Wenn wir also den Artikel 'squid' mit seiner negativen Indizes-Nummer ausgeben möchten, können wir dies so tun:

print(sea_creatures[-3])

squid

Wir können Zeichenfolgen in einer Liste mit anderen Zeichenfolgen mithilfe des +-Operators verketten:

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

Sammy is a shark

Wir konnten das Zeichenfolgen-Element an Indexnummer 0 mit der Zeichenfolge 'Sammy ist ein ' verketten. Wir können auch den +-Operator verwenden, um 2 oder mehr Listen zusammenzuführen.

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

Ändern von Elementen in Listen

Wir können Indizes verwenden, um Elemente in der Liste zu ändern, indem wir eine Indexnummer auf einen anderen Wert setzen. Dies gibt uns eine größere Kontrolle über Listen, da wir in der Lage sind, die enthaltenen Elemente zu modifizieren und zu aktualisieren.

Wenn wir den String-Wert des Elements an Index 1 von 'cuttlefish' auf 'octopus' ändern möchten, können wir dies wie folgt tun:

sea_creatures[1] = 'octopus'

Jetzt, wenn wir sea_creatures ausdrucken, wird die Liste anders sein:

print(sea_creatures)

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

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

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

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

Jetzt hat 'blobfish' an der negativen Indexnummer -3 (was der positiven Indexnummer 2 entspricht) den 'squid' ersetzt.

Die Möglichkeit, Elemente in Listen zu ändern, gibt uns die Fähigkeit, Listen effizient zu ändern und zu aktualisieren.

Listen schneiden

Wir können auch einige Elemente aus der Liste aufrufen. Angenommen, wir möchten nur die mittleren Elemente von sea_creatures drucken, können wir dies tun, indem wir eine Teilmenge erstellen. Mit Teilmengen können wir mehrere Werte durch die Erstellung eines Bereichs von Indexnummern, die durch einen Doppelpunkt [x:y] getrennt sind, aufrufen:

print(sea_creatures[1:4])

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

Beim Erstellen eines Slices, wie in [1:4], ist die erste Indexnummer der Startpunkt des Slices (inklusive) und die zweite Indexnummer der Endpunkt des Slices (exklusive). Deshalb sind in unserem obigen Beispiel die Elemente an den Positionen 1, 2 und 3 die Elemente, die ausgegeben werden.

Wenn wir entweder das Ende der Liste einbeziehen möchten, können wir eine der Zahlen in der list[x:y] Syntax weglassen. Zum Beispiel, wenn wir die ersten 3 Elemente der Liste sea_creatures — nämlich 'Hai', 'Oktopus', 'Blobfisch' — ausgeben möchten, können wir dies tun, indem wir Folgendes eingeben:

print(sea_creatures[:3])

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

Dies druckte den Anfang der Liste und hielt direkt vor dem Index 3 an.

Um alle Elemente am Ende einer Liste einzufügen, würden wir die Syntax umkehren:

print(sea_creatures[2:])

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

Wir können auch negative Indexzahlen verwenden, wenn wir Listen schneiden, ähnlich wie bei positiven Indexzahlen:

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

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

Ein letzter Parameter, den wir beim Slicing verwenden können, wird Schrittweite genannt und bezieht sich darauf, wie viele Elemente man nach dem ersten Element, das aus der Liste abgerufen wird, voranschreiten soll. Bisher haben wir den Schrittweitenparameter weggelassen, und Python verwendet standardmäßig eine Schrittweite von 1, sodass jedes Element zwischen zwei Indexnummern abgerufen wird.

Die Syntax für diese Konstruktion ist list[x:y:z], wobei z auf den Schrittwert verweist. Lassen Sie uns eine größere Liste erstellen, sie dann aufteilen und den Schrittwert auf 2 setzen:

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

print(numbers[1:11:2])

[1, 3, 5, 7, 9]

Unser Konstruktion numbers[1:11:2] gibt die Werte zwischen den Indexnummern inklusiv von 1 und exklusiv von 11 aus, dann sagt der Sprungwert von 2 dem Programm, dass es nur jedes zweite Element ausgeben soll.

Wir können die ersten beiden Parameter weglassen und nur den Schritt als Parameter mit der Syntax list[::z] verwenden:

print(numbers[::3])

[0, 3, 6, 9, 12]

Wenn die Liste numbers mit einem Schritt von 3 ausgegeben wird, wird nur jedes dritte Element ausgegeben:

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

Das Aufteilen von Listen mit sowohl positiven als auch negativen Indizes und die Angabe des Schrittes gibt uns die Kontrolle, Listen zu manipulieren und das gewünschte Ergebnis zu erhalten.

Listen mit Operatoren ändern

Operatoren können verwendet werden, um Änderungen an Listen vorzunehmen. Wir werden die Verwendung der +- und *-Operatoren sowie 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)

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

Da der + Operator verkettet, kann er verwendet werden, um ein Element (oder mehrere) in Listenform an das 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)

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

Der * Operator kann verwendet werden, um Listen zu multiplizieren. Möglicherweise müssen Sie alle Dateien in einem Verzeichnis auf einen Server kopieren oder eine Wiedergabeliste mit Freunden teilen – in diesen Fällen müssten Sie Sammlungen von Daten vervielfältigen.

Lass uns die Liste sea_creatures mit 2 multiplizieren und die Liste oceans mit 3:

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

['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']

Durch die Verwendung des *-Operators können wir unsere Listen um die Anzahl der von uns angegebenen Wiederholungen replizieren.

Wir können auch komplexe Formen der + und * Operatoren mit dem Zuweisungsoperator = verwenden. Die += und *= komplexen Operatoren können verwendet werden, um Listen schnell und automatisiert zu füllen. Sie können diese Operatoren verwenden, um Listen mit Platzhaltern zu füllen, die Sie später mit benutzereingaben anpassen können, zum Beispiel.

Lass uns einen Eintrag in Listenform zur Liste sea_creatures hinzufügen. Dieser Eintrag wird als Platzhalter fungieren, und wir möchten diesen Platzhaltereintrag mehrmals hinzufügen. Dazu verwenden wir den += Operator mit einer Schleife.

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

['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)

['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.

Ein Element aus einer Liste entfernen

Elemente können von Listen entfernt werden, indem die del Anweisung verwendet wird. Dies löscht den Wert an der Indexnummer, die Sie innerhalb einer Liste angeben.

Vom sea_creatures List, lassen Sie uns das Element 'octopus' entfernen. Dieses Element befindet sich an der Indexposition 1. Um das Element zu entfernen, verwenden wir die del Anweisung 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)

['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.

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

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

del sea_creatures[1:4]
print(sea_creatures)

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

Durch die Verwendung eines Bereichs mit der del-Anweisung konnten wir die Elemente zwischen der Indexnummer 1 (einschließlich) und der Indexnummer 4 (ausschließlich) entfernen, wodurch wir eine Liste mit 3 Elementen nach der Entfernung von 3 Elementen hatten.

Die del Anweisung ermöglicht es uns, bestimmte Elemente vom Listendatentyp zu entfernen.

Eine Liste mit Listenelementen erstellen

Listen können definiert werden mit Elementen, die aus Listen bestehen, wobei jede in Klammern gesetzte Liste innerhalb der größeren 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 in dieser Liste zuzugreifen, müssen wir mehrere Indizes verwenden:

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

Sammy
shark

Die erste Liste, da sie gleich einem Element ist, wird die Indexnummer 0 haben, was die erste Zahl in der Konstruktion sein wird, und die zweite Liste wird die Indexnummer 1 haben. Innerhalb jeder inneren geschachtelten Liste wird es separate Indexnummern geben, die wir im zweiten Indexnummern nennen 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'

Beim Arbeiten mit Listen von Listen ist es wichtig, sich daran zu erinnern, dass Sie auf mehr als eine Indexnummer verweisen müssen, um spezifische Elemente innerhalb der relevanten geschachtelten Liste zuzugreifen.

Schlussfolgerung

Der Listendatentyp ist ein flexibler Datentyp, der während des gesamten Laufs Ihres Programms angepasst werden kann. Dieses Tutorial behandelte die grundlegenden Funktionen von Listen, einschließlich Indizierung, Slicing, Modifizieren und Konkatenieren von Listen.

Von hier aus können Sie mehr darüber erfahren, wie man mit Listen in Python arbeitet, indem Sie "Wie man List-Methoden verwendet" lesen, und über List Comprehensions, um Listen basierend auf bestehenden Listen zu erstellen. Um mehr über Datentypen im Allgemeinen zu erfahren, können Sie unser Tutorial "Verstehen von Datentypen" lesen.