Überblick

Weitere Informationen finden Sie in O'Reilly Japans "Einführung in Python 3" und im folgenden japanischen Python-Übersetzungsdokument. Lernen Sie die grundlegende Grammatik des Python3-Systems. Ich hoffe, es ist hilfreich für diejenigen, die Python auf die gleiche Weise lernen möchten.

Python 3.6.1-Dokumentation https://docs.python.jp/3/index.html

Sequenztyp

Der Sequenztyp ist eine Datenstruktur für die Behandlung von 0 oder mehr Elementen. Der grundlegende Sequenztyp entspricht Liste, Tupel, Bereich usw.

Listentyp (Liste)

Listen eignen sich für veränderbare Sequenzen, bei denen sich Reihenfolge und Inhalt ändern können. Der gleiche Wert kann auch mehrmals in der Liste vorkommen. (Wenn Sie sich nicht für die Reihenfolge interessieren, wenn Sie eindeutige Werte verwalten können, möchten Sie möglicherweise einen Satz verwenden.)

Erstellt von [] oder list ()

>>> #Erstellen eines leeren Arrays[]
>>> empty_list1 = []
>>> empty_list1
[]

>>> #Listenerstellung[]
>>> str_list1 = ['A','B','C']
>>> str_list1
['A', 'B', 'C']

>>> #Erstellung einer leeren Array-Liste()
>>> empty_list2 = list()
>>> empty_list2
[]

>>> #Listenerstellungsliste()
>>> str_list2 = list(['A','B','C'])
>>> str_list2
['A', 'B', 'C']

Konvertierung von anderen Datentypen in Listentypen

>>> #Konvertieren Sie Zeichenfolgen in Listen
>>> list('ABC')
['A', 'B', 'C']

>>> #Konvertieren Sie Taples in Listen
>>> tuple_sample = ('A','B','C')
>>> list(tuple_sample)
['A', 'B', 'C']

>>> #Konvertieren Sie das Teilungsergebnis der Teilung in eine Liste
>>> today = '2017/07/01'
>>> today.split('/')
['2017', '07', '01']

>>> #Konvertieren Sie das Teilungsergebnis der Teilung in eine Liste (wenn ein leeres Zeichenelement enthalten ist).
>>> target = 'A//B/C/DE///F'
>>> target.split('/')
['A', '', 'B', 'C', 'DE', '', '', 'F']
>>> target.split('//')
['A', 'B/C/DE', '/F']

Element mit [Offset] extrahieren

>>> target = ['A','B','C']

>>> #Geben Sie einen positiven Index an
>>> target[0]
'A'
>>> target[1]
'B'
>>> target[2]
'C'

>>> #Geben Sie einen negativen Index an (Zählung in umgekehrter Reihenfolge vom Ende)
>>> target[-1]
'C'
>>> target[-2]
'B'
>>> target[-3]
'A'

>>> #Fehler, wenn ein Offset außerhalb des Bereichs angegeben ist
>>> target[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Liste der Listen

Der Listentyp kann Elemente verschiedener Typen (einschließlich anderer Listentypen) speichern.

>>> str_upper = ['A','B','C']
>>> str_lower = ['a','b','c']
>>> str_number = [1 ,'2','3',4]
>>> all_str = [str_upper, str_lower, str_number]

>>> #Liste der Listen
>>> all_str
[['A', 'B', 'C'], ['a', 'b', 'c'], [1, '2', '3', 4]]

>>> #Das erste Element aus der Liste in der Liste
>>> all_str[0]
['A', 'B', 'C']

>>> #Das zweite Element aus der Liste in der Liste
>>> all_str[1]
['a', 'b', 'c']

>>> #Drittes Element aus der Liste in der Liste
>>> all_str[2]
[1, '2', '3', 4]

>>> #Wenn Sie zwei Indizes angeben, werden nur die Elemente der integrierten Liste zurückgegeben.
>>> all_str[1][0]
'a'

Umschreiben des Elements mit [Offset] angegeben

Da die Liste veränderbar ist, können Sie den Wert neu schreiben, indem Sie den Versatz angeben.

>>> target = ['A','B','C']
>>> target
['A', 'B', 'C']

>>> target[1] = 'V'
>>> target
['A', 'V', 'C']

>>> #Das Hinzufügen von Elementen zur Liste wird angehängt()Mach mit
>>> target[3] = 'D'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range

Extraktion durch Slice mit angegebenem Bereich von [Offset]

>>> target = ['A','B','C']
>>> target
['A', 'B', 'C']

>>> #Von Anfang an
>>> target[0:]
['A', 'B', 'C']

>>> #2 Zeichen von Anfang an
>>> target[0:2]
['A', 'B']

>>> #Kehren Sie die Elemente der Liste um
>>> target[::-1]
['C', 'B', 'A']

Fügen Sie am Ende ein Element mit append () hinzu

>>> target = ['A','B','C']
>>> target.append('D')
>>> target
['A', 'B', 'C', 'D']

Element mit insert () hinzufügen

Die Funktion append () fügt am Ende ein Element hinzu. Verwenden Sie diese Option, wenn Sie ein Element hinzufügen möchten, indem Sie einen Versatz und eine zusätzliche Position angeben. Wenn ein Versatz angegeben wird, der das Ende überschreitet, wird er am Ende der Liste hinzugefügt. (Für falsche Offsets können keine Ausnahmen ausgelöst werden.)

>>> target = ['A','B','C']

>>> #Zum 3. Zeichen hinzugefügt
>>> target.insert(2,'Q')
>>> target
['A', 'B', 'Q', 'C']

>>> #Wenn Sie einen Versatz angeben, der das Ende überschreitet
>>> target.insert(10,'Z')
>>> target
['A', 'B', 'Q', 'C', 'Z']

>>> #Beim Zählen vom Ende
>>> target.insert(-2,'V')
>>> target
['A', 'B', 'Q', 'V', 'C', 'Z']

Elemente mit del löschen

Da del eine Python-Anweisung und keine Listenmethode ist, schreiben wir del () nicht.

>>> target = ['A','B','C','D','E']

>>> #Löschen Sie das dritte Zeichen
>>> del target[2]
>>> target
['A', 'B', 'D', 'E']

>>> #Löschen Sie das Ende
>>> del target[-1]
>>> target
['A', 'B', 'D']

Element mit remove () entfernen

Wenn Sie ein Element angeben und löschen möchten, anstatt einen Versatz anzugeben, verwenden Sie dieses Element anstelle von del.

>>> target = ['A','B','C','D','E']
>>> target.remove('B')
>>> target
['A', 'C', 'D', 'E']

Elemente mit pop () extrahieren und löschen

Mit pop () können Sie ein Element aus der Liste abrufen und gleichzeitig aus der Liste entfernen. Wenn kein Argument angegeben wird, wird -1 (Ende) als Offset angegeben.

>>> target = ['A','B','C','D','E','F','G']
>>> #Pop das dritte Zeichen
>>> target.pop(2)
'C'
>>> target
['A', 'B', 'D', 'E', 'F', 'G']

>>> #Pop das letzte Zeichen
>>> target.pop()
'G'
>>> target
['A', 'B', 'D', 'E', 'F']

>>> #Pop das erste Zeichen
>>> target.pop(0)
'A'
>>> target
['B', 'D', 'E', 'F']

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

>>> # extend()Liste kombinieren nach
>>> target1 = ['A','B','C']
>>> target2 = ['D','E']
>>> target1.extend(target2)
>>> target1
['A', 'B', 'C', 'D', 'E']

>>> # +=Liste kombinieren nach
>>> target1 = ['A','B','C']
>>> target2 = ['D','E']
>>> target1 += target2
>>> target1
['A', 'B', 'C', 'D', 'E']

Überprüfen Sie den Elementversatz durch index ()

>>> target = ['A','B','C','D','E','F','G']
>>> target.index('D')
3

Anwesenheits- / Abwesenheitsbeurteilung des Wertes unter Verwendung von in ()

>>> target = ['A','B','C','D','E','F','G']
>>> 'A' in target
True
>>> 'Z' in target
False

Zählen der Anzahl der Werte mit count ()

>>> target = ['A','A','A','B','B','C']
>>> target.count('A')
3
>>> target.count('B')
2
>>> target.count('C')
1

Konvertierung in einen String durch join ()

join () ist eine String-Methode, keine Listenmethode.

>>> target = ['A','B','C','D','E','F','G']
>>> ','.join(target)
'A,B,C,D,E,F,G'

Holen Sie sich die Anzahl der Elemente mit len ()

>>> target = ['A','B','C','D','E','F','G']
>>> len(target)
7

Sortieren von Elementen nach sort () (Ergänzung bei Verwendung von Allzweckfunktionen)

>>> #Generische Funktion sortiert()Aufsteigende Sortierung nach
>>> target = ['C','E','A','D','B','F']
>>> sorted_target = sorted(target)
>>> sorted_target
['A', 'B', 'C', 'D', 'E', 'F']

>>> #Generische Funktion sortiert()Absteigend sortieren nach
>>> target = ['C','E','A','D','B','F']
>>> sorted_target = sorted(target, reverse=True)
>>> sorted_target
['F', 'E', 'D', 'C', 'B', 'A']

>>> #Listenfunktionssortierung()Aufsteigende Sortierung nach
>>> target = ['C','E','A','D','B','F']
>>> target.sort()
>>> target
['A', 'B', 'C', 'D', 'E', 'F']

>>> #Listenfunktionssortierung()Absteigend sortieren nach
>>> target = ['C','E','A','D','B','F']
>>> target.sort(reverse=True)
>>> target
['F', 'E', 'D', 'C', 'B', 'A']

Kopieren der Liste mit copy () (Ergänzung zu anderen Kopiermethoden)

>>> target = ['A','B','C']

>>> #Listenkopie()Nach Funktion kopieren
>>> target1 = target.copy()
>>> target1
['A', 'B', 'C']

>>> # list()Kopieren mit Konvertierungsfunktion
>>> target2 = list(target)
>>> target2
['A', 'B', 'C']

>>> #Nach Listen-Slice kopieren
>>> target3 = target[:]
>>> target3
['A', 'B', 'C']

Tupeltyp

Im Gegensatz zu Listen sind Taples unveränderliche Sequenzen, sodass Sie nach dem Definieren eines Tapples keine Elemente hinzufügen, entfernen oder ändern können. Da es keine Funktionen wie append () und insert () gibt, gibt es auch weniger Funktionen als Listen.

Verwenden Sie tapple, um es richtig zu verwenden, wenn Sie mit einer konstanten Liste arbeiten. Weitere zu berücksichtigende Punkte sind:

--Taple benötigt weniger Platz.

Es besteht keine Gefahr, dass die Elemente des Tupels neu geschrieben werden. --Taple kann als Wörterbuchschlüssel verwendet werden.
Benannte Taples können als einfache Alternative zu Objekten verwendet werden.
Funktionsargumente werden als Tapples übergeben.

Einen Taple erstellen

>>> #Einen leeren Taple erstellen
>>> empty_tuple = ()
>>> empty_tuple
()

>>> #Taple mit einem Element (mit einem Komma am Ende)
>>> target1 = 'A',
>>> target1
('A',)

>>> #Mehrere Elemente (das nachfolgende Komma kann weggelassen werden)
>>> target2 = 'A','B','C'
>>> target2
('A', 'B', 'C')

>>> #Es ist einfacher zu verstehen, ob dies ein Taple ist, da es selbst dann keinen Fehler verursacht, wenn Sie Klammern setzen
>>> target3 = ('A','B','C')
>>> target3
('A', 'B', 'C')

Umwandlung in Taple durch Tupel ()

>>> str_list = ['A','B','C']
>>> tuple(str_list)
('A', 'B', 'C')

Andere

Sequenz auspacken

>>> #Liste der entpackten Aufgaben
>>> str_list = ['A','B','C']
>>> s1, s2, s3 = str_list
>>> s1
'A'
>>> s2
'B'
>>> s3
'C'

>>> #Taple-Auspackaufgabe
>>> str_tuple = ('A','B','C')
>>> s1, s2, s3 = str_tuple
>>> s1
'A'
>>> s2
'B'
>>> s3
'C'

Grundlegende Grammatik der Python3-Reihe (Liste, Tapple)