Listen und Tupel in Python

Listen und Tupel in Python

Lists undtuples sind wohl die vielseitigsten und nützlichstendata types von Python. Sie finden sie in praktisch jedem nicht trivialen Python-Programm.

Here’s what you’ll learn in this tutorial: Sie werden die wichtigen Merkmale von Listen und Tupeln behandeln. Sie lernen, wie Sie sie definieren und manipulieren. Wenn Sie fertig sind, sollten Sie ein gutes Gefühl dafür haben, wann und wie diese Objekttypen in einem Python-Programm verwendet werden.

__ Take the Quiz: Testen Sie Ihr Wissen mit unserem interaktiven Quiz „Python-Listen und Tupel“. Nach Abschluss erhalten Sie eine Punktzahl, mit der Sie Ihren Lernfortschritt im Laufe der Zeit verfolgen können:

Python-Listen

Kurz gesagt, eine Liste ist eine Sammlung beliebiger Objekte, die einem Array in vielen anderen Programmiersprachen ähnelt, jedoch flexibler ist. Listen werden in Python definiert, indem eine durch Kommas getrennte Folge von Objekten in eckige Klammern ([]) eingeschlossen wird, wie unten gezeigt:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']

>>> print(a)
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']

Die wichtigen Merkmale von Python-Listen sind folgende:

  • Listen werden bestellt.

  • Listen können beliebige Objekte enthalten.

  • Auf Listenelemente kann über den Index zugegriffen werden.

  • Listen können bis zu einer beliebigen Tiefe verschachtelt werden.

  • Listen sind veränderlich.

  • Listen sind dynamisch.

Jedes dieser Merkmale wird nachstehend ausführlicher untersucht.

Listen werden bestellt

Eine Liste ist nicht nur eine Sammlung von Objekten. Es ist eine geordnete Sammlung von Objekten. Die Reihenfolge, in der Sie die Elemente angeben, wenn Sie eine Liste definieren, ist ein angeborenes Merkmal dieser Liste und wird für die Lebensdauer dieser Liste beibehalten. (Sie sehen einen Python-Datentyp, der im nächsten Tutorial zu Wörterbüchern nicht geordnet ist.)

Listen mit denselben Elementen in einer anderen Reihenfolge sind nicht identisch:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False

>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False

Listen können beliebige Objekte enthalten

Eine Liste kann eine beliebige Auswahl von Objekten enthalten. Die Elemente einer Liste können alle vom gleichen Typ sein:

>>>

>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]

Oder die Elemente können unterschiedlicher Art sein:

>>>

>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]

Listen können sogar komplexe Objekte wie Funktionen, Klassen und Module enthalten, die Sie in den kommenden Tutorials kennenlernen werden:

>>>

>>> int

>>> len

>>> def foo():
...     pass
...
>>> foo

>>> import math
>>> math


>>> a = [int, len, foo, math]
>>> a
[, , ,
]

Eine Liste kann eine beliebige Anzahl von Objekten enthalten, von null bis zu so vielen, wie der Arbeitsspeicher Ihres Computers zulässt:

>>>

>>> a = []
>>> a
[]

>>> a = [ 'foo' ]
>>> a
['foo']

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
... 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
... 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
... 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
... 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]

(Eine Liste mit einem einzelnen Objekt wird manchmal als Singleton-Liste bezeichnet.)

Listenobjekte müssen nicht eindeutig sein. Ein bestimmtes Objekt kann mehrmals in einer Liste angezeigt werden:

>>>

>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']

Auf Listenelemente kann über den Index zugegriffen werden

Auf einzelne Elemente in einer Liste kann über einen Index in eckigen Klammern zugegriffen werden. Dies ist genau analog zum Zugriff auf einzelne Zeichen in einer Zeichenfolge. Die Listenindizierung basiert wie bei Zeichenfolgen auf Null.

Betrachten Sie die folgende Liste:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

Die Indizes für die Elemente ina sind nachstehend aufgeführt:

Hier ist Python-Code für den Zugriff auf einige Elemente vona:

>>>

>>> a[0]
'foo'
>>> a[2]
'baz'
>>> a[5]
'corge'

Praktisch alles an der Zeichenfolgenindizierung funktioniert für Listen ähnlich. Zum Beispiel zählt ein negativer Listenindex ab dem Ende der Liste:

>>>

>>> a[-1]
'corge'
>>> a[-2]
'quux'
>>> a[-5]
'bar'

Das Schneiden funktioniert auch. Wenna eine Liste ist, gibt der Ausdrucka[m:n] den Teil vona vom Indexm zum Indexn zurück, schließt diesen jedoch nicht ein:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a[2:5]
['baz', 'qux', 'quux']

Andere Funktionen des String-Slicing funktionieren analog auch für das List-Slicing:

  • Es können sowohl positive als auch negative Indizes angegeben werden:

    >>>

>>> a[-5:-2]
['bar', 'baz', 'qux']
>>> a[1:4]
['bar', 'baz', 'qux']
>>> a[-5:-2] == a[1:4]
True
  • Durch Weglassen des ersten Index wird das Slice am Anfang der Liste gestartet, und durch Weglassen des zweiten Index wird das Slice bis zum Ende der Liste verlängert:

    >>>

>>> print(a[:4], a[0:4])
['foo', 'bar', 'baz', 'qux'] ['foo', 'bar', 'baz', 'qux']
>>> print(a[2:], a[2:len(a)])
['baz', 'qux', 'quux', 'corge'] ['baz', 'qux', 'quux', 'corge']

>>> a[:4] + a[4:]
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[:4] + a[4:] == a
True
  • Sie können einen Schritt angeben - entweder positiv oder negativ:

    >>>

>>> a[0:6:2]
['foo', 'baz', 'quux']
>>> a[1:6:2]
['bar', 'qux', 'corge']
>>> a[6:0:-2]
['corge', 'qux', 'bar']
  • Die Syntax zum Umkehren einer Liste funktioniert genauso wie für Zeichenfolgen:

    >>>

>>> a[::-1]
['corge', 'quux', 'qux', 'baz', 'bar', 'foo']
  • Die Syntax von[:]funktioniert für Listen. Es gibt jedoch einen wichtigen Unterschied zwischen der Funktionsweise dieser Operation mit einer Liste und der Funktionsweise mit einer Zeichenfolge.

    Wenns eine Zeichenfolge ist, gibts[:] einen Verweis auf dasselbe Objekt zurück:

    >>>

>>> s = 'foobar'
>>> s[:]
'foobar'
>>> s[:] is s
True

+ Wenna eine Liste ist, gibta[:] ein neues Objekt zurück, das eine Kopie vona ist:

+>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[:]
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[:] is a
False

Mehrere Python-Operatoren und integrierte Funktionen können auch mit Listen analog zu Zeichenfolgen verwendet werden:

  • Die Operatorenin undnot in:

    >>>

>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> 'qux' in a
True
>>> 'thud' not in a
True
  • Die Operatoren Verkettung (+) und Replikation (*):

    >>>

>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a + ['grault', 'garply']
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'grault', 'garply']
>>> a * 2
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'foo', 'bar', 'baz',
'qux', 'quux', 'corge']
  • Die Funktionenlen(),min() undmax():

    >>>

>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> len(a)
6
>>> min(a)
'bar'
>>> max(a)
'qux'

Es ist kein Zufall, dass sich Zeichenfolgen und Listen so ähnlich verhalten. Dies sind beide Sonderfälle eines allgemeineren Objekttyps, der als iterable bezeichnet wird und auf den Sie im kommenden Tutorial zur bestimmten Iteration näher eingehen werden.

Übrigens wird in jedem obigen Beispiel die Liste immer einer Variablen zugewiesen, bevor eine Operation daran ausgeführt wird. Sie können aber auch ein Listenliteral bearbeiten:

>>>

>>> ['foo', 'bar', 'baz', 'qux', 'quux', 'corge'][2]
'baz'

>>> ['foo', 'bar', 'baz', 'qux', 'quux', 'corge'][::-1]
['corge', 'quux', 'qux', 'baz', 'bar', 'foo']

>>> 'quux' in ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
True

>>> ['foo', 'bar', 'baz'] + ['qux', 'quux', 'corge']
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> len(['foo', 'bar', 'baz', 'qux', 'quux', 'corge'][::-1])
6

Im Übrigen können Sie dies auch mit einem String-Literal tun:

>>>

>>> 'If Comrade Napoleon says it, it must be right.'[::-1]
'.thgir eb tsum ti ,ti syas noelopaN edarmoC fI'

Listen können verschachtelt werden

Sie haben gesehen, dass ein Element in einer Liste eine beliebige Art von Objekt sein kann. Das schließt eine andere Liste ein. Eine Liste kann Unterlisten enthalten, die wiederum selbst Unterlisten enthalten können, und so weiter bis zu einer beliebigen Tiefe.

Betrachten Sie dieses (zugegebenermaßen erfundene) Beispiel:

>>>

>>> x = ['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']
>>> x
['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']

Die Objektstruktur, auf diexverweist, ist unten dargestellt:

x[0],x[2] undx[4] sind Zeichenfolgen mit jeweils einem Zeichen Länge:

>>>

>>> print(x[0], x[2], x[4])
a g j

Aberx[1] undx[3] sind Unterlisten:

>>>

>>> x[1]
['bb', ['ccc', 'ddd'], 'ee', 'ff']

>>> x[3]
['hh', 'ii']

Um auf die Elemente in einer Unterliste zuzugreifen, fügen Sie einfach einen zusätzlichen Index hinzu:

>>>

>>> x[1]
['bb', ['ccc', 'ddd'], 'ee', 'ff']

>>> x[1][0]
'bb'
>>> x[1][1]
['ccc', 'ddd']
>>> x[1][2]
'ee'
>>> x[1][3]
'ff'

>>> x[3]
['hh', 'ii']
>>> print(x[3][0], x[3][1])
hh ii

x[1][1] ist eine weitere Unterliste, sodass das Hinzufügen eines weiteren Index auf seine Elemente zugreift:

>>>

>>> x[1][1]
['ccc', 'ddd']
>>> print(x[1][1][0], x[1][1][1])
ccc ddd

Abgesehen von der Größe des Arbeitsspeichers Ihres Computers gibt es keine Begrenzung für die Tiefe oder Komplexität, mit der Listen auf diese Weise verschachtelt werden können.

Die übliche Syntax für Indizes und Slicing gilt auch für Unterlisten:

>>>

>>> x[1][1][-1]
'ddd'
>>> x[1][1:3]
[[ccc', 'ddd'], 'ee']
>>> x[3][::-1]
['ii', 'hh']

Beachten Sie jedoch, dass Operatoren und Funktionen nur für die Liste auf der von Ihnen angegebenen Ebene gelten und nicht rekursiv sind. Überlegen Sie, was passiert, wenn Sie die Länge vonx mitlen() abfragen:

>>>

>>> x
['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']
>>> len(x)
5

>>> x[0]
'a'
>>> x[1]
['bb', ['ccc', 'ddd'], 'ee', 'ff']
>>> x[2]
'g'
>>> x[3]
['hh', 'ii']
>>> x[4]
'j'

x hat nur fünf Elemente - drei Zeichenfolgen und zwei Unterlisten. Die einzelnen Elemente in den Unterlisten werden nicht auf die Länge vonxangerechnet.

Bei Verwendung des Operatorsintritt eine ähnliche Situation auf:

>>>

>>> 'ddd' in x
False
>>> 'ddd' in x[1]
False
>>> 'ddd' in x[1][1]
True

'ddd' ist nicht eines der Elemente inx oderx[1]. Es ist nur direkt ein Element in der Unterlistex[1][1]. Ein einzelnes Element in einer Unterliste zählt nicht als Element der übergeordneten Liste (n).

Listen sind veränderlich

Die meisten Datentypen, auf die Sie bisher gestoßen sind, waren Atomtypen. Integer- oder Float-Objekte sind beispielsweise primitive Einheiten, die nicht weiter zerlegt werden können. Diese Typen sind unveränderlich, dh sie können nach ihrer Zuweisung nicht mehr geändert werden. Es macht wenig Sinn, daran zu denken, den Wert einer Ganzzahl zu ändern. Wenn Sie eine andere Ganzzahl möchten, weisen Sie einfach eine andere zu.

Im Gegensatz dazu ist der Zeichenfolgentyp ein zusammengesetzter Typ. Zeichenfolgen können auf kleinere Teile reduziert werden - die Komponentenzeichen. Es kann sinnvoll sein, die Zeichen in einer Zeichenfolge zu ändern. Aber das kannst du nicht. In Python sind Zeichenfolgen ebenfalls unveränderlich.

Die Liste ist der erste veränderbare Datentyp, auf den Sie gestoßen sind. Sobald eine Liste erstellt wurde, können Elemente nach Belieben hinzugefügt, gelöscht, verschoben und verschoben werden. Python bietet eine Vielzahl von Möglichkeiten zum Ändern von Listen.

Ändern eines einzelnen Listenwerts

Ein einzelner Wert in einer Liste kann durch Indizierung und einfache Zuweisung ersetzt werden:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a[2] = 10
>>> a[-1] = 20
>>> a
['foo', 'bar', 10, 'qux', 'quux', 20]

Sie können sich aus dem TutorialStrings and Character Data in Python daran erinnern, dass Sie dies nicht mit einer Zeichenfolge tun können:

>>>

>>> s = 'foobarbaz'
>>> s[2] = 'x'
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

Ein Listenelement kann mit dem Befehldel gelöscht werden:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> del a[3]
>>> a
['foo', 'bar', 'baz', 'quux', 'corge']
Mehrere Listenwerte ändern

Was ist, wenn Sie mehrere zusammenhängende Elemente in einer Liste gleichzeitig ändern möchten? Python erlaubt dies mit Slice-Zuweisung, die die folgende Syntax hat:

a[m:n] = 

Stellen Sie sich für den Moment wieder eine iterierbare Liste vor. Diese Zuweisung ersetzt das angegebene Slice vona durch<iterable>:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a[1:4]
['bar', 'baz', 'qux']
>>> a[1:4] = [1.1, 2.2, 3.3, 4.4, 5.5]
>>> a
['foo', 1.1, 2.2, 3.3, 4.4, 5.5, 'quux', 'corge']
>>> a[1:6]
[1.1, 2.2, 3.3, 4.4, 5.5]
>>> a[1:6] = ['Bark!']
>>> a
['foo', 'Bark!', 'quux', 'corge']

Die Anzahl der eingefügten Elemente muss nicht der Anzahl der ersetzten Elemente entsprechen. Python vergrößert oder verkleinert die Liste nur nach Bedarf.

Sie können mehrere Elemente anstelle eines einzelnen Elements einfügen. Verwenden Sie einfach ein Slice, das nur ein Element kennzeichnet:

>>>

>>> a = [1, 2, 3]
>>> a[1:2] = [2.1, 2.2, 2.3]
>>> a
[1, 2.1, 2.2, 2.3, 3]

Beachten Sie, dass dies nicht mit dem Ersetzen des einzelnen Elements durch eine Liste identisch ist:

>>>

>>> a = [1, 2, 3]
>>> a[1] = [2.1, 2.2, 2.3]
>>> a
[1, [2.1, 2.2, 2.3], 3]

Sie können auch Elemente in eine Liste einfügen, ohne etwas zu entfernen. Geben Sie einfach ein Slice der Form[n:n] (ein Slice mit der Länge Null) am gewünschten Index an:

>>>

>>> a = [1, 2, 7, 8]
>>> a[2:2] = [3, 4, 5, 6]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]

Sie können mehrere Elemente aus der Mitte einer Liste löschen, indem Sie einer leeren Liste das entsprechende Slice zuweisen. Sie können auch die Anweisungdel mit demselben Slice verwenden:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[1:5] = []
>>> a
['foo', 'corge']

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> del a[1:5]
>>> a
['foo', 'corge']
Voranstellen oder Anhängen von Elementen an eine Liste

Mit dem erweiterten Zuweisungsoperator+` concatenation operator or the `=+können zusätzliche Elemente am Anfang oder Ende einer Liste hinzugefügt werden:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a += ['grault', 'garply']
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'grault', 'garply']

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a = [10, 20] + a
>>> a
[10, 20, 'foo', 'bar', 'baz', 'qux', 'quux', 'corge']

Beachten Sie, dass eine Liste mit einer anderen Liste verkettet werden muss. Wenn Sie also nur ein Element hinzufügen möchten, müssen Sie es als Singleton-Liste angeben:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a += 20
Traceback (most recent call last):
  File "", line 1, in 
    a += 20
TypeError: 'int' object is not iterable

>>> a += [20]
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 20]

Note: Technisch gesehen ist es nicht ganz richtig zu sagen, dass eine Liste mit einer anderen Liste verknüpft werden muss. Genauer gesagt muss eine Liste mit einem iterierbaren Objekt verknüpft werden. Natürlich sind Listen iterierbar, daher funktioniert es, eine Liste mit einer anderen Liste zu verketten.

Strings sind auch iterierbar. Beachten Sie jedoch, was passiert, wenn Sie eine Zeichenfolge mit einer Liste verknüpfen:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux']
>>> a += 'corge'
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'c', 'o', 'r', 'g', 'e']

Dieses Ergebnis entspricht möglicherweise nicht ganz Ihren Erwartungen. Wenn eine Zeichenfolge durchlaufen wird, ist das Ergebnis eine Liste ihrer Komponentenzeichen. Im obigen Beispiel wird auf Listea eine Liste der Zeichen in der Zeichenfolge'corge' verkettet.

Wenn Sie wirklich nur die einzelne Zeichenfolge'corge' am Ende der Liste hinzufügen möchten, müssen Sie sie als Singleton-Liste angeben:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux']
>>> a += ['corge']
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

Wenn dies mysteriös erscheint, ärgern Sie sich nicht zu sehr. Im Tutorial zur bestimmten Iteration erfahren Sie mehr über die Vor- und Nachteile von Iterables.

Methoden, die eine Liste ändern

Schließlich bietet Python mehrere integrierte Methoden, mit denen Listen geändert werden können. Informationen zu diesen Methoden finden Sie weiter unten.

Note: Die Zeichenfolgenmethoden, die Sie im vorherigen Lernprogramm gesehen haben, haben die Zielzeichenfolge nicht direkt geändert. Das liegt daran, dass Zeichenfolgen unveränderlich sind. Stattdessen geben Zeichenfolgenmethoden ein neues Zeichenfolgenobjekt zurück, das gemäß den Anweisungen der Methode geändert wird. Sie lassen die ursprüngliche Zielzeichenfolge unverändert:

>>>

>>> s = 'foobar'
>>> t = s.upper()
>>> print(s, t)
foobar FOOBAR

Listenmethoden sind unterschiedlich. Da Listen veränderbar sind, ändern die hier gezeigten Listenmethoden die vorhandene Zielliste.

a.append()

Hängt ein Objekt an eine Liste an.

a.append(<obj>) hängt das Objekt<obj> an das Ende der Listea an:

>>>

>>> a = ['a', 'b']
>>> a.append(123)
>>> a
['a', 'b', 123]

Denken Sie daran, dass Listenmethoden die vorhandene Zielliste ändern. Sie geben keine neue Liste zurück:

>>>

>>> a = ['a', 'b']
>>> x = a.append(123)
>>> print(x)
None
>>> a
['a', 'b', 123]

Denken Sie daran, dass, wenn der Operator+zum Verketten mit einer Liste verwendet wird und der Zieloperand iterierbar ist, seine Elemente aufgeteilt und einzeln an die Liste angehängt werden:

>>>

>>> a = ['a', 'b']
>>> a + [1, 2, 3]
['a', 'b', 1, 2, 3]

Die Methode.append()funktioniert nicht so! Wenn eine Iterable an eine Liste mit.append() angehängt wird, wird sie als einzelnes Objekt hinzugefügt:

>>>

>>> a = ['a', 'b']
>>> a.append([1, 2, 3])
>>> a
['a', 'b', [1, 2, 3]]

Mit.append() können Sie also eine Zeichenfolge als einzelne Entität anhängen:

>>>

>>> a = ['a', 'b']
>>> a.append('foo')
>>> a
['a', 'b', 'foo']

a.extend()

Erweitert eine Liste mit den Objekten aus einer iterierbaren.

Ja, das ist wahrscheinlich das, was du denkst. .extend() wird ebenfalls am Ende einer Liste hinzugefügt, es wird jedoch erwartet, dass das Argument iterierbar ist. Die Elemente in<iterable> werden einzeln hinzugefügt:

>>>

>>> a = ['a', 'b']
>>> a.extend([1, 2, 3])
>>> a
['a', 'b', 1, 2, 3]

Mit anderen Worten,.extend() verhält sich wie der Operator+` operator. More precisely, since it modifies the list in place, it behaves like the `=+:

>>>

>>> a = ['a', 'b']
>>> a += [1, 2, 3]
>>> a
['a', 'b', 1, 2, 3]

a.insert(, )

Fügt ein Objekt in eine Liste ein.

a.insert(<index>, <obj>) fügt das Objekt<obj> mit den angegebenen<index> in die Listea ein. Nach dem Methodenaufruf ista[<index>]<obj>, und die verbleibenden Listenelemente werden nach rechts verschoben:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.insert(3, 3.14159)
>>> a[3]
3.14159
>>> a
['foo', 'bar', 'baz', 3.14159, 'qux', 'quux', 'corge']

a.remove()

Entfernt ein Objekt aus einer Liste.

a.remove(<obj>) entfernt das Objekt<obj> aus der Listea. Wenn<obj> nicht ina enthalten ist, wird eine Ausnahme ausgelöst:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.remove('baz')
>>> a
['foo', 'bar', 'qux', 'quux', 'corge']

>>> a.remove('Bark!')
Traceback (most recent call last):
  File "", line 1, in 
    a.remove('Bark!')
ValueError: list.remove(x): x not in list

a.pop(index=-1)

Entfernt ein Element aus einer Liste.

Diese Methode unterscheidet sich in zwei Punkten von.remove():

  1. Sie geben den Index des zu entfernenden Elements und nicht das Objekt selbst an.

  2. Die Methode gibt einen Wert zurück: das Element, das entfernt wurde.

a.pop() entfernt einfach das letzte Element in der Liste:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a.pop()
'corge'
>>> a
['foo', 'bar', 'baz', 'qux', 'quux']

>>> a.pop()
'quux'
>>> a
['foo', 'bar', 'baz', 'qux']

Wenn der optionale Parameter<index> angegeben ist, wird das Element an diesem Index entfernt und zurückgegeben. <index> kann negativ sein, wie bei der Indizierung von Zeichenfolgen und Listen:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a.pop(1)
'bar'
>>> a
['foo', 'baz', 'qux', 'quux', 'corge']

>>> a.pop(-3)
'qux'
>>> a
['foo', 'baz', 'quux', 'corge']

<index> ist standardmäßig-1, daher entsprichta.pop(-1)a.pop().

Listen sind dynamisch

Dieses Tutorial begann mit einer Liste von sechs definierenden Merkmalen von Python-Listen. Die letzte ist, dass Listen dynamisch sind. Sie haben in den obigen Abschnitten viele Beispiele dafür gesehen. Wenn Elemente zu einer Liste hinzugefügt werden, wächst sie nach Bedarf:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a[2:2] = [1, 2, 3]
>>> a += [3.14159]
>>> a
['foo', 'bar', 1, 2, 3, 'baz', 'qux', 'quux', 'corge', 3.14159]

In ähnlicher Weise wird eine Liste verkleinert, um das Entfernen von Elementen zu ermöglichen:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[2:3] = []
>>> del a[0]
>>> a
['bar', 'qux', 'quux', 'corge']

Python-Tupel

Python bietet einen anderen Typ, bei dem es sich um eine geordnete Sammlung von Objekten handelt, die als Tupel bezeichnet wird.

Die Aussprache variiert je nachdem, wen Sie fragen. Einige sprechen es aus, als wäre es "zu ple" (Reim mit "Mott the Hoople"), andere als ob es "tup-ple" (Reim mit "geschmeidig") geschrieben wäre. Meine Neigung ist die letztere, da sie vermutlich vom selben Ursprung stammt wie "Fünffach", "Sextupel", "Oktupel" usw., und jeder, den ich kenne, spricht diese letzteren aus, als ob sie sich mit "geschmeidig" reimen würden.

Tupel definieren und verwenden

Tupel sind in jeder Hinsicht mit Listen identisch, mit Ausnahme der folgenden Eigenschaften:

  • Tupel werden definiert, indem die Elemente in Klammern (()) anstelle von eckigen Klammern ([]) eingeschlossen werden.

  • Tupel sind unveränderlich.

Hier ist ein kurzes Beispiel, das eine Tupeldefinition, Indizierung und Aufteilung zeigt:

>>>

>>> t = ('foo', 'bar', 'baz', 'qux', 'quux', 'corge')
>>> t
('foo', 'bar', 'baz', 'qux', 'quux', 'corge')

>>> t[0]
'foo'
>>> t[-1]
'corge'
>>> t[1::2]
('bar', 'qux', 'corge')

Hab niemals Angst! Unser bevorzugter Umkehrmechanismus für Zeichenfolgen und Listen funktioniert auch für Tupel:

>>>

>>> t[::-1]
('corge', 'quux', 'qux', 'baz', 'bar', 'foo')

Note: Obwohl Tupel in Klammern definiert sind, indizieren und schneiden Sie Tupel in eckigen Klammern, genau wie bei Zeichenfolgen und Listen.

Alles, was Sie über Listen gelernt haben - sie sind geordnet, sie können beliebige Objekte enthalten, sie können indiziert und in Scheiben geschnitten werden, sie können verschachtelt sein - gilt auch für Tupel. Sie können jedoch nicht geändert werden:

>>>

>>> t = ('foo', 'bar', 'baz', 'qux', 'quux', 'corge')
>>> t[2] = 'Bark!'
Traceback (most recent call last):
  File "", line 1, in 
    t[2] = 'Bark!'
TypeError: 'tuple' object does not support item assignment

Warum ein Tupel anstelle einer Liste verwenden?

  • Die Programmausführung ist beim Bearbeiten eines Tupels schneller als bei der entsprechenden Liste. (Dies wird wahrscheinlich nicht auffallen, wenn die Liste oder das Tupel klein ist.)

  • Manchmal möchten Sie nicht, dass Daten geändert werden. Wenn die Werte in der Sammlung während der gesamten Laufzeit des Programms konstant bleiben sollen, schützt die Verwendung eines Tupels anstelle einer Liste vor versehentlicher Änderung.

  • Es gibt einen anderen Python-Datentyp, auf den Sie in Kürze stoßen werden, der als Wörterbuch bezeichnet wird und der als eine seiner Komponenten einen Wert benötigt, der unveränderlich ist. Zu diesem Zweck kann ein Tupel verwendet werden, eine Liste jedoch nicht.

In einer Python-REPL-Sitzung können Sie die Werte mehrerer Objekte gleichzeitig anzeigen, indem Sie sie direkt an der Eingabeaufforderung>>>eingeben, getrennt durch Kommas:

>>>

>>> a = 'foo'
>>> b = 42
>>> a, 3.14159, b
('foo', 3.14159, 42)

Python zeigt die Antwort in Klammern an, da die Eingabe implizit als Tupel interpretiert wird.

Es gibt eine Besonderheit in Bezug auf die Tupeldefinition, die Sie beachten sollten. Es gibt keine Mehrdeutigkeit beim Definieren eines leeren Tupels oder eines mit zwei oder mehr Elementen. Python weiß, dass Sie ein Tupel definieren:

>>>

>>> t = ()
>>> type(t)

>>>

>>> t = (1, 2)
>>> type(t)

>>> t = (1, 2, 3, 4, 5)
>>> type(t)

Aber was passiert, wenn Sie versuchen, ein Tupel mit einem Element zu definieren:

>>>

>>> t = (2)
>>> type(t)

Doh! Da Klammern auch zum Definieren der Operatorpriorität in Ausdrücken verwendet werden, wertet Python den Ausdruck(2) einfach als Ganzzahl2 aus und erstellt einint-Objekt. Um Python mitzuteilen, dass Sie wirklich ein Singleton-Tupel definieren möchten, fügen Sie kurz vor der schließenden Klammer ein nachfolgendes Komma (,) ein:

>>>

>>> t = (2,)
>>> type(t)

>>> t[0]
2
>>> t[-1]
2

Sie müssen wahrscheinlich nicht oft ein Singleton-Tupel definieren, aber es muss einen Weg geben.

Wenn Sie ein Singleton-Tupel anzeigen, enthält Python das Komma, um Sie daran zu erinnern, dass es sich um ein Tupel handelt:

>>>

>>> print(t)
(2,)

Tupelzuweisung, Packen und Auspacken

Wie Sie oben bereits gesehen haben, kann einem einzelnen Objekt ein Literal-Tupel mit mehreren Elementen zugewiesen werden:

>>>

>>> t = ('foo', 'bar', 'baz', 'qux')

In diesem Fall ist es so, als wären die Elemente im Tupel in das Objekt „gepackt“ worden:

>>>

>>> t
('foo', 'bar', 'baz', 'qux')
>>> t[0]
'foo'
>>> t[-1]
'qux'

Wenn dieses "gepackte" Objekt anschließend einem neuen Tupel zugewiesen wird, werden die einzelnen Elemente in die Objekte im Tupel "entpackt":

>>>

>>> (s1, s2, s3, s4) = t
>>> s1
'foo'
>>> s2
'bar'
>>> s3
'baz'
>>> s4
'qux'

Beim Auspacken muss die Anzahl der Variablen links mit der Anzahl der Werte im Tupel übereinstimmen:

>>>

>>> (s1, s2, s3) = t
Traceback (most recent call last):
  File "", line 1, in 
    (s1, s2, s3) = t
ValueError: too many values to unpack (expected 3)

>>> (s1, s2, s3, s4, s5) = t
Traceback (most recent call last):
  File "", line 1, in 
    (s1, s2, s3, s4, s5) = t
ValueError: not enough values to unpack (expected 5, got 4)

Das Ein- und Auspacken kann zu einer Anweisung zusammengefasst werden, um eine zusammengesetzte Zuordnung vorzunehmen:

>>>

>>> (s1, s2, s3, s4) = ('foo', 'bar', 'baz', 'qux')
>>> s1
'foo'
>>> s2
'bar'
>>> s3
'baz'
>>> s4
'qux'

Auch hier muss die Anzahl der Elemente im Tupel links von der Zuweisung der Anzahl rechts entsprechen:

>>>

>>> (s1, s2, s3, s4, s5) = ('foo', 'bar', 'baz', 'qux')
Traceback (most recent call last):
  File "", line 1, in 
    (s1, s2, s3, s4, s5) = ('foo', 'bar', 'baz', 'qux')
ValueError: not enough values to unpack (expected 5, got 4)

In Aufgaben wie dieser und einer kleinen Handvoll anderer Situationen lässt Python zu, dass die Klammern, die normalerweise zur Bezeichnung eines Tupels verwendet werden, weggelassen werden:

>>>

>>> t = 1, 2, 3
>>> t
(1, 2, 3)

>>> x1, x2, x3 = t
>>> x1, x2, x3
(1, 2, 3)

>>> x1, x2, x3 = 4, 5, 6
>>> x1, x2, x3
(4, 5, 6)

>>> t = 2,
>>> t
(2,)

Es funktioniert genauso, ob die Klammern enthalten sind oder nicht. Wenn Sie also Zweifel haben, ob sie benötigt werden, fügen Sie sie hinzu.

Die Tupelzuweisung ermöglicht ein merkwürdiges Stück idiomatischen Python. Beim Programmieren haben Sie häufig zwei Variablen, deren Werte Sie austauschen müssen. In den meisten Programmiersprachen muss einer der Werte in einer temporären Variablen gespeichert werden, während der Austausch wie folgt erfolgt:

>>>

>>> a = 'foo'
>>> b = 'bar'
>>> a, b
('foo', 'bar')

>>># We need to define a temp variable to accomplish the swap.
>>> temp = a
>>> a = b
>>> b = temp

>>> a, b
('bar', 'foo')

In Python kann der Austausch mit einer einzigen Tupelzuweisung erfolgen:

>>>

>>> a = 'foo'
>>> b = 'bar'
>>> a, b
('foo', 'bar')

>>># Magic time!
>>> a, b = b, a

>>> a, b
('bar', 'foo')

Wie jeder weiß, der jemals Werte mithilfe einer temporären Variablen austauschen musste, ist die Möglichkeit, dies in Python auf diese Weise zu tun, der Höhepunkt moderner technologischer Errungenschaften. Besser wird es nie.

Fazit

In diesem Tutorial wurden die grundlegenden Eigenschaften von Pythonlists undtuples sowie deren Manipulation behandelt. Sie werden diese in Ihrer Python-Programmierung ausgiebig verwenden.

Eines der Hauptmerkmale einer Liste ist, dass sie geordnet ist. Die Reihenfolge der Elemente in einer Liste ist eine intrinsische Eigenschaft dieser Liste und ändert sich nicht, es sei denn, die Liste selbst wird geändert. (Gleiches gilt für Tupel, außer dass sie natürlich nicht geändert werden können.)

Das nächste Tutorial führt Sie in Pythondictionary:ein, einen zusammengesetzten Datentyp, der ungeordnet ist. Weiter lesen!

__ Take the Quiz: Testen Sie Ihr Wissen mit unserem interaktiven Quiz „Python-Listen und Tupel“. Nach Abschluss erhalten Sie eine Punktzahl, mit der Sie Ihren Lernfortschritt im Laufe der Zeit verfolgen können: