Grundlegende Grammatik der Python3-Reihe (Liste, Tapple)

Ü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.

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'

Recommended Posts

Grundlegende Grammatik der Python3-Reihe (Liste, Tapple)
Liste der grundlegenden Operationen für Python3-Listen, -Tapples, -Wörterbücher und -Sätze
Grundlegende Grammatik des Python3-Systems (Wörterbuch)
Grundlegende Grammatik von Python3
Grundlegende Grammatik der Python3-Reihe (Zeichenkette)
Grundlegende Grammatik des Python3-Systems (inklusive Notation)
Liste der Python-Module
Python-Grundgrammatik (Sonstiges)
Grundkenntnisse in Python
Python grundlegende Grammatik Memo
Grundlegende Bedienung von Python Pandas Series und Dataframe (1)
Zusammenfassung der Python3-Listenoperationen
Zusammenfassung der Python-Sortierung (Liste, Wörterbuchtyp, Serie, DataFrame)
Python-Installation und grundlegende Grammatik
Python-Grammatik-Grundnotiz (1)
Python-Grundkurs (5 List Taple)
Python-Grundgrammatik (Verschiedenes) Memo (2)
Grundlegende Python-Grammatik für Anfänger
[Python] Kopie einer mehrdimensionalen Liste
Grundlegende Verwendung von Python-F-String
Ich habe die grundlegende Python-Grammatik gelernt
Python-Grundgrammatik (Verschiedenes) Memo (4)
Python (Python 3.7.7) Installation und grundlegende Grammatik
Ich habe die grundlegende Grammatik von Python in Jupyter Lab geschrieben
[Hinweis] Liste der grundlegenden Befehle zum Erstellen einer Python / Conda-Umgebung
[Python] Taple-Version des Pulldowns der Präfektur
Vergleich der grundlegenden Grammatik zwischen Java und Python
Zeitdelta in Python 2.7-Serie teilen
Informationen zur Grundlagenliste der Python-Grundlagen
Grundlegendes Studium von OpenCV mit Python
Grundlegende Grammatik des Python3-Systems (Verwendung von Funktionen, Schließung, Lambda-Funktion)
[Python] -Liste
Zeigen Sie eine Liste der Alphabete in Python 3 an
[Grundlegende Grammatik] Unterschiede zwischen Ruby / Python / PHP
Python> Tupel in Liste konvertieren> aList = Liste (pi_tuple)
[Python] Ruft eine Liste der Instanzvariablen ab
[Python] Ich habe die grundlegende Grammatik persönlich zusammengefasst.
[Python Iroha] Unterschied zwischen Liste und Tupel
Zusammenfassung der integrierten Methoden usw. der Python-Liste
Python-Grundkurs (Ende 15)
Zusammenfassung der Verwendung der Python-Liste
Einfache Einführung in die Python3-Serie und OpenCV3
[Python] Nur eine Liste der Ordner abrufen
Ein leicht verständlicher Vergleich der grundlegenden Grammatik von Python und Go
Python-Grundlagen: Liste
[Python] Checklistenelemente alle, alle
RF Python Basic_01
[Python] Sortieren Sie die Liste von pathlib.Path in natürlicher Reihenfolge
Listentyp, Taple-Typ 2
[Python] Erstellen Sie eine Liste mit verschiedenen Zeichentypen
[Einführung in die Udemy Python3 + -Anwendung] 19. Kopie der Liste
Kopieren Sie die Liste in Python
Python-Grundschrift
Grundlagen von Python ①