Verstehen Sie Python-Listen, Wörterbücher und so weiter.

list

list()

Liste erstellen / konvertieren. Zeichenkette → Liste und Tupel → Liste sind möglich.

Generieren

hoge = []
hoge = list()  #Das gleiche wie oben

Umwandlung

list('cat')
# ['c','a','t']

Offset

Scheibe

hoge = ['a','b','c','d']
hoge[::2]
# ['a','c']
hoge[::-2]
# ['d','b'] #Aus dem Gegenteil
hoge[::-1]
# ['d','c','b','a'] #In umgekehrter Reihenfolge

append() extend()

Hinzufügen und kombinieren

hoge = ['a','b','c','d']
fuga = ['e']

hoge.append('e')
hoge.extend(fuga)
hoge += fuga
# ['a','b','c','d','e'] #Trotzdem das gleiche Ergebnis

insert()

piyo = ['a','b','d','e']
piyo.insert(2, 'c')
# ['a','b','c','d','e']

remove() pop()

hoge = ['a','b','c','d','e']
hoge.remove('d') #Löschen Sie, indem Sie das Element selbst angeben
hoge.pop(3) #Löschen Sie durch Angabe eines Versatzes(Um genau zu sein, herausnehmen)
# hoge = ['a','b','c','e'] #Gleiches Ergebnis

Existenzprüfung

hoge = ['a','b','c','d','e']
if 'a' in hoge:
    print("exist")
else
    print("not exist")
# exist

split() join()

fuga = 'a,b,c,d'
fuga.split(',')
# ['a','b','c','d']

hoge = ['a','b','c','d']
','.join(hoge)    #hoge.join(',')Beachten Sie, dass dies nicht der Fall ist!
# 'a,b,c,d'

copy()

Python wird grundsätzlich als Referenz übergeben.

hoge = ['a','b','c','d']
fuga = hoge
#Wenn Sie danach den Hoge wechseln, spiegelt Fuga auch die Änderung wider.=Fuga bezieht sich auf Hoge.

fuga = hoge.copy()
fuga = list(hoge)
fuga = hoge[:]
#Jedes dieser Elemente generiert eine Kopie und keine Referenz. Daher behält fuga die ursprüngliche Liste bei, auch wenn Sie den Hofge ändern.

Holen Sie sich Offset und Wert enumerate ()

hoge = ['a','b','c','d']
for i, val in enumerate(hoge):
    print(i, val)

Taple

Der Unterschied zur Liste besteht darin, dass sie unveränderlich ist, dh die Änderungen funktionieren nicht.

Erstellen

hoge = 4, 10, 5
hoge = (4, 10, 5)
hoge = tuple(4, 10, 5)  #Alles das selbe.

Auspacken

Der Inhalt des Taples kann jeder Variablen ohne Verwendung temporärer Variablen zugewiesen werden.

Auspacken

hoge = tuple(4, 10, 5)
a, b, c = hoge

Wörterbuch

dict()

Generieren

hoge = {}
hoge = dict()

Umwandlung

fuga = [('a', 'b'), ('c', 'd')] #Listen von Listen können ebenfalls konvertiert werden
hoge = dict(fuga)
# {
#     'a': 'b',
#     'c': 'd'
# }

piyo = list(hoge.items()) #Mit einer Liste von Taples konvertiert.(Darüber hinaus Liste()Wenn Sie das Diktat nicht beißen_Rückgabe in Form von Artikeln.)
# [('a', 'b'), ('c', 'd')]

#Der Grund für die Anwendung ist außerdem, dass die Entpackungseigenschaft von Taple verwendet wird.
for key, item in hoge.items():
    pass

Hinzufügen und kombinieren

hoge = {
    'a': 'b',
    'c': 'd'
}
hoge['e'] = 'f' #Sie können es ohne Erlaubnis angeben

fuga = {
    'g': 'h'
}
hoge.update(fuga) #Beitreten

Existenzprüfung

Gleich wie die Liste.

hoge = {
    'a': 'b',
    'c': 'd'
}
if 'a' in hoge:
    print("exist")
else
    print("not exist")
# exist

keys() values()

hoge = {
    'a': 'b',
    'c': 'd'
}
hoge.keys()
# dict_keys(['a', 'c'])→ Gibt eine iterierbare Schlüsselansicht zurück. aufführen()Müssen beißen und in eine Liste konvertieren.
list(hoge.keys())
# ['a', 'c']

values () ist das gleiche wie oben.

copy()

Gleich wie die Liste. Wenn nicht als Referenz übergeben.

einstellen

Wenn Sie sich nicht für die Bestellung interessieren. Die Form wird als "{0, 2, 7, 1, 4}" dargestellt.

Erstellen

hoge = set()           #Leeres Set
hoge = {0, 2, 7, 1, 4} #Ein Set, das auch den Inhalt definiert
hoge = {}              #Dies ist ein Wörterbuch

hoge = set( ["hoge", "fuga", "piyo"] ) #Neben Listen werden auch Taples, Zeichenketten und Wörterbücher unterstützt.(Im Wörterbuch wird nur der Schlüssel extrahiert)
# {"piyo", "hoge", "fuga"}

Byte-Zeichenfolge

Bytes → So etwas wie ein Haufen Bytes, unveränderlich. bytearray → So etwas wie eine Liste von Bytes, veränderbar.

Andere Funktionen

zip()

Geben Sie den Taple zurück. Es kann wie folgt verwendet werden, indem mit der for-Anweisung entpackt wird.

hoge = ["a", "b", "c"]
fuga = ["A", "B", "C", "D"]

for small, large in zip(hoge, fuga):
    print("small:", small, "large:", large)

# small: a large: A
# small: b large: B
# small: c large: C  #Beenden Sie nach dem kürzeren,"D"Es kommt nicht heraus.

range()

Erstellen einer Sequenz. Die Syntax range (start, end, step). Bis zur Nummer unmittelbar vor "Ende".

range(0, 3)
# 0, 1, 2

Einschlussnotation

Listeneinschlussnotation

Schreiben Sie eine for-Schleife ohne das [] in die Liste.

Syntax 1

 [Ausdruck für Variable in iterierbarem Objekt]

Beispiel

hoge = [num for num in range(0, 3)]
# [0, 1, 2]

fuga = [num * 2 for num in range(0, 3)]
# [0, 2, 4]

piyo = [(a, b) for a in range(0, 2) for b in range(0, 3)]
#[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]

Syntax 2

 [Ausdruck für Variable in iterierbarem Objekt, wenn Bedingung]

Beispiel

hoge = [num for num in range(0, 3) if num % 2 == 0]
# [0, 2]

Wörterbucheinschlussnotation

Syntax

 {Formel:Formelfor 変数 in イテラブルオブジェクト }

Beispiel

word = "letter" #Es ist in Ordnung, eine Liste oder einen Satz zu führen
hoge = { let : word.count(let) fot let in word }
# { "l": 1, "e": 2, "t": 2, "r": 1}

Legen Sie die Einschlussnotation fest

das Gleiche. Kürzung

× Taple-Einschlussnotation ○ Generatortyp

→ Es gibt keine Einschlussnotation im Taple! Wenn Sie im gleichen Format wie oben schreiben, wird ein Generatorobjekt zurückgegeben.