Zugriff per Index
>>> L = [0, 1, 2, 3, 4, 5]
>>> L[2]
2
#Wenn Sie einen negativen Wert als Index angeben, wird ab Ende auf ihn verwiesen.
>>> L[-1] #Der Index des letzten Elements ist-1
5
>>> L[-2]
4
#Ausnahme, wenn Sie einen Index außerhalb des Bereichs angeben
>>> L[6]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
Scheibe
#Holen Sie sich alles auf einmal, indem Sie einen Bereich von Indexwerten angeben
>>> L = [0, 1, 2, 3, 4]
>>> L[1:4]
[1, 2, 3] #Erstellen Sie ein neues Sequenzobjekt mit den Elementen bis zu dem vor dem an der Endposition angegebenen Element
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[-5:-1] #Wenn die Startposition und die Endposition negative Werte sind, wird die Position ab dem Ende angegeben.
[5, 6, 7, 8]
>>> L[-5:0] #Wenn Sie es bis zum Ende nehmen wollen, nicht so
[]
>>> L[-5:] #so was
[5, 6, 7, 8, 9]
>>> L = [1, 2, 3]
>>> L[10:20] #Gibt eine leere Sequenz zurück, wenn Sie einen Index angeben, der nicht vorhanden ist
[]
>>> L[1:1] #Slices mit der Länge Null geben auch eine leere Sequenz zurück
[]
>>> L[3:1] #Slices mit einer negativen Länge geben auch eine leere Zeichenfolge zurück (es heißt leere Zeichenfolge, aber es ist das gleiche wie oben....？）
[]
>>> L[0:10] #Wenn über das Ende des Elements hinaus angegeben, wird bis zum letzten Element zurückgegeben
[1, 2, 3]
>>> L[-10:10] #Wenn über den Anfang des Elements hinaus angegeben, kehren Sie vom ersten Element zurück
[1, 2, 3]
Holen Sie sich das Element, indem Sie den Inkrementwert angeben
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[1:10:3] #Erhalten durch Überspringen des Index 3 zwischen der Startposition und der Endposition
[1, 4, 7]
#Wenn Sie als Inkrementwert einen negativen Wert angeben, werden die Elemente in umgekehrter Reihenfolge von hinten abgerufen.
>>> L[8:2:-1]
[8, 7, 6, 5, 4, 3]
>>> L[10:1:-3]
[9, 6, 3]
Weglassen der Slice-Spezifikation
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[:5] #Startposition weglassen (Startposition ist 0)
[0, 1, 2, 3, 4]
>>> L[0::2] #Lassen Sie die Endposition weg (die Endposition ist 10)
[0, 2, 4, 6, 8]
#Wenn der Inkrementwert negativ ist
>>> L[:5:-1] #Startposition weglassen (Startposition ist 10)
[9, 8, 7, 6]
>>> L[10::-2] #Lassen Sie die Endposition weg (die Endposition ist 0)
[9, 7, 5, 3, 1]
#Wenn der Inkrementwert weggelassen wird, ist der Inkrementwert 1.
>>> L[2:5:]
[2, 3, 4]
>>> L[2:5] #Letzte:Interpretation als eine Form, die weglässt. Das war's.
[2, 3, 4]
#Auslassungstricks
>>> L[::2]
[0, 2, 4, 6, 8]
>>> L[::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
Objekt in Scheiben schneiden
#Schnittbetrieb[]Der Inhalt kann als Slice-Objekt erstellt werden (nützlich, wenn häufig auf einen bestimmten Bereich verwiesen wird).
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[slice(1, 10, 3)] # L[1:10:3]Gleich wie
[1, 4, 7]
>>> L[slice(10)] # L[:10]Gleich wie
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Substitution mit Scheibe
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[1:9] = ['spam', 'ham'] #Ersetzt Elemente im Slice-Bereich, Längen müssen nicht übereinstimmen
>>> L
[0, 'spam', 'ham', 9]
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[1:1] = ['spam', 'ham'] #Entfernen Sie bei Slices mit einer Länge von 0 keine Elemente aus der ursprünglichen Liste (nur Einfügen).
>>> L
[0, 'spam', 'ham', 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[3:-3] = [] #Wenn die rechte Seite 0 lang ist, entfernen Sie das Element aus der ursprünglichen Liste
>>> L
[0, 1, 2, 7, 8, 9]
#Wenn Sie für das Slice einen anderen Inkrementwert als 1 angeben, wird nur das entsprechende Element durch den Wert auf der rechten Seite ersetzt. Es ist cool.
>>> L = [0, 1, 2, 3, 4, 5, 6]
>>> L[1::2] = ['one', 'three', 'five']
>>> L
[0, 'one', 2, 'three', 4, 'five', 6]
#Nur weil die linke Seite eine Liste ist, heißt das nicht, dass Sie sie nur zuweisen können, wenn es sich um eine Liste handelt.
#Jedes iterierbare Objekt kann zugewiesen werden.
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[5:] = 'spam'
>>> L
[0, 1, 2, 3, 4, 's', 'p', 'a', 'm']
Kumulative Zuweisungsanweisung
>>> L = [1, 2, 3]
>>> L[2] += 4
>>> L
[1, 2, 7]
>>> L = [0, 1, 2, 3]
>>> L[1:3] += ['spam', 'ham'] #Sie können auch ein Slice auf der linken Seite angeben
>>> L
[0, 1, 2, 'spam', 'ham', 3]
>>> L[3:5] *= 2 # L[3:5]Zu L.[3:5]*Set 2.
>>> L
[0, 1, 2, 'spam', 'ham', 'spam', 'ham', 3]
Element löschen
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del L[1], L[2]
>>> L
[0, 2, 4, 5, 6, 7, 8, 9]
#Natürlich können Sie Slices und inkrementelle Werte angeben
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del L[::2]
>>> L
[1, 3, 5, 7, 9]
#Durch das Löschen eines Elements wird das Objekt nicht freigegeben. Entfernen Sie es einfach aus der Sequenz.
>>> L1 = [1, 2, 3]
>>> L2 = [L1]
>>> L2
[[1, 2, 3]]
>>> del L2[0]
>>> L2
[]
>>> L1 #L1 wird nicht gelöscht
[1, 2, 3]
Sequenzoperator
>>> [1, 2] + [3, 4] #Verknüpfen
[1, 2, 3, 4]
>>> [1, 2] * 3 #Wiederholen Sie dies für die angegebene Anzahl von Malen
[1, 2, 1, 2, 1, 2]
>>> 3 * [1, 2] #Gleiches auch, wenn die Berechnungsreihenfolge geändert wird
[1, 2, 1, 2, 1, 2]
#Der Vergleichsoperator vergleicht die Elemente der Sequenz von Anfang an.
>>> [1, 2] < [3, 4]
True # (1 < 3) & (2 < 4)
#in (es scheint ein Mitgliedschaftsoperator genannt zu werden)
>>> 'B' in ['A', 'B', 'C']
True
Recommended Posts