Tutorial zur Python Advanced-Reihe: Erweiterte Python-Syntax und reguläre Ausdrücke

Lernziel

1. Sie müssen die Verwendung der with-Anweisung beherrschen

2. Sie müssen die beiden Erstellungsmethoden des Generators kennen

3. Kennen Sie den Unterschied zwischen Deep Copy und Shallow Copy

4. Kann das Schreiben regulärer Ausdrücke in Python beherrschen

1. Erweiterte Python-Syntax

1. mit Anweisung und Kontextmanager

☆ mit Aussage

Python bietet eine with-Anweisung, die einfach und sicher ist. Bei Verwendung der with-Anweisung kann der Dateivorgang automatisch aufgerufen werden, um den Dateivorgang zu schließen. Selbst wenn eine Ausnahme auftritt, wird der Dateivorgang automatisch geschlossen. Nehmen Sie eine Kastanie:

Verwenden Sie die with-Methode, um Dateioperationen wie folgt zu implementieren:

# 1. Öffnen Sie die Datei, indem Sie withopen('1.txt','w') als f schreiben :
# 2. Lesen Sie den Dateiinhalt
f.write('hello world')

2. Wie der Generator entsteht

Ein Python-Generator ist eine spezielle Art von Iterator, der Werte bei Bedarf und nicht alle auf einmal liefert. Generatoren sparen Speicherplatz und können Daten verzögert generieren, indem sie Daten nur dann generieren, wenn sie benötigt werden.

So erstellen Sie einen Generator

① Generatorableitung

② Schlüsselwort yield

☆ Generatorverständnis

Generatorausdrücke sind eine Listenverständnis-ähnliche Syntax, die zum Erstellen von Generatorobjekten verwendet werden kann. Im Gegensatz zum Listenverständnis verwenden Generatorausdrücke Klammern anstelle von eckigen Klammern und geben ein Generatorobjekt anstelle einer Liste zurück.

Das Folgende ist ein Beispiel für einen Generatorausdruck:

# Erstelle einen Generator
my_generator =(i *2for i inrange(5))
print(my_generator)

# next erhalte den nächsten Wert des Generators
# value = next(my_generator)
# print(value)

# Durchlaufe den Generator
nach Wert in my_generator:
drucken (Wert)

Bei Verwendung von next wird der nächste Wert des Generators abgerufen, d. h.:

# Einen Generator erstellen
my_generator = (i * 2 für i in range(5))
print(my_generator)

# next den nächsten Wert des Generators abrufen
value = next(my_generator)
print(value)

Dieser Code verwendet einen Generatorausdruck, um ein Generatorobjekt my_generator zu erstellen, das Ganzzahlen von 0 bis 4 generiert und jede Ganzzahl mit 2 multipliziert.

Verwenden Sie als Nächstes die Funktion next, um den nächsten Wert des Generatorobjekts abzurufen und ihn dem Variablenwert zuzuweisen. Da Generatoren Werte bei Bedarf generieren, generiert der Generator beim ersten Aufruf der nächsten Funktion den ersten Wert und gibt diesen Wert zurück. Beim nächsten Aufruf der nächsten Funktion generiert der Generator den nächsten Wert und gibt diesen Wert zurück. Analog dazu löst der erneute Aufruf der nächsten Funktion eine StopIteration-Ausnahme aus, bis im Generator keine Werte mehr generiert werden können, was darauf hinweist, dass der Generator keine Werte mehr generiert.

In diesem Beispiel generiert der Generator beim ersten Aufruf der nächsten Funktion den ersten Wert 0 und gibt diesen Wert zurück. Daher ist der Wert des Variablenwerts 0, der dann gedruckt wird.

# Erstelle einen Generator
my_generator = (i * 2 for i in range(5))
print(my_generator)

# Durchlaufe den Generator
für den Wert in my_generator:
print(value)

Dieser Code verwendet einen Generatorausdruck, um ein Generatorobjekt my_generator zu erstellen, das Ganzzahlen von 0 bis 4 generiert und jede Ganzzahl mit 2 multipliziert.

Verwenden Sie als Nächstes eine for-Schleife, um das Generatorobjekt zu durchlaufen, wobei Sie nacheinander jeden vom Generator zurückgegebenen Wert nehmen und ausdrucken. Da der Generator Werte bei Bedarf generiert, wird bei jeder Iteration der nächste Wert generiert, sodass beim Durchlaufen des Generators nicht alle Werte auf einmal generiert werden, sondern nur bei Bedarf. In diesem Beispiel generiert der Generator während der Schleife nacheinander fünf Werte von 0, 2, 4, 6 und 8, weist diese Werte dem Variablenwert zu und druckt sie dann aus. Die Schleife endet, wenn im Generator keine Werte mehr zum Generieren vorhanden sind. Da Generatoren Werte bei Bedarf generieren, sparen sie Speicherplatz und können Daten träge generieren, indem sie Daten nur dann generieren, wenn sie benötigt werden.

Generatorbezogene Funktionen:

Die nächste Funktion ruft den nächsten Wert im Generator ab
und durchläuft jeden Wert im Generator

☆ Ertragsgenerator

Funktionen des Yield-Keyword-Generators: Yield-Keyword in der Def-Funktion enthalten

defgenerator(n):
for i inrange(n):
print('generieren starten...')
yield i
print('einmal beenden...')

g = Generator(5)
print(next(g))
print(next (g))
print(next(g))
print(next(g))
print(next(g))-----> normal
print(next(g))-----> error
Traceback (aktuellste Aufruf zuletzt):
Datei „/Users/cndws/PycharmProjects/pythonProject/demo.py“, Zeile 14, in<module>
print(next(g))
StopIteration

Dieser Code definiert eine Generatorfunktion namens Generator, deren Parameter n die Anzahl der generierten Daten darstellt. Innerhalb der Funktion wird eine for-Schleife verwendet, um n Zahlen zu generieren, und jedes Mal, wenn eine Zahl generiert wird, wird die yield-Anweisung verwendet, um die Zahl als Wert des Generators zurückzugeben, und der Generator beginnt mit der Generierung ... und wird einmal abgeschlossen ... , um zu unterscheiden, in welcher Phase die Leistung des Generators erzeugt wurde. Die yield-Anweisung unterbricht die Ausführung der Funktion und gibt den Rückgabewert als Wert des Generators zurück. Beim nächsten Aufruf der next()-Methode wird die Ausführung ab der yield-Anweisung fortgesetzt.

Rufen Sie im Programm zuerst Generator (5) auf, um einen Generator g zu erstellen, rufen Sie dann fünfmal hintereinander die Methode next (g) auf, um den nächsten Wert des Generators zu erhalten, und jedes Mal, wenn die Methode next () aufgerufen wird, wird die Der Generator generiert den nächsten Wert und gibt diesen Wert zurück. Da im Generator 5 Zahlen generiert werden müssen, können 5 Werte normal abgerufen und ausgedruckt werden. Wenn das Programm die next()-Methode zum sechsten Mal aufruft, wird eine StopIteration-Ausnahme ausgelöst, da im Generator keine weiteren Werte generiert werden müssen, was darauf hinweist, dass der Generator keine weiteren Werte zu generieren hat. Dies ist ein Standardverhalten des Generators. Wenn keine weiteren Werte generiert werden können, wird eine StopIteration-Ausnahme ausgelöst, die im Programm abgefangen und entsprechend verarbeitet werden kann.

defgenerator(n):
for i inrange(n):
print('generieren starten...')
yield i
print('einmal beenden...')

g = Generator(5)
for i in g:
print(i)

Dieser Code ähnelt dem vorherigen Code und definiert außerdem einen Generatorfunktionsgenerator zum Generieren von n Zahlen. Der Unterschied besteht darin, dass hier eine for-Schleife verwendet wird, um das Generatorobjekt g zu durchlaufen, anstatt kontinuierlich die next()-Methode aufzurufen, um den nächsten Wert des Generators zu erhalten. In der for-Schleife ruft jede Iteration automatisch die Methode next() auf, um den nächsten Wert des Generators abzurufen, weist diesen Wert der Schleifenvariablen i zu und führt dann den Codeblock im Schleifenkörper aus. In diesem Beispiel gibt es im Schleifenkörper nur eine Codezeile, die den Wert der Schleifenvariablen i ausgibt.

Operationsergebnis:

Build starten...
0
Einmal beenden...
Build starten...
1
Einmal beenden...
Build starten...
2
Einmal beenden...
Build starten...
3
Einmal beenden...
Build starten...
4
Einmal erledigt ...

Prozess endete mit Exit-Code 0

Da Generator(5) ein Generatorobjekt zurückgibt, kann es direkt in einer for-Schleife verwendet werden, um alle Werte im Generatorobjekt zu durchlaufen. In jeder Schleife generiert der Generator den nächsten Wert, weist diesen Wert der Schleifenvariablen i zu und gibt ihn aus. Da der Generator Werte bei Bedarf generiert, wird im Schleifenprozess jedes Mal, wenn ein Wert generiert wird, eine Zeile gedruckt, um mit der Generierung zu beginnen ... und einmal zu enden ..., um zu unterscheiden, in welcher Phase die Ausgabe erfolgt Der Generator wird aus erzeugt. Schließlich, nachdem die Schleife beendet ist, gibt es im Generator keine weiteren zu generierenden Werte und das Programm endet.

defgenerator(n):
for i inrange(n):
print('generieren starten...')
yield i
print('einmal beenden...')

g = Generator(5)
whileTrue:
try:
print(next(g) )
außer StopIteration:
break

Dieser Code ähnelt den beiden vorherigen Codeteilen und definiert außerdem einen Generatorfunktionsgenerator zum Generieren von n Zahlen. Der Unterschied besteht darin, dass hier eine while-Schleife und eine try...exclusive-Anweisung verwendet werden, um den nächsten Wert des Generators zu erhalten. In der while-Schleife ruft jede Schleife die Methode next() auf, um den nächsten Wert des Generators abzurufen und den Wert auszugeben. Da der Generator Werte bei Bedarf generiert, wird im Schleifenprozess jedes Mal, wenn ein Wert generiert wird, eine Zeile gedruckt, um mit der Generierung zu beginnen ... und einmal zu enden ..., um zu unterscheiden, in welcher Phase die Ausgabe erfolgt Der Generator wird aus erzeugt. Wenn der Generator in der try...exclusive-Anweisung keine weiteren Werte zum Generieren hat, löst er eine StopIteration-Ausnahme aus und verwendet dann die break-Anweisung, um die Schleife zu verlassen.

Da der Generator Werte bei Bedarf generiert, verwenden Sie die while-Schleife und die try...exclusive-Anweisung, um den nächsten Wert des Generators abzurufen, der die Ausnahme rechtzeitig abfangen und die Schleife verlassen kann, wenn keine Werte mehr vorhanden sind im Generator generiert werden, um abnormale Situationen im Programm zu vermeiden. Diese Methode ist flexibler und die Leistung des Generators kann je nach Bedarf frei gesteuert werden. Außerdem kann rechtzeitig darauf reagiert werden, wenn im Generator eine abnormale Situation auftritt.

wichtiger Punkt:

① Die Codeausführung wird bis zum Ergebnis angehalten und gibt dann das Ergebnis zurück. Wenn der Generator das nächste Mal gestartet wird, wird er an der angehaltenen Position weiter ausgeführt

② Wenn der Generator die Datengenerierung abschließt und die nächsten Daten erneut im Generator erhält, wird eine StopIteration-Ausnahme ausgelöst, die angibt, dass die Iteration gestoppt wurde

③ Die Ausnahmeoperation wird nicht innerhalb der While-Schleife behandelt und muss manuell hinzugefügt werden, um die Ausnahmeoperation zu verarbeiten

④ Die for-Schleife behandelt automatisch die Stopp-Iterationsausnahme, was bequemer zu verwenden ist und jedem empfohlen wird.

☆ Yield-Keyword und Return-Keyword

Wenn Sie Yield nicht sehr gut verstehen, können Sie Yield zunächst als Geschwister von Return betrachten. Sie werden alle in Funktionen verwendet und erfüllen die Aufgabe, ein Ergebnis zurückzugeben.

Der Unterschied zwischen den beiden ist:

Die Funktion mit return gibt alle Ergebnisse direkt zurück, das Programm wird beendet und nicht mehr ausgeführt und zerstört die lokalen Variablen.

defexample():
x =1
return x

example = example()
print(example)

Die Funktion mit yield gibt ein iterierbares Generatorobjekt zurück. Sie können die for-Schleife verwenden oder die Methode next() aufrufen, um das Generatorobjekt zu durchlaufen und das Ergebnis zu extrahieren.

defexample():
x =1
y =10
while x < y:
yield x
x +=1

example = example()
print(example)

☆ Warum den Ertragsgenerator verwenden?

import memory_profiler as mem


# nums = [1, 2, 3, 4, 5]
# print([i*i for i in nums])


nums =list(range(10000000))
print('Speicher vor Operation:', mem .memory_usage())
# list
# quadrat_nums = [n * n für n in Zahlen]
# Generator
quadrat_nums = (n * n für n in Zahlen)
print('Speicher nach Operation:', mem.memory_usage())

Dieser Code verwendet das Modul „memory_profiler“, um die Speichernutzung des Programms zu testen.

Importieren Sie zuerst das Modul „memory_profiler“ und definieren Sie dann eine Liste mit Zahlen, die 10000000 Zahlen enthält. Dann wird die Speichernutzung vor der Operation ausgegeben. Als nächstes verwenden Sie einen Generatorausdruck n * n für n in Zahlen, um eine neue Sequenz quadrat_nums zu generieren, die das Quadrat jedes Elements in Zahlen enthält. Ein Generatorausdruck ist ein Generator, dessen Syntax einem Listenverständnis ähnelt. Der Unterschied besteht darin, dass Klammern anstelle von eckigen Klammern verwendet werden, um ein Generatorobjekt anstelle einer Liste zu erstellen. Generatorausdrücke sind elementweise und werden nur bei Bedarf berechnet, anstatt alle Elemente auf einmal zu berechnen und im Speicher zu speichern.

Abschließend gibt das Programm nach der Operation die Speichernutzung aus.

Nach dem Ausführen des Codes können Sie sehen, dass sich die Speichernutzung des Programms nach dem Ausführen des Generatorausdrucks nicht wesentlich ändert. Dies liegt daran, dass Generatorausdrücke Elemente bei Bedarf generieren und nicht alle Elemente im Voraus berechnen und speichern. Im Gegensatz zur Verwendung von Listenverständnissen kann die Verwendung von Generatorausdrücken den Speicherbedarf des Programms reduzieren und gleichzeitig die Funktionalität des Programms sicherstellen.

☆ Ertrag und Fibonacci-Folge

Es gibt eine berühmte Fibonacci-Folge in der Mathematik (Fibonacci)

Anforderungen: Die erste Zahl in der Folge ist 0, die zweite Zahl ist 1 und jede weitere Zahl kann durch Addition der ersten beiden Zahlen erhalten werden:

Beispiel: 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

Jetzt verwenden wir einen Generator, um diese Fibonacci-Folge zu implementieren. Jedes Mal, wenn ein Wert genommen wird, wird ein Algorithmus verwendet, um die nächsten Daten zu generieren. Der Generator generiert nur einen Datenwert pro Aufruf, was viel Speicher sparen kann.

deffib(max):
n, a, b =0,0,1
while n <max:
yield b # 使用 yield
# print b
a, b = b, a + b
n = n +1

für n in fib(5) :
drucken n

Dieser Code verwendet eine Generatorfunktion zum Generieren der Fibonacci-Zahlen und eine for-Schleife zur Ausgabe der ersten fünf Zahlen in der Reihe.

Schauen Sie sich zunächst die Definition der Generatorfunktion fib an. Diese Funktion akzeptiert einen Parameter max, der die größte Zahl in der zu generierenden Sequenz angibt. Innerhalb der Funktion sind drei Variablen n, a und b definiert, die die Folgenummer der aktuell generierten Zahl, der vorherigen Zahl bzw. der aktuellen Zahl in der Folge darstellen. Die Anfangswerte sind jeweils 0, 0 und 1. Geben Sie dann eine Schleife ein. Jede Schleife verwendet die Yield-Anweisung, um die Zahl b im aktuellen Array zurückzugeben, und aktualisiert dann die Werte der Variablen a und b, um die nächste Zahl zu berechnen, und addiert 1 zum Wert von n. Diese Schleife wird solange ausgeführt, bis der Wert von n den Maximalwert erreicht.

Als nächstes kommt der Code, der eine for-Schleife verwendet, um die ersten fünf Zahlen in der Sequenz auszugeben. Rufen Sie zunächst mit fib(5) die Generatorfunktion fib auf, um ein Generatorobjekt abzurufen. Übergeben Sie dieses Generatorobjekt dann an die for-Schleife, und die Schleife verwendet die nächste Funktion, um nacheinander die nächste Zahl im Generator abzurufen, bis sie fünfmal wiederholt wird. Verwenden Sie in jeder Schleife die Druckfunktion, um die Zahl n im aktuellen Array auszugeben. Da die yield-Anweisung in der Generatorfunktion verwendet wird, gibt diese Schleife die ersten 5 Zahlen in der Sequenz, nämlich 1, 1, 2, 3 und 5, nacheinander aus.

Es ist zu beachten, dass diese Generatorfunktion eine Sequenz unendlich generieren kann. Wenn Sie also eine for-Schleife zur Ausgabe einer Sequenz verwenden, müssen Sie die Anzahl der Schleifen angeben oder die Schleife manuell beenden. Da diese Generatorfunktion außerdem die yield-Anweisung verwendet, wird in jeder Schleife nur eine Zahl generiert und nicht alle Zahlen im Array auf einmal, was Speicherplatz spart.

3. Tiefe und flache Kopie

☆ mehrere Konzepte

• Variable: ist ein Element einer Systemtabelle, dessen Verbindungsraum auf ein Objekt zeigt

• Objekt: Ein Speicherblock, der zum Speichern des von ihm dargestellten Werts zugewiesen wird

• Referenz: ist ein automatisch gebildeter Zeiger von einer Variablen auf ein Objekt

• Typ: gehört zum Objekt, nicht zur Variablen

• Unveränderliche Objekte: Objekte, die nach ihrer Erstellung nicht geändert werden können, einschließlich numerischer Typen, Zeichenfolgen, boolescher Typen und Tupel

(Der Wert im Speicher, auf den das Objekt zeigt, kann nicht geändert werden. Wenn Sie eine Variable ändern, entspricht dies dem Kopieren und anschließenden Ändern des ursprünglichen Werts, da der Wert, auf den sie zeigt, nicht geändert werden kann, wodurch eine neue Adresse geöffnet wird , und die Variable zeigt auf diese neue Adresse.)

• Veränderbare Objekte: Objekte, die geändert werden können, einschließlich Listen, Wörterbüchern und Sammlungen

(Der Wert im Speicher, auf den das Objekt zeigt, kann geändert werden. Nachdem die Variable (genauer gesagt eine Referenz) geändert wurde, wird der Wert, auf den sie zeigt, tatsächlich direkt geändert, es tritt kein Kopierverhalten auf und es wird keine neue Adresse geöffnet (Laienhaft ausgedrückt handelt es sich um eine direkte Änderung.) Wenn wir schreiben:

a = „Python“

Was der Python-Interpreter macht:

① Erstellen Sie die Variable a

② Erstellen Sie ein Objekt (ordnen Sie einen Speicherblock zu), um den Wert „Python“ zu speichern.

③ Verbinden Sie Variablen und Objekte über Zeiger. Die Verbindung von Variablen zu Objekten wird als Referenz (Variablenreferenzobjekt) bezeichnet.

image-20210121111247319.png

☆ Aufgabe

Aufgabe: Kopieren Sie einfach die Referenz des neuen Objekts und öffnen Sie keinen neuen Speicherplatz.

Es generiert kein unabhängiges Objekt, das allein existiert, sondern fügt lediglich eine neue Beschriftung auf den ursprünglichen Datenblock ein. Wenn also eine der Beschriftungen geändert wird, ändert sich der Datenblock und die andere Beschriftung ändert sich entsprechend.

 

☆ flache Kopie

Flache Kopie: Erstellen Sie ein neues Objekt, dessen Inhalt eine Referenz auf das Originalobjekt ist.

Der Grund, warum eine flache Kopie als flache Kopie bezeichnet wird, liegt darin, dass sie nur eine Ebene, das äußerste Objekt selbst, kopiert und die internen Elemente nur eine Kopie einer Referenz sind.

Fall 1: Aufgabe

 

Fall 2: flache Kopie eines veränderlichen Typs

 

Fall 3: flache Kopie eines unveränderlichen Typs

 

Hinweis: Durch das flache Kopieren unveränderlicher Typen wird kein neuer Speicherplatz für das kopierte Objekt geöffnet, sondern nur die Referenz dieses Objekts kopiert

Flaches Kopieren hat drei Formen: Slice-Operation, Factory-Funktion (list()), Kopierfunktion im Kopiermodul.

Zum Beispiel: lst = [1,2,[3,4]]

Slicing-Vorgang: lst1 = lst[:] oder lst1 = [jeder für jeden in lst]

Hinweis: [:] ähnelt [0:], was bedeutet, dass vom Index 0 bis zum Ende geteilt wird. Es wird eine neue Liste zurückgegeben.

Factory-Funktion: lst1 = list(lst)

Kopierfunktion: lst1 = copy.copy(lst)

In lst gibt es jedoch eine verschachtelte Liste [3,4]. Wenn wir sie ändern, ist die Situation anders.

In zwei Fällen sollte über eine flache Replikation gesprochen werden:

1) Wenn der Wert der flachen Kopie ein unveränderliches Objekt (Zeichenfolge, Tupel, numerischer Typ) ist, entspricht dies dem Fall der „Zuweisung“. Der ID-Wert des Objekts wird mit der Funktion id () abgerufen Die Speicheradresse des Objekts) und die flache Kopie entsprechen dem ursprünglichen Wert.

2) Wenn der Wert der flachen Kopie ein veränderbares Objekt (Liste, Wörterbuch, Sammlung) ist, existiert ein „nicht so unabhängiges Objekt“. Es gibt zwei Fälle:

Der erste Fall: Das kopierte Objekt enthält kein komplexes Unterobjekt, und die Änderung des Originalwerts wirkt sich nicht auf den Wert der flachen Kopie aus, und die Änderung des Werts der flachen Kopie hat keinen Einfluss auf den Originalwert. Der ID-Wert des Originalwerts unterscheidet sich vom Originalwert der flachen Kopie.

Der zweite Fall: Das kopierte Objekt enthält komplexe Unterobjekte (z. B. ist ein Unterelement in einer Liste eine Liste). Wenn das komplexe Unterobjekt nicht geändert wird, hat die Wertänderung der flachen Kopie keine Auswirkungen der ursprüngliche Wert. Eine Änderung des Werts des komplexen Unterobjekts im Originalwert wirkt sich jedoch auf den flach kopierten Wert aus.

☆ tiefe Kopie

Tiefe Kopie: Entsprechend der flachen Kopie kopiert die tiefe Kopie alle Elemente des Objekts, einschließlich mehrstufiger verschachtelter Elemente. Das Objekt, das tief kopiert wird, ist ein brandneues Objekt, das nicht mehr mit dem Originalobjekt verknüpft ist.

Daher hat eine Änderung des ursprünglich kopierten Objekts keine Auswirkungen auf das neue kopierte Objekt. Es gibt nur eine Form, die Deepcopy-Funktion im Kopiermodul.

Deep Copy vom veränderbaren Typ:

 

Tiefe Kopie des unveränderlichen Typs: Eine tiefe Kopie des unveränderlichen Typs öffnet keinen neuen Speicherplatz für das kopierte Objekt, sondern kopiert nur die Referenz dieses Objekts

☆ Fallpräsentation

Fall 1: Deep Copy für veränderbare Objekte

import copy
a=[1,2,3]

print("=====赋值=====")
b=a
print(a)
print(b)
print(id(a))
print(id(b ))

print("=====浅拷贝=====")
b=copy.copy(a)
print(a)
print(b)
print(id(a))
print(id(b))

print ("=====深拷贝=====")
b=copy.deepcopy(a)
print(a)
print(b)
print(id(a))
print(id(b))

Ergebnis:

===== Zuweisung =====
[1,2,3]
[1,2,3]
37235144
37235144
===== Flache Kopie =====
[1,2,3]
[1,2 ,3]
37235144
37191432
===== tiefe Kopie =====
[1,2,3]
[1,2,3]
37235144
37210184

Zusammenfassung:

Zuweisung: gleicher Wert, gleiche Adresse

Flache Kopie kopieren: gleiche Werte, nicht gleiche Adressen

Deepcopy Deep Copy: Wert ist gleich, Adresse ist nicht gleich

Fall 2: Tiefe und flache Kopie für veränderliche Objekte (äußere Ebene ändert Elemente)

import copy
l=[1,2,3,[4,5]]

l1=l #assignment
l2=copy.copy(l)#shallow copy
l3=copy.deepcopy(l)#deep copy
l.append(6)

print(l)
print(l1)
print(l2)
print(l3)

Ergebnis:

[1,2,3,[4,5],6]#l füge ein Element 6 hinzu
[1,2,3,[4,5],6]#l1 füge dann ein Element 6 hinzu
[1,2,3, [4,5]]#l2 bleibt unverändert
[1,2,3,[4,5]]#l3 bleibt unverändert

Fall 3: Tiefe und flache Kopie für veränderliche Objekte (innere Ebene ändert Elemente)

import copy
l=[1,2,3,[4,5]]

l1=l #assignment
l2=copy.copy(l)#shallow copy
l3=copy.deepcopy(l)#deep copy
l[3].append (6)

print(l)
print(l1)
print(l2)
print(l3)

Ergebnis:

[1,2,3,[4,5,6]]#l[3] füge ein Element 6
[1,2,3,[4,5,6]]#l1 hinzu und füge dann ein Element 6
[1,2 hinzu ,3,[4,5,6]]#l2 gefolgt vom Hinzufügen eines Elements 6
[1,2,3,[4,5]]#l3 bleibt unverändert

Zusammenfassung:

① Wenn die äußere Ebene Elemente hinzufügt, ändert sich die flache Kopie nicht mit der Originalliste; wenn die innere Ebene Elemente hinzufügt, ändert sich die flache Kopie.

② Unabhängig davon, wie sich die ursprüngliche Liste ändert, bleibt die tiefe Kopie unverändert.

③ Das ​​Zuweisungsobjekt ändert sich zusammen mit der ursprünglichen Liste.

2. Übersicht über reguläre Ausdrücke

1. Warum reguläre Ausdrücke lernen?

Im eigentlichen Entwicklungsprozess besteht häufig die Notwendigkeit, Zeichenfolgen zu finden, die bestimmte komplexe Regeln erfüllen, z. B. E-Mail-Adresse, Bildadresse, Mobiltelefonnummer usw. Zu diesem Zeitpunkt möchten Sie Zeichenfolgen finden, die bestimmten Anforderungen entsprechen oder diese erfüllen Regeln können Sie reguläre Ausdrücke verwenden

image-20210118135358176.png

Im Prozess der praktischen Anwendung kann es eine wichtige Rolle in der Textverarbeitung, Datenanalyse, Webcrawler, Datenbereinigung und anderen Bereichen spielen. Hier sind einige Gründe, reguläre Ausdrücke zu lernen:

• Textverarbeitung: Bei der Textverarbeitung müssen wir Vorgänge wie das Suchen, Ersetzen und Teilen von Text ausführen. Mithilfe regulärer Ausdrücke können wir diese Aufgaben schnell und genau erledigen. Beispielsweise können wir reguläre Ausdrücke verwenden, um nach Text zu suchen, der ein bestimmtes Wort oder eine bestimmte Phrase enthält, oder um einige Zeichen in einem Textabschnitt durch andere Zeichen zu ersetzen. 

• Datenanalyse: Bei der Datenanalyse müssen wir Vorgänge wie das Bereinigen, Extrahieren und Konvertieren von Daten ausführen. Mithilfe regulärer Ausdrücke können wir diese Aufgaben schnell und effizient erledigen. Beispielsweise können wir reguläre Ausdrücke verwenden, um Zahlen, Daten, Telefonnummern und andere Informationen aus einem Text zu extrahieren oder einige Datenformate zu konvertieren. 

• Webcrawler: In Webcrawlern müssen wir Webseiten analysieren, extrahieren, filtern und andere Vorgänge durchführen. Mithilfe regulärer Ausdrücke können wir diese Aufgaben schnell und genau erledigen. Beispielsweise können wir reguläre Ausdrücke verwenden, um Informationen wie Links, Bilder und Videos aus Webseiten zu extrahieren oder um Webseiten herauszufiltern, die bestimmte Bedingungen erfüllen. 

• Programmiersprache: In der Programmiersprache ist der reguläre Ausdruck auch ein häufig verwendetes Werkzeug, mit dem wir Zeichenfolgenabgleiche, Ersetzungen, Segmentierungen und andere Vorgänge durchführen können. In Python können wir beispielsweise das re-Modul verwenden, um reguläre Ausdrücke für die String-Manipulation zu verwenden. 

Zusammenfassend lässt sich sagen, dass das Erlernen regulärer Ausdrücke uns helfen kann, die Arbeitseffizienz in der Textverarbeitung, Datenanalyse, Webcrawler, Programmierung und anderen Bereichen zu verbessern, und es ist auch eine der notwendigen Fähigkeiten für Programmierer.

2. Was ist ein regulärer Ausdruck?

Ein regulärer Ausdruck beschreibt ein Zeichenfolgen-Übereinstimmungsmuster, mit dem überprüft werden kann, ob eine Zeichenfolge eine bestimmte Teilzeichenfolge enthält, die übereinstimmende Teilzeichenfolge ersetzt wird oder eine Teilzeichenfolge, die eine bestimmte Bedingung erfüllt, aus einer Zeichenfolgenwartezeit extrahiert werden kann.

Modus: Ein spezifischer String-Modus, der aus einigen speziellen Symbolen besteht.

Irgendwie: Es kann auch als eine Art Fuzzy-Matching verstanden werden.

Genaue Übereinstimmung: select * from blog where title='python';

Fuzzy-Matching: Wählen Sie * aus dem Blog aus, dessen Titel wie „%python%“ lautet.

Reguläre Ausdrücke gibt es nicht nur in Python. Reguläre Ausdrücke werden in Sprachen wie Java, PHP, Go und JavaScript unterstützt.

3. Funktionen regulärer Ausdrücke

① Datenüberprüfung (Formularüberprüfung, z. B. Mobiltelefon, E-Mail, IP-Adresse)

② Datenabruf (Datenabruf, Datenerfassung)

③ Ausblenden von Daten (1356235 Herr Wang)

④ Datenfilterung (forumsensible Schlüsselwortfilterung) …

3. Einführung des Re-Moduls

1. Was ist das Re-Modul?

Wenn Sie Zeichenfolgen über reguläre Ausdrücke in Python abgleichen müssen, können Sie ein re-Modul verwenden

2. Das Re-Modul verwendet drei Schritte

# Schritt 1: Import re-Modul
import re
# Schritt 2: Verwenden Sie die Match-Methode für den Matching-Vorgang
result = re.match(Muster regulärer Ausdruck, zu vergleichende Zeichenfolge, Flags=0)
# Schritt 3: Wenn die Daten erfolgreich sind Verwenden Sie die Gruppenmethode, um die Daten
result.group() zu extrahieren.

Beschreibung der Parameter der Match-Funktion:

Parameter	beschreiben
Muster	Übereinstimmung mit regulärem Ausdruck
Zeichenfolge	Die zu vergleichende Zeichenfolge.
Flaggen	Das Flag-Bit wird verwendet, um den Vergleichsmodus des regulären Ausdrucks zu steuern, z. B. ob Groß-/Kleinschreibung beachtet werden soll, mehrzeiliger Vergleich usw. Siehe: Regex-Modifikatoren – Optionale Flags

Die re.match-Methode gibt ein passendes Objekt zurück, wenn die Übereinstimmung erfolgreich ist, andernfalls gibt sie None zurück.

Wir können die Match-Objektfunktion „group(num)“ oder „groups()“ verwenden, um Match-Daten abzurufen.

Ein regulärer Ausdruck kann einige optionale Flag-Modifikatoren enthalten, um das übereinstimmende Muster zu steuern. Modifikatoren werden als optionales Flag angegeben. Mehrere Flags können durch bitweises ODER(|) angegeben werden. Wenn re.I | re.M auf die I- und M-Flags gesetzt ist:

Modifikator	beschreiben
re.I	Machen Sie bei der Übereinstimmung die Groß-/Kleinschreibung unempfindlich
re.L	Führen Sie einen Abgleich mit der Lokalisierungserkennung (Gebietsschema) durch. Diese Funktion unterstützt die mehrsprachige Version der Zeichensatzumgebung, z. B. das Escape-Zeichen \w, in der englischen Umgebung stellt es [a-zA-Z0-9_] dar. , also alle englischen Zeichen und Zahlen. Wenn es in einer französischen Umgebung verwendet wird, kann es standardmäßig nicht mit „é“ oder „ç“ übereinstimmen. Fügen Sie diese L-Option hinzu und Sie können eine Übereinstimmung erzielen. Dies scheint jedoch für die chinesische Umgebung nicht sinnvoll zu sein, es kann immer noch keine chinesischen Zeichen erkennen.
re.M	Mehrzeilige Übereinstimmung, wirkt sich auf ^ und $ aus
re.S	make . entspricht allen Zeichen, einschließlich Zeilenumbrüchen
re.U	Analysieren Sie Zeichen gemäß dem Unicode-Zeichensatz. Dieses Flag betrifft \w, \W, \b, \B.
re.X	VERBOSE, Redundanzmodus, dieser Modus ignoriert die Leerzeichen und #-Kommentare im regulären Ausdruck, z. B. das Schreiben eines regulären Ausdrucks, der mit Postfächern übereinstimmt. Mit diesem Flag können Sie reguläre Ausdrücke schreiben, die durch eine flexiblere Formatierung einfacher zu verstehen sind.

3. Verwandte Methoden des Re-Moduls

☆ re.match(Muster, String, Flags=0)

• Übereinstimmung vom Anfang der Zeichenfolge. Wenn die Übereinstimmung erfolgreich ist, wird der übereinstimmende Inhalt zurückgegeben, andernfalls wird None zurückgegeben

Parameterbeschreibung:

• Muster: Der reguläre Ausdruck, der abgeglichen werden muss.

• string: Die zu vergleichende Zeichenfolge.

• Flags: optionaler Parameter, der verwendet wird, um zu steuern, wie der reguläre Ausdruck abgeglichen wird.

Die Funktion re.match() gleicht den regulären Ausdruck vom Anfang der Zeichenfolge ab. Wenn die Übereinstimmung erfolgreich ist, gibt sie ein Match-Objekt zurück, andernfalls gibt sie None zurück. Das Match-Objekt enthält die passenden Ergebnisinformationen, die durch Aufrufen der Methode des Match-Objekts abgerufen werden können.

Es ist zu beachten, dass re.match() nur mit dem Anfang der Zeichenfolge übereinstimmt. Wenn Sie den regulären Ausdruck in der gesamten Zeichenfolge abgleichen müssen, können Sie die Funktion re.search() verwenden.

Der folgende Code zeigt beispielsweise, wie die Funktion re.match() verwendet wird, um einen regulären Ausdruck vom Anfang einer Zeichenfolge abzugleichen:

import re

string = "hello, world"
pattern = r"hello"

match_obj = re.match(pattern, string)
if match_obj:
print("Match erfolgreich")
else:
print("Match failed")

Die Ausgabe ist:

erfolgreiches Spiel

Im obigen Code verwenden wir die Funktion re.match(), um einen regulären Ausdruck vom Anfang der Zeichenfolge abzugleichen. Da der Anfang der Zeichenfolge „Hallo“ ist, ist die Übereinstimmung erfolgreich.

☆ re.findall(Muster, String, Flags=0)

Parameterbeschreibung:

• Muster: Der reguläre Ausdruck, der abgeglichen werden muss.

• string: Die zu vergleichende Zeichenfolge.

• Flags: optionaler Parameter, der verwendet wird, um zu steuern, wie der reguläre Ausdruck abgeglichen wird.

Die Funktion re.findall() durchsucht eine Zeichenfolge nach einem regulären Ausdruck und gibt alle passenden Ergebnisse zurück. Das Rückgabeergebnis ist eine Liste, und jedes Element in der Liste ist ein passendes Ergebnis.

Der folgende Code zeigt beispielsweise, wie Sie mit der Funktion re.findall() nach Zahlen in einer Zeichenfolge suchen:

import re

string ="Ich habe 2 Äpfel und 3 Orangen"
pattern =r"\d+"

result = re.findall(pattern, string)
print(result)

Die Ausgabe ist:

['2','3']

Im obigen Code verwenden wir die Funktion re.findall(), um nach Zahlen in der Zeichenfolge zu suchen. Da die Zeichenfolge die beiden Zahlen 2 und 3 enthält, wird eine Liste mit diesen beiden Zahlen zurückgegeben.

☆ re.finditer(Muster, String, Flags)

• Die Funktion ist dieselbe wie findall oben, gibt jedoch einen Iterator zurück

Parameterbeschreibung:

• Muster: Musterzeichenfolge.

• repl: Die Ersatzzeichenfolge, die auch eine Funktion sein kann.

• string: Die ursprüngliche Zeichenfolge, die gesucht und ersetzt werden soll.

• count: Die maximale Anzahl von Ersetzungen nach dem Mustervergleich. Der Standardwert 0 bedeutet, dass alle Übereinstimmungen ersetzt werden.

• Flags: Matching-Methode:

• re.I macht den Vergleich unabhängig von der Groß-/Kleinschreibung und I steht für „Ignore“, um die Groß-/Kleinschreibung zu ignorieren

• re.S sorgt dafür, dass . mit allen Zeichen, einschließlich Zeilenumbrüchen, übereinstimmt

• Der re.M-Mehrzeilenmodus wirkt sich auf ^ und $ aus

Die Funktion re.finditer() durchsucht eine Zeichenfolge nach einem regulären Ausdruck und gibt alle passenden Ergebnisse zurück. Das Rückgabeergebnis ist ein Iterator, und die übereinstimmenden Ergebnisse können einzeln über den Iterator abgerufen werden.

Der folgende Code zeigt beispielsweise, wie Sie mit der Funktion re.finditer() nach Zahlen in einer Zeichenfolge suchen:

import re

string ="Ich habe 2 Äpfel und 3 Orangen"
Muster =r"\d+"

iter_obj = re.finditer(muster, string)
für match_obj in iter_obj:
print(match_obj.group())

Die Ausgabe ist:

2
3

Im obigen Code verwenden wir die Funktion re.finditer(), um nach Zahlen in der Zeichenfolge zu suchen. Da die Zeichenfolge die beiden Zahlen 2 und 3 enthält, wird ein Iterator zurückgegeben, der diese beiden Zahlen enthält. Wir durchlaufen den Iterator durch die for-Schleife, erhalten nacheinander die übereinstimmenden Ergebnisse und drucken sie aus.

4. Schnellstart mit regulären Ausdrücken

Fall 1: Finden Sie heraus, ob eine Zeichenfolge eine Zahl „8“ enthält

import re


result = re.findall('8','13566128753')
# print(result)
if result:
print(result)
else:
print('Es wurden keine Daten abgeglichen')

Fall 2: Finden Sie heraus, ob eine Zeichenfolge Zahlen enthält

import re


result = re.findall('\d','a1b2c3d4f5')
# print(result)
if result:
print(result)
else:
print('Es wurden keine Daten abgeglichen')

Fall 3: Finden Sie heraus, ob eine Zeichenfolge eine Nichtzahl enthält

import re


result = re.findall('\D','a1b2c3d4f5')
# print(result)
if result:
print(result)
else:
print('Es wurden keine Daten abgeglichen')

4. Detaillierte Erläuterung regulärer Ausdrücke

Regelmäßiges Schreiben in drei Schritten: Was ist zu prüfen, wie viel ist zu prüfen und wo ist zu prüfen

Reguläre Ausdrücke bestehen normalerweise aus zwei Datenteilen: gewöhnlichen Zeichen und Metazeichen. Gewöhnliche Zeichen: 0123456789abcd@... Metazeichen: Symbole, die nur für reguläre Ausdrücke gelten => [0-9], ^, *, +, ?

1. Was zu überprüfen ist

der Code	Funktion
. (englischer Punkt)	Entspricht einem beliebigen Zeichen (außer \n)
[ ]	Entspricht einem der in [ ] aufgeführten Zeichen, professionelles Substantiv => Zeichencluster
[^angegebenes Zeichen]	Entspricht einem anderen Zeichen als dem angegebenen Zeichen, ^professional noun=>tobyte
\D	Passen Sie die Ziffern an, z. B. 0–9
\D	entspricht einer Nicht-Ziffer, also keiner Ziffer
\S	Entspricht Leerzeichen, z. B. Leerzeichen und Tabulatortasten
\S	Übereinstimmung nicht leer
\w	Entspricht Nicht-Sonderzeichen, z. B. az, AZ, 0-9, _
\W	Passen Sie Sonderzeichen an, d. h. keine Buchstaben, keine Ziffern, keine Unterstriche

Gemeinsames Schreiben von Zeichenclustern:

① [abcdefg] bedeutet, dass alle Zeichen in abcdefg-Zeichen übereinstimmen (1)

② [aeiou] bedeutet, dass es mit einem der fünf Zeichen a, e, i, o, u übereinstimmt

③ [az] bedeutet, dass es mit einem der 26 Zeichen zwischen az übereinstimmt

④ [AZ] bedeutet Übereinstimmung mit einem der 26 Zeichen zwischen AZ

⑤ [0-9] bedeutet, dass es mit einem der 10 Zeichen zwischen 0 und 9 übereinstimmt

⑥ [0-9a-zA-Z] bedeutet, dass jedes Zeichen zwischen 0-9, az, AZ gefunden werden kann

Die Kombination aus Zeichencluster + Spielzeugbyte stellt die Bedeutung der Inversion dar:

① [^aeiou] bedeutet, dass alle Zeichen außer a, e, i, o, u übereinstimmen

② [^az] bedeutet, dass jedes Zeichen außer az übereinstimmen soll

\d entspricht [0-9], was bedeutet, dass es mit einer beliebigen Zahl zwischen 0 und 9 übereinstimmt

\D entspricht [^0-9], was bedeutet, dass bei der Übereinstimmung mit nicht-stelligen Zeichen nur eines gefunden werden kann

2. Überprüfen Sie, wie viel

der Code	Funktion
*	Entspricht dem vorherigen Zeichen 0 Mal oder unbegrenzt oft, es kann optional sein (0 bis viele).
+	Passen Sie das vorherige Zeichen 1 Mal oder unbegrenzt oft an, d. h. mindestens 1 Mal (1 zu viele).
?	Entspricht dem vorherigen Zeichen 1 oder 0 Mal, also entweder 1 oder keines (0 oder 1).
{M}	Übereinstimmung mit dem vorherigen Zeichen m-mal, Übereinstimmung mit der Mobiltelefonnummer\d{11}
{M,}	Übereinstimmung mit dem vorherigen Zeichen mindestens m-mal, \w{3,} bedeutet, dass das vorherige Zeichen mindestens dreimal vorkommen muss und höchstens unbegrenzt oft vorkommen kann
{m,n}	Passen Sie das vorherige Zeichen m bis n-mal an, \w{6,10}, was bedeutet, dass das vorherige Zeichen 6 bis 10 Mal vorkommt

Grundlegende Syntax: Reguläre übereinstimmende Zeichen. Oder \w oder \S + folgen Sie, um zu überprüfen, wie oft, z. B. \w{6, 10}, z. B. .*, mit dem vorherigen Zeichen 0 oder öfter übereinstimmt

3. Wo überprüfen

der Code	Funktion
^	Das Spiel beginnt mit einer Zeichenfolge
$	Das Spiel endet mit einer Zeichenfolge

Erweiterung: Reguläre Toolbox

https://c.runoob.com/front-end/854/

https://c.runoob.com/front-end/7625/#!flags=&re=1[3-9]\d{9}

Crawler => xpath, spezialisiert auf Crawler

Crawler + normal

Reptil+xpath

Konzentrieren Sie sich auf das Erlernen von SQL

Fünf, mehrere wichtige Konzepte

1. Unterausdruck (auch als Gruppierung bezeichnet)

In regulären Ausdrücken wird der von einem Klammerpaar eingeschlossene Inhalt als „Unterausdruck“ bezeichnet.

re.search(r'\d(\d)(\d)','abcdef123ghijklmn')

Hinweis: Das r vor dem regulären Python-Ausdruck stellt eine Rohzeichenfolge (rawstring) dar, die angibt, dass der Inhalt in den Anführungszeichen die darstellt Die ursprüngliche Bedeutung des Inhalts, wodurch die durch mehrfache Escapezeichen verursachten Backslash-Probleme vermieden werden.

In \d\d\d im regulären Ausdruck ist (\d)(\d) ein Unterausdruck, und es gibt zwei ()-Klammern, die zwei Unterausdrücke darstellen

Hinweis: Wenn das Muster eine Gruppe enthält, gibt die Findall-Methode eine Liste zurück, die mit der Gruppe übereinstimmt. Daher ist die Findall-Methode nicht für Gruppenoperationen geeignet. Es wird empfohlen, die Suchfunktion (Match One) oder Finditer ( Übereinstimmung mit mehreren) Methoden.

2. Erfassen

Wenn der reguläre Ausdruck mit dem entsprechenden Inhalt in der Zeichenfolge übereinstimmt, fügt das Computersystem den vom Unterausdruck übereinstimmenden Inhalt automatisch in den entsprechenden Pufferbereich des Systems ein (der Pufferbereich beginnt bei $ 1).

Falldarstellung:

import re


# Passt zwei aufeinanderfolgende identische Wörter in der Zeichenfolge an
str1 ='abcdef123ghijklmn'
result = re.search(r'\d(\d)(\d)', str1)
print(result.group())
print(result. Gruppe(1))
print(Ergebnisgruppe(2))

3. Rückverweis (Rückverweis)

In regulären Ausdrücken können wir mit \n auf den Inhalt im Pufferbereich verweisen (n stellt die Nummer des n-ten Pufferbereichs dar) und wir nennen diesen Vorgang „Reverse Reference“.

① 4 aufeinanderfolgende Zahlen re.search(r'\d\d\d\d, str1)

1234、5678、6789

② 4 aufeinanderfolgende Zahlen, aber das Format der Zahlen ist 1111, 2222, 3333, 4444, 5555?

re.search(r'(\d)\1\1\1, str1)

4. Ein paar Übungsfragen

① Finden Sie vier aufeinanderfolgende Zahlen, zum Beispiel: 3569

Antwort: \d\d\d\d oder \d{4}

② Finden Sie die gleichen vier aufeinanderfolgenden Zahlen, zum Beispiel: 1111

Antwort: (\d)\1\1\1

③ Suchen Sie nach Nummern wie: 1221,3443

Antwort: (\d)(\d)\2\1 Das erste () wird in Puffer 1 platziert, wenn Sie auf \1 verweisen möchten. Das zweite () wird in Puffer 2 platziert, wenn Sie auf \2 verweisen möchten

④ Suchen Sie nach Zeichen wie: AABB,TTMM (Hinweis: AZ, regulär: [AZ])

答:([AZ])\1([AZ])\2

⑤ Finden Sie die gleichen vier aufeinanderfolgenden Zahlen oder vier Zeichen (Hinweis: \w)

答:(\w)\1\1\1 1111 aaaa bbbb

6. Andere Methoden regulärer Ausdrücke

1. Wählen Sie ein passendes Zeichen aus

|Es können mehrere Regelfälle abgeglichen werden: Übereinstimmung mit der Zeichenfolge hellojava oder hellopython

import re


str='hellojava, hellopython'
result = re.finditer(r'hello(java|python)',str)
if result:
for i in result:
print(i.group())
else:
print('not matched zu beliebigen Daten‘)

2. Gruppenalias

der Code	Funktion
(?P)	Nach Alias ​​gruppieren
(?P=Name)	Zitieren Sie die Zeichenfolge, die mit der Aliasnamensgruppe übereinstimmt

Fall: Streichholz

# 导入模块
import re

str1 ='<book></book>'
result = re.search(r'<(?P<mark>\w+)></(?P=mark)>', str1)

print( result.group())

3. Umfassender Fall

①Anforderung: Passen Sie in der Liste [„Apfel“, „Banane“, „Orange“, „Birne“] Apfel und Birne an

import re

list1 =["apple","banana","orange","pear"]
str1 =str(list1)
result = re.finditer('(apple|pear)', str1)
if result:
for i in result:
print(i.group())
else:
print('未匹配到任何数据')

② 需求：匹配出163、126、qq等邮箱

import re

email ='[email protected], [email protected], [email protected]'
result = re.finditer('\w+@(qq|126|163).com', email)
if result:
for i in result:
print(i.group())
else:
print('未匹配到任何数据')

③需求 :  匹配qq:10567这样的数据，提取出来qq文字和qq号码

import re

str1 ='qq:10567'
result = re.split(r':', str1)
if result:
print(f'{result[0]}号：{result[1]}')
else:
print('未匹配到任何数据')