Die Python-Liste verweist auf Objekte
>>> L1 = [1, 2]
>>> L2 = ['A', L1]
>>> L2
['A', [1, 2]]
>>> L1.append('three')
>>> L2
['A', [1, 2, 'three']]
#Elementarisierung als separates Objekt anstelle einer Referenz
>>> L1 = [1, 2]
>>> L2 = ['A', L1[:]]
>>> L2
['A', [1, 2]]
>>> L1.append('three')
>>> L2
['A', [1, 2]]
Listeneinschluss#1
#Listenverarbeitung wie folgt
src = ['SPAM', 'HAM', 'EGG']
dest = []
for val in src:
lowerer = val.lower()
dest.append(lowerer) #Machen Sie alles niedriger und tauchen Sie in eine andere Liste ein
#Python kann so geschrieben werden. Einfach.
src = ['SPAM', 'HAM', 'EGG']
dest = [val.lower() for val in src]
Es scheint, dass die Notation der Listeneinbeziehung schneller ist. Geschwindigkeit der Python-Listeneinschlussnotation
Listeneinschluss#2
#Es ist auch möglich, eine Liste durch Angabe eines bedingten Ausdrucks zu generieren
>>> L = [1, 2, 3, 4, 5]
>>> [i for i in L if i % 2]
[1, 3, 5]
#Iterierbare Objektelemente können auch zerlegt und gespeichert werden
>>> L = [('a', 1), ('b', 2), ('c', 3)]
>>> [c * i for c, i in L]
['a', 'bb', 'ccc']
#Am Anfang des Variablennamens*Wenn Sie hinzufügen, können Sie mehrere Elemente in einer Liste empfangen
>>> L = [(1, 2), (3, 4, 5), (6, 7, 8, 9)]
>>> [first * sum(others) for first, *others in L]
[2, 27, 144]
#Es sind auch mehrere Schleifen möglich
>>> years = [2019, 2020]
>>> months = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
>>> [(y, m) for y in years
... for m in months]
[(2019, 1), (2019, 2), (2019, 3), (2019, 4), (2019, 5), (2019, 6), (2019, 7), (2019, 8), (2019, 9), (2019, 10), (2019, 11), (2019, 12), (2020, 1), (2020, 2), (2020, 3), (2020, 4), (2020, 5), (2020, 6), (2020, 7), (2020, 8), (2020, 9), (2020, 10), (2020, 11), (2020, 12)]
Da die Liste ein Objekt vom Typ Sequenz ist, Operatoren wie + (Verkettung), * (Wiederholung) und Vergleichsoperatoren werden unterstützt
Listenoperator
#Verknüpfen
>>> [1, 2] + [3]
[1, 2, 3]
#Wiederholung
#Wenn Sie im Voraus eine Liste mit fester Länge erstellen, sieht dies folgendermaßen aus
>>> L = [None] * 5
>>> L
[None, None, None, None, None]
Von der Sequenz+Betreiber und*Der Bediener kopiert nur die Referenz
#Wenn Sie ein Listenobjekt mit mehreren Listenobjekten als Elemente erstellen möchten
#Ich habe das Gefühl, dass ich so schreiben kann
>>> L = [[]] * 3
>>> L
[[], [], []]
#Aber nein
>>> L[0].append(1)
>>> L
[[1], [1], [1]] #Alle Elemente sind Verweise auf dasselbe Objekt
#Listen Sie die Einschlussnotation zu solchen Zeiten auf
>>> L = [[] for i in range(3)]
>>> L[0].append('spam')
>>> L
[['spam'], [], []]
Liste der kumulativen Zuweisungsanweisungen
#Für Listenobjekte A.= A +B und A.+=B ist nicht gleichwertig!
>>> A = [0, 1, 2, 3]
>>> B = ['spam']
>>> id(A)
4429687688
>>> A = A + B
>>> A
[0, 1, 2, 3, 'spam']
>>> id(A)
4429687176 # A = A +In B wird A ein neues Listenobjekt zugewiesen
>>> A = [0, 1, 2, 3]
>>> B = ['spam']
>>> id(A)
4429687688
>>> A += B
>>> A
[0, 1, 2, 3, 'spam']
>>> id(A)
4429687688 # A +=In B werden alle Elemente von B wie zu dem durch die Variable A angegebenen Listenobjekt hinzugefügt.
Sie müssen keine Methode zusammenstellen, sondern sie im Sinne eines einmaligen Versuchs schreiben.
Listen Sie Methoden dies und das auf
#Element hinzufügen
>>> A = [0, 1, 2, 3]
>>> A.append(4)
>>> A
[0, 1, 2, 3, 4]
#Wenn jedoch die Anzahl der Elemente im Voraus bekannt ist, ist es schneller, die Substitutions- oder Einschlussnotation zu verwenden.
#Referenz:https://www.kumilog.net/entry/python-speed-comp
#Löschen Sie alle Elemente
>>> A = [0, 1, 2, 3]
>>> A.clear() # del A[:]Gleich wie
>>> A
[]
#Erstellen Sie ein anderes Listenobjekt mit denselben Elementen
>>> A = [0, 1, 2, 3]
>>> id(A)
4429688712
>>> B = A.copy() # B = A[:]Gleich wie
>>> B
[0, 1, 2, 3]
>>> id(B)
4430184776
#Gibt die Anzahl der Elemente mit einem Wert zurück, der dem Argument entspricht
>>> A = [0, 1, 2, 1]
>>> A.count(1)
2
#Zerlegen Sie alle Elemente eines iterierbaren Objekts und hängen Sie sie an
>>> A = [0, 1, 2]
>>> A.extend('spam')
>>> A
[0, 1, 2, 's', 'p', 'a', 'm']
>>> A[len(A):len(A)] = 'ham' #Das ist das gleiche
>>> A
[0, 1, 2, 's', 'p', 'a', 'm', 'h', 'a', 'm']
#Findet ein Element mit einem Wert, der dem Argument entspricht, und gibt den Index des ersten übereinstimmenden Elements zurück
>>> A = [3, 4, 5, 3, 4, 5]
>>> A.index(4)
1
>>> A.index(4, 3) #Der Suchbereich kann als Argument für die Aufteilung angegeben werden
4
>>> A.index(4, 3, 4) #Ausnahme wenn nicht
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 4 is not in list
#Element an angegebener Position hinzufügen
>>> L = ['ham']
>>> L.insert(0, 'spam') # L[0:0] = ['spam']Gleich wie
>>> L
['spam', 'ham']
>>> L.insert(-1, 'egg') #Vom Ende zur relativen Position hinzugefügt
>>> L
['spam', 'egg', 'ham']
#Pop das nachfolgende Element (seinen Wert zurückgeben und das Element löschen)
>>> L = [0, 1, 2, 3]
>>> L.pop()
3
>>> L
[0, 1, 2]
>>> L.pop(1) #Index kann angegeben werden
1
>>> L
[0, 2]
#Suchen Sie nach Elementen mit demselben Wert wie das Argument und löschen Sie das erste übereinstimmende Element
>>> L = [0, 1, 2, 3, 2]
>>> L.remove(2)
>>> L
[0, 1, 3, 2]
#Ersetzen Sie die Elemente in der Liste in umgekehrter Reihenfolge. Es wird kein neues Listenobjekt erstellt.
>>> L = [0, 1, 2, 3]
>>> L.reverse()
>>> L
[3, 2, 1, 0]
#Sortieren Sie die Elemente der Liste. Erstellen Sie kein neues Listenobjekt. Argumente gelten nur für Schlüsselwörter.
>>> L = ['9', '10', '100']
>>> L.sort()
>>> L
['10', '100', '9']
#Wenn für key eine Funktion angegeben ist, wird der Schlüssel mit den Elementen der Liste als Argumenten aufgerufen und der Rückgabewert als zu sortierender Schlüssel verwendet.
>>> L.sort(key=int)
>>> L
['9', '10', '100']
#Absteigende Sorte
>>> L.sort(reverse=True)
>>> L
['9', '100', '10']
#Das Sortieren in Python ist "stabile Sortierung" (Elemente mit demselben Sortierschlüssel haben vor und nach dem Sortieren denselben Kontext)
>>> def func(v):return v % 3
...
>>> L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> L.sort(key=func)
>>> L
[3, 6, 9, 0, 1, 4, 7, 2, 5, 8] # 3,6,9 - 0,1,4,7 - 2,5,Der Kontext von 8 hat sich nicht geändert
Recommended Posts