Struktur und Betrieb der Python-Daten (Python-Lernnotiz ③)

Dieses Mal ist ein Lernprotokoll über die Datenstruktur von Objekten, die von Python verarbeitet werden

Methoden, die in Listen verwendet werden können

Element hinzufügen

list.append(x) Fügen Sie am Ende der Liste ein Element hinzu Entspricht einer [Liste (a):] = [x]

list.extend(L) Erweitern Sie die Liste, indem Sie alle Elemente in der angegebenen Liste L am Ende der Liste hinzufügen Entspricht a [len (a):] = L.

list.insert(i, x) Fügt ein Element an der angegebenen Position ein. Das erste Argument ist der Elementindex. Das Einfügen erfolgt vor diesem Element. a.insert (0, x) fügt es am Anfang der Liste ein a.insert (len (a), x) entspricht a.append (x)

Elemente löschen und abrufen

list.remove(x) Löschen Sie das erste Element mit dem Wert x Fehler, falls nicht vorhanden

list.pop([i]) Entfernt das Element an der angegebenen Position aus der Liste und gibt dieses Element zurück Wenn kein Index angegeben ist, geben Sie das letzte Element zurück und entfernen Sie es aus der Liste

• [] Bedeutet optional. Beschreibt eigentlich nicht []

list.clear() Entfernen Sie alle Elemente aus der Liste Entspricht del a [:]

Andere Operationen

list.index() Gibt den Index des ersten Elements mit dem Wert x zurück. Fehler, wenn kein solches Element vorhanden ist

list.count(x) Gibt die Anzahl von x in der Liste zurück

list.sort(key=None, reverse=False) Listenobjekte direkt sortieren (Änderungen direkt vornehmen, ohne eine Kopie der Liste zu erstellen) Die Sortierung kann mit Argumenten angepasst werden

list.reverse() Das Listenobjekt direkt umkehren

list.copy() Gibt eine flache Kopie der Liste zurück Entspricht einem [:]

a = [66.25, 333, 333, 1, 1234.5]

print(a.count(333), a.count(66.25), a.count('x'))
# 2 1 0

a.insert(2, -1)
a.append(333)
print(a)
# [66.25, 333, -1, 333, 1, 1234.5, 333]

print(a.index(333))
# 1

a.remove(333)
print(a)
# [66.25, -1, 333, 1, 1234.5, 333]

a.reverse()
print(a)
# [333, 1234.5, 1, 333, -1, 66.25]

a.sort()
print(a)
# [-1, 1, 66.25, 333, 333, 1234.5]

print(a.pop())
# 1234.5

print(a)
# [-1, 1, 66.25, 333, 333]

Verwenden Sie die Liste als Stapel

Punkt

• Listenmethoden erleichtern die Verwendung von Listen als Stapel

Last-In First-Out-Beispiel

stack = [3, 4, 5]

stack.append(6)
stack.append(7)

print(stack)
# [3, 4, 5, 6, 7]

print(stack.pop())
# 7

print(stack)
# [3, 4, 5, 6]

print(stack.pop())
# 6

Liste als Warteschlange verwenden

Punkt

• Kann bequem als ähnliche Warteschlange verwendet werden
• Im Gegensatz zu Anhängen und Pop sind Einfügen und Pop am Anfang der Liste jedoch langsam. Verwenden Sie daher "collection.deque", um die Warteschlange zu implementieren.

collection.Warteschlange mit Deque(Als Erster rein, als erster raus)Implementierung von

from collections import deque

queue = deque(["Bill", "Earl", "Sam"])
queue.append("Andy")
queue.append("Chris")
print(queue.popleft())
# Bill
print(queue.popleft())
# Earl
print(queue)
# deque(['Sam', 'Andy', 'Chris'])

Listeneinschluss

Punkt

• Besteht aus einem Ausdruck, gefolgt von einer for-Klausel
• Fügen Sie am Ende 0 oder mehr für und if-Klauseln hinzu und schließen Sie das Ganze in [] ein
• Sie erhalten eine neue Liste von Werten, die den ersten Ausdruck in nachfolgenden for- und if-Klauseln auswerten.
• Auch nützlich, wenn Sie eine gemeinsame Verarbeitung für alle Elemente der Liste durchführen möchten.

Ein einfaches Beispiel für die Erstellung einer Liste von Quadraten

#Generieren Sie eine Liste von Quadraten
squares = []
for x in range(10):
    squares.append(x**2)
    
print(squares)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 

#Der obige Prozess hinterlässt eine Variable namens x
print(x)

#Sie können eine Liste ohne Nebenwirkungen erstellen, indem Sie die folgenden Schritte ausführen
squares = list(map(lambda x: x**2, range(10)))

#Wenn Sie ↑ in die Liste schreiben, ist dies wie folgt
squares = [x**2 for x in range(10)]

Ein etwas komplizierteres Beispiel

combs = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
print(combs)
# [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

#Dies entspricht
combs = []
for x in [1, 2, 3]:
    for y in [3, 1, 4]:
        if x != y:
            combs.append((x, y))

print(combs)
# [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

Andere bequeme Verwendung

vec = [-4, -2, 0, 2, 4]
#Generieren Sie eine neue Liste mit doppelten Werten
double = [x*2 for x in vec]

print(double)
# [-8, -4, 0, 4, 8]

#Filtern, um negative Zahlen zu entfernen
positive_list = [x for x in vec if x >= 0]
print(positive_list)
# [0, 2, 4]

Aufnahme verschachtelter Listen

Punkt

• Sie können einen beliebigen Ausdruck am Anfang des Listeneinschlusses verwenden und hier andere Listeneinschlüsse einfügen.

Vertauschen Sie Zeilen und Spalten in einem Array

matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]

#Vertauschen Sie Zeilen und Spalten
reversed_matrix = [[row[i] for row in matrix] for i in range(4)]
print(reversed_matrix)
# [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

• In der Realität sollten komplexe Abläufe integrierte Funktionen verwenden

Beispiel für eine Zip-Funktion

matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
]

print(list(zip(*matrix)))
# [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

del Aussage

Punkt

• Beim Löschen von Elementen in der Liste gibt es eine Möglichkeit, anstelle des Werts einen Index anzugeben
• Im Gegensatz zur Methode pop () gibt sie keinen Wert zurück
• Die del-Anweisung kann auch verwendet werden, um eine Liste auszuschneiden oder die gesamte Liste zu löschen

Beispiel mit del-Anweisung

a = [-1, 1, 66.25, 333, 333, 1234.5]

#Angegeben durch Index
del a[0]

print(a)
# [1, 66.25, 333, 333, 1234.5]

#Angegeben durch Scheibe
del a[2:4]

print(a)
# [1, 66.25, 1234.5]

#Löschen Sie die gesamte Liste
del a[:]

print(a)
# []

#Löschen Sie die gesamte Variable (danach führt das Verweisen auf a zu einem Fehler)
del a

Taple und Sequenz

Punkt

• Es ist nicht möglich, Tapple-Elementen zuzuweisen
• Es ist möglich, Tapples zu generieren, die veränderbare Objekte wie Listen enthalten
• Taples sind unveränderlich und folgen normalerweise unterschiedlichen Elementen
• Es ist üblich, auf jedes Element durch Entpacken, Indexieren oder Attributieren zuzugreifen.
• Ähnlich wie Listen, aber Listen sind veränderbar, bestehen normalerweise aus ähnlichen Elementen und können durch Durchlaufen der Liste aufgerufen werden.

Taple-Betrieb

#Taples bestehen aus durch Kommas getrennten Werten (Tapple Packing)
t = 12345, 54321, 'hello!'

#Das Auspacken ist auch mit der folgenden Methode möglich(Sequenz auspacken)
x, y, z = t
print(x) # 12345
print(y) # 54321
print(z) # hello!

print(t)
# (12345, 54321, 'hello!')

#Taples können verschachtelt werden
u = t, (1, 2, 3, 4, 5)

print(u)
# ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

#Taple kann nicht geändert werden
# t[0] = 88888

#Modifizierbare Objekte können gespeichert werden
v = ([1, 2, 3], [3, 2, 1])
print(v)
# ([1, 2, 3], [3, 2, 1])

#Leerer Taple
empty = ()

#Taple mit 1 Element
singleton = 'hello', <-Fügen Sie am Ende ein Komma hinzu

einstellen

Punkt

• Eine Menge ist eine Sammlung nicht überlappender Elemente in keiner bestimmten Reihenfolge.
• Grundlegende Verwendungszwecke sind die Beurteilung der Existenz und die Beseitigung doppelter Einträge.
• Aggregierte Objekte unterstützen mathematische Operationen wie Summen, Schnittpunkte, Differenzen und symmetrische Differenzen
• Verwenden Sie die mittlere Klammerfunktion {{} oder set () `, um die Menge zu generieren
• Sie müssen "set ()" anstelle von "{}" verwenden, um eine leere Menge zu generieren (die erstere generiert eine leere Dich).

Beispiel setzen

basket = {'apple', 'orage', 'apple', 'pear', 'orange', 'banana'}
print(basket)
# {'banana', 'pear', 'apple', 'orage', 'orange'}

print('orange' in basket) #Hochgeschwindigkeits-Existenzurteil
# True
print('crabgrass' in basket)
# False

#Stellen Sie die Operation ein, indem Sie ein eindeutiges Zeichen aus zwei Wörtern nehmen
a = set('abracadabra')
b = set('alacazam')

#Einzigartiger Charakter von a
print(a)
# {'r', 'a', 'c', 'b', 'd'}

#Zeichen, die in a, aber nicht in b existieren
print(a - b)
{'r', 'b', 'd'}

#Zeichen in a oder b
print(a | b)
# {'z', 'r', 'a', 'c', 'b', 'd', 'l', 'm'}

#Zeichen, die sowohl in a als auch in b existieren
print(a & b)
# {'c', 'a'}

#Gelegentliche Zeichen in a oder b
print(a ^ b)
# {'m', 'b', 'l', 'z', 'd', 'r'}

#Festgelegte Einschlüsse, die Listeneinschlüssen ähneln, werden ebenfalls unterstützt
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)
# {'r', 'd'}

Wörterbuch

Punkt

• Schlüsselverzeichnis
• Für den Schlüssel kann jeder unveränderliche Typ verwendet werden
• Zeichenketten und Zahlen können immer als Schlüssel verwendet werden
• Tapple kann auch als Schlüssel verwendet werden (vorausgesetzt, es enthält nur Zeichenfolgen, Zahlen und Tapples).
• Tapples, die direkt oder indirekt veränderbare Objekte enthalten, können nicht als Schlüssel verwendet werden
• Liste kann nicht als Schlüssel verwendet werden
• Der Schlüssel des Wörterbuchs ist eindeutig
• Wenn Sie die mittlere Klammer schreiben, handelt es sich um ein leeres Wörterbuch {}

Beispiel für einen Wörterbuchtyp

#Initialisieren
tel = {'jack': 4098, 'sape': 4139}

#hinzufügen
tel['guido'] = 4127
print(tel) # {'jack': 4098, 'sape': 4139, 'guido': 4127}
print(tel['jack']) # 4098

#Löschen
del tel['sape']
tel['irv'] = 4127
print(tel)
# {'jack': 4098, 'guido': 4127, 'irv': 4127}

#Holen Sie sich eine Liste der Schlüssel
print(list(tel.keys()))
# ['jack', 'guido', 'irv']

#Nach Schlüssel sortieren
print(sorted(tel.keys()))
# ['guido', 'irv', 'jack']

#Existenzprüfung
print('guido' in tel) # True
print('jack' not in tel) # False

# dict()Der Konstruktor ist der Schlüssel:Aus einer Folge von Tupeln von Wertepaaren
#Erstellen Sie ein Wörterbuch
tel2 = dict([('sape', 4139), ('guide', 4127), ('jack', 4098)])
print(tel2)
# {'sape': 4139, 'guide': 4127, 'jack': 4098}

#Wörterbücher können aus beliebigen Ausdrücken generiert werden, die mithilfe von Wörterbucheinschlüssen Schlüssel und Werte angeben
print({x: x**2 for x in (2, 4, 6)})
# {2: 4, 4: 16, 6: 36}

#Wenn der Schlüssel eine Zeichenfolge ist, ist es möglicherweise einfacher, das Paar mit dem Schlüsselwortargument anzugeben
tel3 = dict(sape=4139, guido=4127, jack=4098)
print(tel3)
# {'sape': 4139, 'guido': 4127, 'jack': 4098}

Schleifentechnik

Punkt

• Verwenden Sie beim Durchlaufen des Wörterbuchs die Methode "items ()", um gleichzeitig den Schlüssel und den entsprechenden Wert abzurufen.

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
    print(k, v)

# gallahad the pure
# robin the brave

• Verwenden Sie beim Schleifen einer Sequenz die Funktion enumerate (), um gleichzeitig den Positionsindex und den entsprechenden Wert abzurufen.

for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)

# 0 tic
# 1 tac
# 2 toe

• Wenn Sie zwei oder mehr Sequenzen gleichzeitig durchlaufen, können Sie mit der Funktion zip () beide Einträge koppeln.
• Übrigens, wenn die Anzahl der Sequenzen unterschiedlich ist und kein Paar erstellt werden kann, wird die größere weggelassen.

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']

for q, a in zip(questions, answers):
    print('What is your {0}? It is {1}.'.format(q, a))
    
# What is your name? It is lancelot.
# What is your quest? It is the holy grail.
# What is your favorite color? It is blue.

• Um die Sequenz in umgekehrter Reihenfolge zu wiederholen, geben Sie zuerst die Sequenz in Vorwärtsreihenfolge an und rufen Sie dann die Funktion reverse () auf.

for i in reversed(range(1, 10, 2)):
    print(i)
    
# 9
# 7
# 5
# 3
# 1

• Verwenden Sie die Funktion sortiert (), um die Sequenz in sortierter Reihenfolge zu durchlaufen. Diese Funktion berührt die ursprüngliche Sequenz nicht und gibt eine neu sortierte Liste zurück

basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

for f in sorted(set(basket)):
    print(f)
    
# apple
# banana
# orange
# pear

• Wenn Sie den Inhalt der Liste ändern möchten, ist es einfacher und sicherer, eine neue Liste zu erstellen.

import math

raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
filtered_data = []
for value in raw_data:
    if not math.isnan(value):
        filtered_data.append(value)
        
print(filtered_data)
# [56.2, 51.7, 55.3, 52.5, 47.8]

Informationen zu den Bedingungen für den Vergleich von Objekten

Punkt

• Vergleichsoperatoren "ist" und "ist nicht" vergleichen zwei Objekte, um festzustellen, ob sie genau gleich sind
• Alle Vergleichsoperatoren haben die gleiche Priorität, alle niedriger als alle numerischen Operatoren
• Vergleiche können durch die Booleschen Operatoren und und oder kombiniert werden
• Der Abschluss des Vergleichs (und aller anderen Booleschen Ausdrücke) kann mit "nicht" abgelehnt werden.
• Und oder haben keine niedrigere Priorität als Vergleichsoperatoren
• Priorität ist nicht> und> oder
• A und nicht B oder C entspricht (A und (nicht B)) oder C.
• und und oder werden Kurzschlussoperatoren genannt
• Und und oder werden von links nach rechts bewertet, und die Bewertung wird gestoppt, wenn die Schlussfolgerung entschieden wird.
• Wenn A und B und C angegeben sind, wird C nicht bewertet, wenn B falsch ist.
• Wenn anstelle eines Booleschen Werts ein allgemeiner Wert verwendet wird, ist der Rückgabewert des Kurzschlussoperators das zuletzt ausgewertete Argument.

string1, string2, string3 = '', 'Tronbheim', 'Hammer Dance'
non_null = string1 or string2 or string3
print(non_null)
# Tronbheim

Sequenzvergleich, anderer Typvergleich

Punkt

• Sequenzobjekte können mit Objekten mit demselben Sequenztyp verglichen werden
• Verwenden Sie für diesen Vergleich die lexikalische Reihenfolge
• Die Reihenfolge des Vergleichs ist wie folgt
• Vergleichen Sie zuerst die ersten Elemente. Wenn sie unterschiedlich sind, wird die Größe als Schlussfolgerung verwendet. Wenn sie gleich sind, fahren Sie mit dem Vergleich zwischen den zweiten Elementen fort.
• Wenn dasselbe Element fortgesetzt wird, wird der Vergleich fortgesetzt, bis eine der beiden Sequenzen abgelaufen ist
• Wenn die beiden zu vergleichenden Elemente ebenfalls denselben Sequenztyp haben, wird ein Wörterbuchvergleich rekursiv durchgeführt.
• Wenn die Elemente in den beiden Sequenzen alle gleich sind, werden beide Sequenzen als gleich angesehen.
• Die beiden sind im Grunde die gleiche Sequenz, und wenn eine kürzer ist, ist diese kürzere kleiner.
• Verwenden Sie die Unicode-Codepunktnummer jedes Zeichens für die Wörterbuchreihenfolge der Zeichenfolgen

Objektvergleich

(1, 2, 3) < (1, 2, 4)
[1, 2, 3] < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)