Von http://www.amazon.co.jp/dp/4873117380

Scheibe

Zuallererst die Idee des Schneidens

-- [:] `` `extrahiert die gesamte Sequenz von Anfang bis Ende -- [start:] extrahiert die Sequenz vom Startversatz bis zum Ende --``` [: end] extrahiert die Sequenz vom Anfang bis zum Ende-1-Offset -- [start: end] `` `extrahiert die Sequenz vom Start-Offset zum End-1-Offset -- [start: end: step] `` `extrahiert die Sequenz vom Start-Offset bis zum End-1-Offset für jedes Schrittzeichen

Der Versatz ist 0, 1, ... von Null nach rechts und -1, -2, ... vom Ende nach links. Wenn start nicht angegeben ist, verwendet Slice 0 (start).

Beispiel

In [9]: sample_list = ['a','b','c','d','e']

In [10]: sample_list[0]
Out[10]: 'a'

In [11]: sample_list[0:]
Out[11]: ['a', 'b', 'c', 'd', 'e']

In [12]: sample_list[0:-1]
Out[12]: ['a', 'b', 'c', 'd']

In [13]: sample_list[0:4]
Out[13]: ['a', 'b', 'c', 'd']

In [19]: sample_list[-3:]
Out[19]: ['c', 'd', 'e']

In [22]: sample_list[-3:-1]
Out[22]: ['c', 'd']

#Beim Umblättern der Liste
In [14]: sample_list[::-1]
Out[14]: ['e', 'd', 'c', 'b', 'a']

append() Verwenden Sie die Methode append (), wenn Sie am Ende der Liste ein Element hinzufügen möchten

In [23]: sample_list.append('f')

In [24]: sample_list
Out[24]: ['a', 'b', 'c', 'd', 'e', 'f']

Kombinieren Sie Listen mit verlängern () oder + =

Sie können expand () verwenden, um die beiden Listen zu einer zu kombinieren. Dies ist eine zerstörerische Operation.

In [27]: sample_list.extend(number_list)

In [28]: sample_list
Out[28]: ['a', 'b', 'c', 'd', 'e', 'f', 1, 2, 3]

# sample_Liste initialisieren
In [33]: sample_list = ['a','b','c','d','e']

In [34]: sample_list += number_list

In [35]: sample_list
Out[35]: ['a', 'b', 'c', 'd', 'e', 1, 2, 3]

Append () wird übrigens als ein Element behandelt

In [36]: sample_list = ['a','b','c','d','e']
In [37]: sample_list.append(number_list)

In [38]: sample_list
Out[38]: ['a', 'b', 'c', 'd', 'e', [1, 2, 3]]

Element mit dem durch insert () angegebenen Versatz hinzufügen

Die Funktion append () kann nur ein Element am Ende der Liste hinzufügen. Verwenden Sie insert (), wenn Sie den Versatz der Liste angeben und ein Element davor hinzufügen möchten. Wenn der Versatz 0 angegeben ist, wird er am Anfang eingefügt. Wenn Sie einen Versatz angeben, der das Ende überschreitet, wird er wie append () am Ende der Liste eingefügt.

In [42]: sample_list = ['a','b','c','d','e']

In [43]: sample_list.insert(1,1)

In [44]: sample_list
Out[44]: ['a', 1, 'b', 'c', 'd', 'e']

In [45]: sample_list.insert(10,10)

In [46]: sample_list
Out[46]: ['a', 1, 'b', 'c', 'd', 'e', 10]

Element des angegebenen Versatzes durch del löschen

Beachten Sie, dass del eine Anweisung und keine Methode ist.

In [46]: sample_list
Out[46]: ['a', 1, 'b', 'c', 'd', 'e', 10]

In [48]: del sample_list[-1]

In [49]: sample_list
Out[49]: ['a', 1, 'b', 'c', 'd', 'e']

(Del-, Len- und uneinheitliche Implementierungen sind ziemlich verwirrend.)

Entfernen Sie Elemente basierend auf dem Wert mit remove ()

Wenn Sie den Versatz nicht kennen oder sich nicht darum kümmern, wo er sich befindet, können Sie mit remove () einen Wert zum Entfernen des Elements angeben.

In [49]: sample_list
Out[49]: ['a', 1, 'b', 'c', 'd', 'e']

In [50]: sample_list.remove(1)

In [51]: sample_list
Out[51]: ['a', 'b', 'c', 'd', 'e']

So rufen Sie ein Element ab und löschen es, indem Sie einen Versatz mit pop () angeben

Mit pop () können Sie ein Element aus der Liste entfernen und gleichzeitig aus der Liste entfernen. Wenn Sie pop () mit einem Offset aufrufen, wird das Element für diesen Offset zurückgegeben. Wenn kein Argument angegeben wird, wird -1 als Offset verwendet.

In [51]: sample_list
Out[51]: ['a', 'b', 'c', 'd', 'e']

In [52]: sample_list.pop()
Out[52]: 'e'

In [53]: sample_list
Out[53]: ['a', 'b', 'c', 'd']

In [54]: sample_list.pop(1)
Out[54]: 'b'

In [55]: sample_list
Out[55]: ['a', 'c', 'd']

Wie erkennt man den Elementversatz vom Elementwert durch index ()

In [56]: sample_list = ['a','b','c','d','e']

In [57]: sample_list.append('a')

In [58]: sample_list
Out[58]: ['a', 'b', 'c', 'd', 'e', 'a']

In [60]: sample_list.index('b')
Out[60]: 1

#Wenn es mehrere gibt, die mit dem kleineren Versatz
In [61]: sample_list.index('a')
Out[61]: 0

Testen Sie das Vorhandensein oder Nichtvorhandensein von Werten mit in

Verwenden Sie diese Option, um zu testen, ob die Liste einen Wert hat.

In [64]: sample_list
Out[64]: ['a', 'b', 'c', 'd', 'e']

In [65]: 'a' in sample_list
Out[65]: True

In [66]: 'g' in sample_list
Out[66]: False

Berechnen Sie die Anzahl der Werte mit count ()

Verwenden Sie count (), um zu zählen, wie viele bestimmte Werte in der Liste enthalten sind.

In [64]: sample_list
Out[64]: ['a', 'b', 'c', 'd', 'e']

In [67]: sample_list.count('a')
Out[67]: 1

In [68]: sample_list.count('g')
Out[68]: 0

In [69]: sample_list.append('a')

In [70]: sample_list
Out[70]: ['a', 'b', 'c', 'd', 'e', 'a']

In [71]: sample_list.count('a')
Out[71]: 2

Sortieren von Elementen nach sort ()

Es gibt zwei Arten

Die Methode sort () ist eine destruktive Operation
Die generische Funktion sorted () ist eine zerstörungsfreie Operation
Gibt eine Kopie der sortierten Liste zurück

In [76]: names = [ 'Ryoma', 'Toshimichi', 'Tomoatsu']

In [77]: sorted_named = sorted(names)

In [78]: sorted_named
Out[78]: ['Ryoma', 'Tomoatsu', 'Toshimichi']

In [79]: names.sort()

In [80]: names
Out[80]: ['Ryoma', 'Tomoatsu', 'Toshimichi']

Ganzzahlen und Gleitkommazahlen können zusammen verwendet werden, da Python sie automatisch in den Ausdruck konvertiert.

In [81]: numbers = [2, 1, 4.0, 3]

In [82]: numbers.sort()

In [83]: numbers
Out[83]: [1, 2, 3, 4.0]

Standardmäßig ist es in aufsteigender Reihenfolge.```reverse=True``Dies kann auch in absteigender Reihenfolge erfolgen.

In [84]: numbers = [2, 1, 4.0, 3]

In [85]: numbers.sort(reverse=True)

In [86]: numbers
Out[86]: [4.0, 3, 2, 1]

=Ersetzung und Kopie durch()Kopieren von

=Beachten Sie dann, dass das Referenzziel dasselbe ist.

In [87]: a = [1, 2, 3]

In [88]: b = a

In [89]: b[0] = 'why'

In [90]: b
Out[90]: ['why', 2, 3]

In [91]: a
Out[91]: ['why', 2, 3]

Verwenden Sie zum Kopieren eine der folgenden Optionen -Listenkopie()Funktion

list()Konvertierungsfunktion -Handgelenkscheibe[:]

In [92]: a = [1, 2, 3]

In [93]: b = a.copy()

In [94]: c = list(a)

In [95]: d = a[:]

In [96]: a
Out[96]: [1, 2, 3]

In [97]: b
Out[97]: [1, 2, 3]

In [98]: c
Out[98]: [1, 2, 3]

In [99]: d
Out[99]: [1, 2, 3]

In [100]: a[0] = 'why'

In [101]: a
Out[101]: ['why', 2, 3]

In [102]: b
Out[102]: [1, 2, 3]

In [103]: c
Out[103]: [1, 2, 3]

In [104]: d
Out[104]: [1, 2, 3]

list()Informationen zur Konvertierungsfunktion

list()Die Konvertierungsfunktion generiert eine Liste, wenn sie alleine verwendet wird. Wenn Sie jedoch eine Liste oder einen Tipp als Argument verwenden, wird der äußerste Teil des Inhalts erweitert und aufgelistet.

In [107]: a = [1, 2, 3]

In [108]: b = (1, 2, 3)

In [109]: c = list(a)

In [110]: c
Out[110]: [1, 2, 3]

In [111]: d = list(b)

In [112]: d
Out[112]: [1, 2, 3]

In [113]: a.append(b)

In [114]: a
Out[114]: [1, 2, 3, (1, 2, 3)]

In [115]: c = list(a)

In [116]: c
Out[116]: [1, 2, 3, (1, 2, 3)]

Zusammenfassung der Python3-Listenoperationen