T:0000
Die Syntax von Python ist einfach und ähnelt der natürlichen Sprache. Selbst unerfahrene Programmierer können schnell loslegen, was die Lernschwelle senkt.
Python bietet eine breite Palette von Standardfunktionsbibliotheken, die viele Aspekte wie Vernetzung, Datenverarbeitung und grafische Schnittstellen abdecken. Darüber hinaus macht das leistungsstarke Ökosystem von Drittanbietern wie NumPy, Pandas und TensorFlow Python zu einem vielseitigen Entwicklungstool.
Python ist eine plattformübergreifende Sprache. Unabhängig davon, ob es sich um Windows, macOS oder Linux handelt, kann dasselbe Python-Programm ausgeführt werden, was die Flexibilität der Entwicklung erheblich verbessert.
Python spielt in mehreren Bereichen wie Datenwissenschaft, künstliche Intelligenz, Webentwicklung, Automatisierungsskripting, Spieleentwicklung usw. eine wichtige Rolle und ermöglicht es Entwicklern, mehrere Anforderungen mit einer Sprache zu erfüllen.
Python hat eine große globale Community und sowohl Anfänger als auch erfahrene Entwickler können leicht Bildungsressourcen, Diskussionsgruppen und technischen Support finden.
Python bietet eine intuitive Syntax und leistungsstarke Tools, sodass Entwickler die Programmierung schneller implementieren und den Produktentwicklungszyklus verkürzen können.
Anaconda ist eine Open-Source-Python- und R-Programmierplattform, die für wissenschaftliches Rechnen entwickelt wurde, einschließlich Anwendungen wie Datenwissenschaft, maschinelles Lernen, künstliche Intelligenz und Big-Data-Analyse.
Anaconda ist für Benutzer in den folgenden Bereichen geeignet:
Die folgenden Probleme treten bei Benutzern häufig auf:
Kann im Terminal eingegeben werdenconda update condaUndconda update anaconda。
Anaconda ist eine Data-Science-Plattform, die Python, eine Programmiersprache, mit einer Vielzahl integrierter Tools und Bibliotheken integriert.
Anaconda bietet eine Funktion für virtuelle Umgebungen (Umgebung), mit der Benutzer mehrere unabhängige Python-Ausführungsumgebungen auf demselben Computer erstellen können. Jede Umgebung kann unterschiedliche Python-Versionen und -Pakete haben, um Abhängigkeitskonflikte zwischen verschiedenen Projekten zu vermeiden.
# Erstellen Sie eine Umgebung mit dem Namen myenv und geben Sie die Python-Version an
conda create -n myenv python=3.10# Umgebung starten
Conda aktiviert Myenv
#Verlassen Sie die Umgebung
Conda deaktivieren# Alle Umgebungen auflisten
Conda-Env-Liste
# oder
Conda-Info --envs# Umgebungskonfiguration in eine YAML-Datei exportieren
Conda-Env-Export > Environment.yml
# Umgebung aus YAML-Datei erstellen
conda env create -f ambient.yml# Löschen Sie die angegebene Umgebung
conda remove -n myenv --allJupyter ist eine interaktive Open-Source-Computerumgebung, die mehrere Programmiersprachen unterstützt und hauptsächlich für Datenwissenschaft, maschinelles Lernen und akademische Forschung verwendet wird.
Jupyter wird häufig in den folgenden Bereichen verwendet:
jupyter notebookStarten Sie Jupyter Notebook.Gehe zuOffizielle Website von Visual Studio Code, laden Sie die für Ihr Betriebssystem geeignete Version herunter und installieren Sie sie.
Installieren Sie in Visual Studio Code die Python-Erweiterung, indem Sie die folgenden Schritte ausführen:
Stellen Sie sicher, dass Python auf Ihrem System installiert ist. Erhältlich beiOffizielle Python-WebsiteHerunterladen und installieren.
Geben Sie nach Abschluss der Installation den folgenden Befehl in die Befehlszeile ein, um zu bestätigen, dass die Installation erfolgreich war:
Python --version
# oder
python3 --versionÖffnen Sie Ihr Python-Projekt oder Ihre Python-Datei, klicken Sie auf die Statusleiste „Python“ in der unteren rechten Ecke von Visual Studio Code und wählen Sie den entsprechenden Python-Interpreter aus.
Öffnen Sie die Python-Datei im Editor und führen Sie das Programm mit der folgenden Methode aus:
Ctrl + Shift + P, suchen Sie nach „Run Python File“ und führen Sie es aus.Wenn Sie ein Paket eines Drittanbieters installieren müssen, können Sie über das integrierte Terminal Folgendes eingeben:
Name des pip-InstallationspaketsProfitieren Sie von der automatischen Vervollständigung und leistungsstarken Debugging-Tools durch die von Python-Erweiterungen bereitgestellten Funktionen:
Hier sind einige häufig verwendete Tastenkombinationen:
Ctrl + F5Ctrl + Shift + PShift + Alt + FCtrl + `Wenn Sie beim Ausführen eines Python-Programms Parameter übergeben müssen, können Sie diese festlegenlaunch.jsonBeenden:
launch.jsonÄndern Sie relevante Einstellungen in der Datei.Das Folgende ist eine Beispielkonfiguration, einschließlich des Programmpfads und der Ausführungsparameter:
{
„Version“: „0.2.0“,
„Konfigurationen“: [
{
„name“: „Python: Mit Argumenten ausführen“,
„Typ“: „Python“,
„request“: „launch“,
„program“: „${workspaceFolder}/main.py“, // Programmpfad
„console“: „integratedTerminal“, // Terminaltyp
"args": ["arg1", "arg2", "--option", "value"] // Parameter übergeben
}
]
}existierenargsEs können Befehlszeilenparameter übergeben werden, zum Beispiel:
arg1Undarg2ist ein Positionsparameter.--optionUndvalueist ein Parameter mit Optionen.verwendensys.argvSo lesen Sie die über die Befehlszeile übergebenen Parameter:
importsys
print("Alle Parameter:", sys.argv)
wenn len(sys.argv) > 1:
print("Erster Parameter:", sys.argv[1])
print("Zweiter Parameter:", sys.argv[2])Angenommen, das Programm ist:
python main.py arg1 arg2 --option valueAusführungsergebnis:
Alle Parameter: ['main.py', 'arg1', 'arg2', '--option', 'value']
Erster Parameter: arg1
Zweiter Parameter: arg21. InstallationPython ExtensionVerlängerung.
2. Starten Sie Ihr Python-Projekt in VS Code.
3. Drücken SieF5Oder klicken Sie links auf die AktivitätsleisteDebugSymbol.
1. Klicken Sie im Debug-Panel auf „Konfiguration hinzufügen“.
2. Wählen SiePython, das System generiert automatisch einelaunch.json。
{
"version": "0.2.0",
"configurations": [
{
"name": "Python: Current File",
"type": "python",
"request": "launch",
"program": "${file}",
"console": "integratedTerminal"
}
]
}
1. Klicken Sie auf neben der Codezeilennummer, um einen Haltepunkt hinzuzufügen.
2. Bedingte Haltepunkte können verwendet werden: Klicken Sie mit der rechten Maustaste auf den Haltepunkt und wählen Sie „Bedingung bearbeiten“.
F10Skip-Funktion.F11Geben Sie die Funktion ein.Shift+F11Springen Sie aus der Funktion heraus.1. Sehen Sie sich den aktuellen Variablenstatus im Bereich „Variablen“ des Debug-Panels an.
2. Im Bereich „Monitor“ können Sie bestimmte Ausdrücke manuell hinzufügen.
1. Geben Sie Python-Befehle in die Debug-Konsole ein, um den Programmstatus in Echtzeit zu überprüfen.
2. Kann Operationen wie Variablenabfragen und Funktionsaufrufe ausführen.
Stellen Sie sicher, dass Python installiert und zu Ihren Systemumgebungsvariablen hinzugefügt ist, laden Sie dann Visual Studio Code herunter und installieren Sie es.
Öffnen Sie Visual Studio Code, klicken Sie links auf das Erweiterungssymbol und suchen SiePython, und installieren Sie dann die von Microsoft bereitgestellten Python-Erweiterungen.
Geben Sie im Terminal den folgenden Befehl ein, um den Installationspfad von Python zu bestätigen:
which pythonOder (Windows-System):
where pythonDrücken Sie in Visual Studio CodeCtrl + Shift + P, eingeben und auswählenPython: Select Interpreter。
Wählen Sie im Manifest den richtigen Python-Pfad aus. Wenn es nicht angezeigt wird, geben Sie den vollständigen Pfad manuell ein.
Öffnen Sie das Terminal und führen Sie es auspython --versionum zu bestätigen, dass die richtige Version des Python-Interpreters ausgewählt ist.
Wenn Sie den Python-Pfad eines bestimmten Projekts benötigen, können Sie ihn im Projektstammverzeichnis hinzufügen.vscode/settings.jsonDatei und fügen Sie den folgenden Inhalt hinzu:
{
„python.pythonPath“: „Ihr vollständiger Pfad zu Python“
}ersetzenIhr vollständiger Python-Pfadist der eigentliche Pfad.
Bei der Entwicklung in VS-Code entscheide ich mich für die Verwendung von Anaconda oder anderen Umgebungen, hauptsächlich aufgrund der zugrunde liegenden Interpreter-Einstellungen (Interpreter). Dadurch wird sichergestellt, dass Ihre Paketabhängigkeiten vollständig von der Programmausführungsumgebung isoliert sind.
| Umgebungstyp | Anwendbare Situationen | Hauptvorteile |
|---|---|---|
| Anaconda | Datenwissenschaft, maschinelles Lernen, Deep Learning | Es ist mit einer großen Anzahl wissenschaftlicher Computerbibliotheken vorinstalliert und verfügt über eine leistungsstarke Verwaltung der zugrunde liegenden Binärdateien (z. B. DLL). |
| Venv | Allgemeine Webentwicklung, Automatisierungsskripte | Leicht, schnell zu starten und enthält nur die für die Ausführung erforderlichen Pakete. |
Zusätzlich zur grafischen Oberfläche können Sie auch Befehle im integrierten Terminal von VS Code verwenden, um die Umgebung zu verwalten:
conda env listConda aktiviert den Umgebungsnamenconda create -n name python=3.10Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser。
sudo apt update
sudo apt install python3 python3-pip -y
python3Betreten Sie die interaktive Python-Umgebung.pip3-Installationsmodulname。
sudo apt install wget gpg -y
wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
sudo install -o root -g root -m 644 packages.microsoft.gpg /usr/share/keyrings/
sudo sh -c 'echo "deb [arch=amd64 signed-by=/usr/share/keyrings/packages.microsoft.gpg] \
https://packages.microsoft.com/repos/code stable main" > /etc/apt/sources.list.d/vscode.list'
sudo apt update
sudo apt install code -y
pip --versionName des pip-InstallationspaketsZum Beispiel:pip install requests
pip install --upgrade PaketnameZum Beispiel:pip install --upgrade requests
pip listName des pip-DeinstallationspaketsZum Beispiel:pip uninstall requests
pip list --outdatedpip-Installationspaketname==VersionsnummerZum Beispiel:pip install requests==2.26.0
pip install -r requirements.txtverwendenrequirements.txtDatei, die alle erforderlichen Paketnamen und -versionen auflistet.
pip freeze > requirements.txtDieser Befehl exportiert die Pakete und Versionen in der aktuellen Umgebung als Anforderungsarchiv.
pip cache purgeBereinigen Sie den Cache-Ordner von Pip, um Speicherplatz freizugeben.
Lösung: Überprüfen Sie, ob Python installiert wurde, und bestätigen Sie, dass das Python-Installationsverzeichnis zur Umgebungsvariablen PATH des Systems hinzugefügt wurde.
Lösung: Versuchen Sie es mit dem Hinzufügen--userParameter, zum Beispiel:pip-Installationspaketname --user
Lösung: Überprüfen Sie, ob das Netzwerk normal ist, oder versuchen Sie, eine inländische Spiegelquelle zu verwenden, zum Beispiel:pip-Installationspaketname -i https://pypi.tuna.tsinghua.edu.cn/simple
venvodervirtualenv), um Konflikte mit globalen Installationspaketen zu vermeiden.requirements.txtAbhängigkeiten zu verwalten.http-v2Verzeichnis, sodass zukünftige Installationen desselben Pakets nicht erneut heruntergeladen werden müssen.pip cache dirZeigen Sie das aktuelle Cache-Verzeichnis an.pip cache purgeLöschen Sie alle zwischengespeicherten Daten.http-v2Dies führt jedoch dazu, dass pip die Datei bei der nächsten Installation des entsprechenden Pakets erneut herunterlädt.--no-cache-dirParameter, zum Beispiel:pip install package_name --no-cache-dir。
type()Die Funktion kann den Typ des Objekts zurückgeben.
x = 10
print(type(x)) # <class 'int'>
y = "hello"
print(type(y)) # <class 'str'>
isinstance()Wird verwendet, um zu prüfen, ob eine Variable zu einem bestimmten Typ gehört, und unterstützt die Prüfung mehrerer Typen.
x = 10
print(isinstance(x, int)) # True
print(isinstance(x, str)) # False
print(isinstance(x, (int, float))) # True
type()Relativ streng, es wird nur der genaue Typ zurückgegeben.isinstance()Vererbungsbeziehungen werden berücksichtigt und werden in der Praxis häufiger verwendet.Boolean ist in Python der grundlegende Datentyp in der Programmierung, der zwei logische Zustände darstellt: Wahr oder Falsch. Es ist die Grundlage für alle bedingten Urteile und Prozesskontrollen.
TrueUndFalse。bool。a = Wahr
b = Falsch
print(type(a)) # Ausgabe: <class 'bool'>In Python,boolist eine ganze ZahlintUnterkategorien von , damit sie an numerischen Operationen teilnehmen können:
TrueNumerisch äquivalent zu 1.FalseNumerisch äquivalent zu 0.print(True + 1) # Ausgabe: 2 (1 + 1)
print(False * 5) # Ausgabe: 0 (0 * 5)Vergleichsoperatoren vergleichen zwei Werte und geben ein boolesches Ergebnis zurück.
| Operator | beschreiben | Beispiel | Ergebnis |
|---|---|---|---|
== |
gleich | 10 == 10 |
True |
!= |
nicht gleich | 5 != 10 |
True |
> |
größer als | 10 > 5 |
True |
<= |
kleiner oder gleich | 5 <= 5 |
True |
Logische Operatoren werden verwendet, um boolesche Werte oder boolesche Ausdrücke zu kombinieren oder zu ändern.
and: Logisches „und“, beide Seiten sind esTrueDas Ergebnis istTrue。or: Logisches „ODER“, beide Seiten sind vorhandenTrueDas Ergebnis istTrue。not: Logisches „nicht“, Invertieren des booleschen Werts.print(True and False) # Ausgabe: False
print(True or False) # Ausgabe: True
print(not True) # Ausgabe: FalseIn Python haben alle Objekte einen Wahrheitswert. Wenn ein Objekt zur bedingten Beurteilung verwendet wird, konvertiert Python es inTrueoderFalse：
FalseZu den (falschen) Objekten gehören:None, die Zahl 0 (0, 0.0), leere Zeichenfolge (""), leere Liste ([]), leeres Tupel (()), leeres Wörterbuch ({}) und die leere Menge (set())。True(Wahrheits-)Objekte umfassen: alle anderen Objekte außer falschen Werten (z. B. Zahlen ungleich Null, alle nicht leeren Container).if []: # Leere Listen werden als False behandelt
print("Dies wird nicht ausgeführt")
sonst:
print("Die Liste ist leer")
if "hello": # Nicht leere Zeichenfolgen werden als wahr betrachtet
print("String ist nicht leer")In Python ist ein Array eine Datenstruktur, die zum Speichern mehrerer Elemente desselben Typs verwendet wird. Obwohl Python selbst keinen integrierten Array-Typ hat, können Sie ihn verwendenlistoderarrayModule zur Erzielung ähnlicher Funktionalität.
listEs handelt sich um die in Python integrierte Datenstruktur, die viele Datentypen speichern kann, aber auch zum Simulieren von Arrays verwendet werden kann.
my_list = [1, 2, 3, 4, 5]
print(my_list[0]) # Ausgabe: 1Wenn Sie ein echtes Array benötigen (alle Elemente müssen vom gleichen Typ sein), können Sie es verwendenarrayMods.
Array importieren
my_array = array.array('i', [1, 2, 3, 4, 5])
print(my_array[0]) # Ausgabe: 1Hier,'i'Gibt an, dass die Elemente im Array ganze Zahlen sind.
Hier sind einige grundlegende Operationen:
my_array.append(6)my_array.remove(3)len(my_array)Für Situationen, in denen numerische Operationen erforderlich sind,numpyBietet eine leistungsfähigere Array-Unterstützung.
numpy als np importieren
my_numpy_array = np.array([1, 2, 3, 4, 5])
print(my_numpy_array[0]) # Ausgabe: 1NumPy-Arrays unterstützen mehrdimensionale Daten und vektorisierte Operationen und eignen sich daher ideal für die Verarbeitung großer Datenmengen.
Python bietet viele Möglichkeiten, Array-Funktionen zu implementieren.listAnwendbar auf allgemeine Situationen,arrayModule eignen sich für Situationen, in denen dieselbe Art von Elementen erforderlich istnumpyEs ist das Werkzeug der Wahl für wissenschaftliches Rechnen.
für Variablenret_value = []gibt es mehrere einfache und effiziente Möglichkeiten, um festzustellen, ob es sich in der Python-Sprache um eine leere Liste handelt. Da eine leere Liste behandelt wird alsFalseIm Folgenden sind einige häufig verwendete Beurteilungsmethoden aufgeführt.
Dies ist die beliebteste Methode, bei der der boolesche Wert einer Liste direkt überprüft wird. Wenn die Liste leer ist,notDer Operator sorgt dafür, dass seine Bedingung als wahr ausgewertet wird (True）。
ret_value = []
wenn nicht ret_value:
#Hier ausführen, wenn die Liste leer ist
print("ret_value ist eine leere Liste")
sonst:
#Hier ausführen, wenn die Liste nicht leer ist
print("ret_value ist keine leere Liste")len()FunktionPrüft, ob die Länge der Liste gleich 0 ist.
ret_value = []
wenn len(ret_value) == 0:
print("ret_value ist eine leere Liste")
sonst:
print("ret_value ist keine leere Liste")== []Weisen Sie Variablen direkt einem leeren Listenliteral zu[]Machen Sie einen Vergleich.
ret_value = []
wenn ret_value == []:
print("ret_value ist eine leere Liste")
sonst:
print("ret_value ist keine leere Liste")In Python,listEs handelt sich um eine dynamische Datenstruktur, mit der Elemente einfach hinzugefügt und entfernt werden können.
Neue Elemente können mit den folgenden Methoden hinzugefügt werden:
append(): Fügt ein Element am Ende der Liste hinzu.insert(): Fügt ein Element an der angegebenen Indexposition ein.extend(): Hängt die Elemente einer anderen Liste an eine vorhandene Liste an.# Beispiel für neues Element
meine_liste = [1, 2, 3]
my_list.append(4) # [1, 2, 3, 4]
my_list.insert(1, 10) # [1, 10, 2, 3, 4]
my_list.extend([5, 6]) # [1, 10, 2, 3, 4, 5, 6]Elemente können entfernt werden mit:
pop(): Elemente basierend auf dem Index entfernen, standardmäßig wird das letzte Element entfernt.remove(): Entfernt das erste passende Element basierend auf dem Wert.clear(): Alle Elemente aus der Liste entfernen.# Beispiel für Element entfernen
my_list = [1, 2, 3, 4, 5]
my_list.pop() # [1, 2, 3, 4]
my_list.remove(2) # [1, 3, 4]
my_list.clear() # []In Fällen, in denen Sie Elemente desselben Typs benötigen, können Sie verwendenarrayMods.
append()Undextend()Methode gilt fürarrayMods.
import array
my_array = array.array('i', [1, 2, 3])
my_array.append(4) # [1, 2, 3, 4]
my_array.extend([5, 6]) # [1, 2, 3, 4, 5, 6]
remove()Undpop()Methoden können eingesetzt werdenarrayMods.
# Beispiel für Element entfernen
my_array = array.array('i', [1, 2, 3, 4])
my_array.remove(2) # [1, 3, 4]
my_array.pop() # [1, 3]Python bietet eine Vielzahl von Methoden zum dynamischen Erhöhen und Verkleinern von Arrays.listUndarrayDie Module sind für unterschiedliche Bedürfnisse geeignet. Für funktionale Anforderungen können Sie auch die Verwendung in Betracht ziehennumpy。
In Python,list.count()Es handelt sich um ein Tool, das speziell für Statistiken verwendet wirdDie Anzahl der Vorkommen eines bestimmten ElementsVerfahren. Es ist dasselbe, als würde man die Länge der Liste ermittelnlen()Im Gegensatz dazu muss ein Parameter als Vergleichsobjekt übergeben werden.
Die Syntax istlist.count(value), die die Ganzzahl zurückgibt, wie oft der Wert in der Liste erscheint. Wenn der Wert nicht existiert, wird 0 zurückgegeben.
Früchte = ['Apfel', 'Banane', 'Apfel', 'Orange', 'Apfel']
# Zählen Sie die Anzahl der Vorkommen von „apple“
apple_count = Fruits.count('apple')
print(apple_count) # Ausgabe: 3
# Nicht vorhandene Elemente zählen
Grape_count = Fruits.count('Grape')
print(grape_count) # Ausgabe: 0Abhängig von Ihren Anforderungen (ob Sie ein einzelnes Element, mehrere Elemente oder alle Statistiken suchen) gibt es unterschiedliche Best Practices:
| brauchen | Empfohlene Methode | Beispielcode |
|---|---|---|
| Zählen Sie ein einzelnes spezifisches Element | list.count() |
arr.count(10) |
| Ermitteln Sie die Gesamtlänge der Liste | len() |
len(arr) |
| Zählen Sie die Häufigkeit aller Elemente | collections.Counter |
Counter(arr) |
| Bedingungsanzahl (wenn größer als 5) | Generatorausdruck | sum(1 for x in arr if x > 5) |
Wenn Sie wissen möchten, wie oft „alle Elemente“ gleichzeitig in der Liste erscheinen, verwenden SieCounterWird viele Male laufencount()Viel effizienter (O(n) vs. O(n^2)).
aus Sammlungen importieren Counter
Daten = [1, 2, 2, 3, 3, 3, 4]
counts = Zähler(Daten)
print(counts) # Ausgabe: Counter({3: 3, 2: 2, 1: 1, 4: 1})
print(counts[3]) # Ermitteln Sie die Häufigkeit 3: 3
print(counts.most_common(1)) # Holen Sie sich das Element mit den meisten Vorkommenif x in listVergleichenif list.count(x) > 0Viel schneller, weilinEs stoppt, sobald es den ersten findet.count()Es wird nur ein „flacher Vergleich“ durchgeführt. Wenn die Liste eine andere Liste enthält, zählt sie nicht zur Unterliste.list.count()Dies wird zu einem starken Leistungsabfall führen, weshalb diesem Vorrang Vorrang eingeräumt werden sollteCounter。Wenn Sie die Anzahl der Elemente zählen möchten, die einer bestimmten Logik entsprechen (z. B. eine Zeichenfolge mit einer Länge von mehr als 3), können Sie kombinierensum()：
Wörter = ['hi', 'hello', 'python', 'a', 'code']
# Zählen Sie die Anzahl der Wörter mit einer Länge > 3
big_word_count = sum(1 für w in Worten, wenn len(w) > 3)
print(big_word_count) # Ausgabe: 3[key, value]。list1 = [
["a", 1],
["b", 2],
["c", 3]
]
list2 = [
["c", 30],
["a", 10],
["d", 40]
]
#Liste1 in Diktat umwandeln
dict1 = {k: v für k, v in list1}
dict2 = {k: v für k, v in list2}
# Alle Schlüssel finden
all_keys = sortiert(set(dict1.keys()) | set(dict2.keys()))
# Ergebnisse zusammenführen
zusammengeführt = []
für k in all_keys:
v1 = dict1.get(k)
v2 = dict2.get(k)
merged.append([k, v1, v2])
für Zeile in zusammengeführt:
drucken(Zeile)
['a', 1, 10]
['b', 2, None]
['c', 3, 30]
['d', None, 40]
Nonefüllen.[key, value1, value2]。Wenn Sie in Python zwei Listen haben (z. B.selected_fields_listUndaSqlValuesStr_list) und müssen gleichzeitig über sie iterieren. Die gebräuchlichste und pythonische Methode ist die Verwendung der integriertenzip()Funktion.
zip()Die Funktion packt mehrere iterierbare Objekte (Iterable) in eine Folge von Tupeln. Bei jeder Iteration der Schleife wird das Element an der entsprechenden Position aus jeder Liste entfernt.
Import bzgl
# Angenommen, dies sind die beiden Listen, die Sie nach re.split() erhalten
selected_fields = "Name, Alter, Stadt"
aSqlValuesStr = "Alice,25,Taipei"
selected_fields_list = re.split(r',', selected_fields)
aSqlValuesStr_list = re.split(r',', aSqlValuesStr)
# For-Schleife ausführen
für Feld, Wert in zip(selected_fields_list, aSqlValuesStr_list):
print(f"Feld: {field}, Wert: {value}")Feld: Name, Wert: Alice
Feld: Alter, Wert: 25
Feld: Stadt, Wert: TaipeiWenn Sie verwendenzip()Bei der Verwendung von Funktionen müssen Sie auf folgende Punkte achten:
zip()Die Iteration wird mit der kürzesten Liste beendet. Wennselected_fields_listhat 3 Elemente undaSqlValuesStr_listBei 4 Elementen wird die Schleife nur dreimal ausgeführt.itertools.zip_longest。#Beispiel: Listenlängen sind inkonsistent
list1 = [1, 2, 3]
list2 = ['a', 'b']
für Artikel1, Artikel2 in zip(list1, list2):
print(item1, item2)
#Die Ausgabe wird nur sein:
# 1a
#2bDaten = [
[1, 23, 456],
[7890, 12, 3],
[45, 678, 9]
]
# Berechnen Sie die maximale Breite jeder Spalte
col_widths = [max(len(str(row[i])) for row in data) for i in range(len(data[0]))]
# Ausgabe formatieren
für Zeile in Daten:
print(" ".join(str(val).rjust(col_widths[i]) for i, val in enumerate(row)))
1 23 456
7890 12 3
45 678 9
Pakete von DrittanbieterntabulateAusgerichtete Tabellen können direkt ausgegeben werden.
from tabulate import tabulate
data = [
[1, 23, 456],
[7890, 12, 3],
[45, 678, 9]
]
print(tabulate(data, tablefmt="grid"))
+------+-----+-----+
| 1 | 23 | 456 |
| 7890 | 12 | 3 |
| 45 | 678 | 9 |
+------+-----+-----+
rjust()Ausrichtung.tabulateErstellen Sie schnell schöne Tabellen.Das folgende Beispiel zeigt, wie eine zweidimensionale Liste gedruckt wird. Wenn das Element istfloatDie Anzeige von zwei Dezimalstellen wurde korrigiert. Andere Elemente werden unverändert ausgegeben, wobei die Feldausrichtung beibehalten wird.
Daten = [
[1, 23.456, 456],
[7890.1, 12, 3.5],
[45, 678,9, 9]
]
# Formatieren Sie jede Elementzeichenfolge
formatted_data = []
für Zeile in Daten:
new_row = []
für val in Zeile:
if isinstance(val, float):
s = f"{val:.2f}" # float -> zwei Dezimalstellen
sonst:
s = str(val)
new_row.append(s)
formatted_data.append(new_row)
# Berechnen Sie die maximale Breite jeder Spalte
col_widths = [max(len(row[i]) for row in formatted_data) for i in range(len(formatted_data[0]))]
# Ausgabe formatieren
für Zeile in formatted_data:
print(" ".join(val.rjust(col_widths[i]) for i, val in enumerate(row)))
1 23.46 456
7890.10 12 3.50
45 678.90 9
isinstance(val, float)Gleitkommazahlen ermitteln.f"{val:.2f}"Formatieren Sie eine Gleitkommazahl auf zwei Dezimalstellen.Die von Ihnen bereitgestellte Datenstruktur ist eine Liste mit mehreren Wörterbüchern, wobei jedes Wörterbuch einen Zeitreihendatensatz darstellt (z. B. K-Linien-Daten).
data = [
{'time': 1759028400000, 'open': '109398.3', 'close': '109364.8', 'high': '109489.2', 'low': '109364.8', 'volume': '518.7594'},
{'time': 1759024800000, 'open': '109305.6', 'close': '109398.3', 'high': '109496.4', 'low': '109296.0', 'volume': '757.0290'},
# ...
]Wenn Sie alle Werte in allen Datensätzen erhalten möchten (1759028400000, '109398.3', '109364.8'usw.) und sammeln Sie sie in einer Liste. Sie können Nested List Comprehension verwenden.
Verwenden Sie ein zweistufiges Listenverständnis, um jedes Wörterbuch in der Liste zu durchlaufen und dann aufzurufen.values()Die Methode ruft die Werte ab und sammelt schließlich alle Werte in einer flachen Liste.
Daten = [
{'time': 1759028400000, 'open': '109398.3', 'close': '109364.8', 'high': '109489.2', 'low': '109364.8', 'volume': '518.7594'},
{'time': 1759024800000, 'open': '109305.6', 'close': '109398.3', 'high': '109496.4', 'low': '109296.0', 'volume': '757.0290'}
]
all_values = [
Wert
für Datensatz in Daten # Durchlaufen Sie jeden Wörterbuchdatensatz in der externen Liste
for value in record.values() # Alle Werte im Wörterbuchdatensatz durchlaufen
]
print(all_values)Dies führt zu einer einzelnen Liste mit allen Werten:
[1759028400000, '109398.3', '109364.8', '109489.2', '109364.8', '518.7594', 1759024800000, '109305.6', '109398.3', '109496.4', '109296.0', '757.0290']Wenn Sie nur bestimmte Felder extrahieren müssen (z. B. nur alleopenPreis), können Sie ein einstufiges Listenverständnis verwenden:
data = [
{'time': 1759028400000, 'open': '109398.3', ...},
{'time': 1759024800000, 'open': '109305.6', ...}
]
open_prices = [record['open'] for record in data]
print(open_prices)Ausgabeergebnis:
['109398.3', '109305.6']Listenverständnisse sind eine prägnante, einzeilige Syntax zum Erstellen neuer Listen aus vorhandenen Listen.
from datetime import datetime
data_list = [
{'videoid': 'b5HxsaM_E2Y', 'publishedat': datetime(2025, 12, 7, 3, 0, 53), 'rankno': 7, 'viewcount': 913053, 'query': 'baseball'},
{'videoid': 'FEbMCBxsoWI', 'publishedat': datetime(2025, 11, 25, 5, 28, 6), 'rankno': 13, 'viewcount': 754598, 'query': 'baseball'},
{'videoid': 'nOJUI0PGB68', 'publishedat': datetime(2025, 12, 7, 3, 7, 46), 'rankno': 14, 'viewcount': 748349, 'query': 'baseball'},
{'videoid': 'uMHXIudw_w0', 'publishedat': datetime(2025, 12, 2, 10, 1, 38), 'rankno': 8, 'viewcount': 687949, 'query': 'baseball'}
]
target_key = 'videoid'
# Verwenden Sie das Listenverständnis: Nehmen Sie für jedes Wörterbuchelement in der Datenliste das Element [Zielschlüssel] heraus.
video_ids = [item[target_key] für Element in data_list]
print(f"Extrahierter Schlüssel: {target_key}")
print("Alle Video-ID-Werte:")
print(video_ids)['b5HxsaM_E2Y', 'FEbMCBxsoWI', 'nOJUI0PGB68', 'uMHXIudw_w0']Wenn einigen Wörterbüchern in der Liste möglicherweise der Zielschlüssel fehlt (z. B. einige Wörterbücher haben nicht den Schlüssel „videoid“), führt die direkte Verwendung von „item[target_key]“ zu einem „KeyError“-Fehler. Sie können die Methode „.get()“ des Wörterbuchs oder eine Bedingung verwenden, um sicher damit umzugehen.
data_with_missing_key = [
{'videoid': 'A1', 'query': 'football'},
{'query': 'basketball'}, # Fehlender 'videoid'-Schlüssel
{'videoid': 'C3', 'query': 'Volleyball'}
]
target_key = 'videoid'
# Option A: Verwenden Sie .get(), um den Standardwert auf None (oder einen anderen Wert) zu setzen.
safe_video_ids_A = [item.get(target_key) für Element in data_with_missing_key]
# Ausgabe: ['A1', Keine, 'C3']
# Option B: Nur Werte mit diesem Schlüssel extrahieren
safe_video_ids_B = [item[target_key] für Element in data_with_missing_key, wenn target_key in Element]
# Ausgabe: ['A1', 'C3']
print(f"\nSichere Extraktionsergebnisse (Plan B): {safe_video_ids_B}")Sie ausonesymbollist.values()Das erhaltene Ergebnis ist ein Python-Wörterbuchansichtsobjektdict_values. Obwohl es wie eine Liste aussieht, handelt es sich um eine dynamische Ansicht und nicht um eine Standardliste, die indiziert oder geändert werden kann.
dict_values([1763510400000, '0.00015218', '0.00015336', '0.00015415', '0.00015067', '1634523'])Nicht anzeigendict_values()Um den Inhalt eines Tags abzurufen, ist die Verwendung des integrierten Tags die einfachste und gebräuchlichste Methodelist()Die Funktion wandelt es in eine Liste um.
Willedict_valuesweitergegebenlist()Funktion, die alle Elemente im Ansichtsobjekt sofort in eine neue Standardliste kopiert.
# Angenommen, dies ist das dict_values-Ansichtsobjekt, das Sie erhalten haben
dict_values_object = your_dictionary.values() # Angenommen, onesymbollist ist ein Wörterbuch
# Schritt: Verwenden Sie zum Konvertieren die Funktion list()
result_list = list(dict_values_object)
print(result_list)[1763510400000, '0.00015218', '0.00015336', '0.00015415', '0.00015067', '1634523']Wenn Ihr Ziel darin besteht, eine unveränderliche Sequenz zu erstellen, können Sie Folgendes verwendentuple()Die Funktion wandelt es in ein Tupel um.
result_tuple = tuple(dict_values_object)
print(result_tuple)(1763510400000, '0.00015218', '0.00015336', '0.00015415', '0.00015067', '1634523')Beachten Sie, dass Sie die Werte nicht explizit in eine Liste konvertieren müssen, wenn Sie die Werte nur einzeln in einer Schleife verarbeiten möchten.dict_valuesSelbst ist ein iterierbares Objekt (Iterable).
# Angenommen, dies ist das dict_values-Ansichtsobjekt, das Sie erhalten haben
dict_values_object = your_dictionary.values()
print("Elemente einzeln ausgeben:")
für Wert in dict_values_object:
print(Wert)Zusammenfassend: Verwendunglist(your_dict.values())ist die gebräuchlichste Methode, um eine saubere, umsetzbare Werteliste zu erhalten.
beginnendict_valuesExtrahiert alle Werte aus dem Ansichtsobjekt und kombiniert sie in einer einzigen Zeichenfolge, die nur durch Kommas und Leerzeichen getrennt ist (zum Beispiel:1763510400000, '0.00015218', ...), müssen Sie die folgenden Schritte kombinieren:
dict_valuesObjekt ansehen.", ".join()Methode zum Verketten dieser Zeichenfolgen.Angenommen, Ihr ursprüngliches Wörterbuch trägt einen Namenonesymbol_dict, und Sie müssen Nicht-String-Werte (z. B. Zeitstempel) in zu verwendende Strings konvertieren.join()Stellen Sie eine Verbindung her.
onesymbol_dict = {
'Zeit': 1763510400000,
'offen': '0.00015218',
'schließen': '0.00015336',
'hoch': '0,00015415',
'niedrig': '0,00015067',
'Volume': '1634523'
}
# Schritt 1 & 2: Werte abrufen und alle Werte in Zeichenfolgen konvertieren
# Verwenden Sie Listenverständnisse, um sicherzustellen, dass alle Elemente Zeichenfolgen sind
Values_as_strings = [str(v) für v in onesymbol_dict.values()]
# Schritt 3: Verwenden Sie ', '.join(), um diese Zeichenfolgen zu verbinden
value_string = ", ".join(values_as_strings)
print(values_string)Dadurch wird eine einzelne Zeichenfolge erzeugt, deren Inhalt nur der Wert ist, ohne äußere Klammern oderdict_valuesEtikett:
1763510400000, 0.00015218, 0.00015336, 0.00015415, 0.00015067, 1634523Beachten Sie, dass in der erwarteten Beispielausgabe andere Werte als Zeitstempel in einfache Anführungszeichen gesetzt sind:1763510400000, '0.00015218', ...。
Wenn Ihr Ziel darin besteht, dass Zeichenfolgenwerte in der endgültigen Ausgabe einfache Anführungszeichen behalten, müssen Sie während der Verkettung manuell Anführungszeichen hinzufügen. Dies ist normalerweise erforderlich, wenn Zeichenfolgen für SQL-Anweisungen oder bestimmte Formate vorbereitet werden.
# Zusätzlicher Schritt: Behandeln Sie Anführungszeichen manuell, vorausgesetzt, nicht ganzzahlige Werte erfordern Anführungszeichen
quoted_values = []
für v in onesymbol_dict.values():
wenn isinstance(v, (str, float)) oder (isinstance(v, int) und v< 1000000000000): # 假設小數字串需要引號
quoted_values.append(f"'{v}'")
else:
quoted_values.append(str(v))
final_quoted_string = ", ".join(quoted_values)
print(final_quoted_string)Dadurch erhalten Sie das Format, das Sie erwarten (vorausgesetzttimeEs sind keine Anführungszeichen erforderlich, bei anderen numerischen Zeichenfolgen ist dies der Fall):
1763510400000, '0.00015218', '0.00015336', '0.00015415', '0.00015067', '1634523'isdigit()Mit dieser Methode kann überprüft werden, ob eine Zeichenfolge nur numerische Zeichen enthält.
# Beispiel
string = "12345"
if string.isdigit():
print("ist eine Zahl")
sonst:
print("Keine Zahl")Beachten:isdigit()Dezimalpunkte oder negative Vorzeichen können nicht verarbeitet werden.
Wenn Sie eine Zeichenfolge mit einem Dezimalpunkt überprüfen müssen, können Sie den Dezimalpunkt vor der Verwendung entfernenisdigit()。
# Beispiel
string = "123,45"
if string.replace(".", "").isdigit():
print("ist eine Zahl")
sonst:
print("Keine Zahl")Diese Methode funktioniert nicht mit negativen Zahlen.
Der gebräuchlichste Ansatz besteht darin, zu versuchen, die Zeichenfolge in eine Gleitkommazahl oder Ganzzahl umzuwandeln und eine Ausnahme abzufangen, wenn die Konvertierung fehlschlägt.
# Beispiel
string = "-123,45"
Versuchen Sie:
float(string) # Sie können stattdessen int(string) verwenden, um nach Ganzzahlen zu suchen
print("ist eine Zahl")
außer ValueError:
print("Keine Zahl")Reguläre Ausdrücke können Zahlen genau abgleichen, einschließlich Ganzzahlen, Dezimalzahlen und negative Zahlen.
# Beispiel
Import bzgl
string = "-123,45"
Muster = r"^-?\d+(\.\d+)?$"
if re.match(pattern, string):
print("ist eine Zahl")
sonst:
print("Keine Zahl")Für einfache Fälle verwenden Sieisdigit(). Für komplexere Fälle (z. B. Umgang mit Dezimalzahlen oder negativen Zahlen) wird die Verwendung empfohlentry-exceptoder regulärer Ausdruck.
f-string (formatiertes String-Literal) ist eine leistungsstarke und effiziente String-Formatierungsmethode, die in Python 3.6 eingeführt wurde. Es bietet eine prägnante und gut lesbare Möglichkeit, die Werte von Variablen und Ausdrücken in Zeichenfolgen einzubetten.
Das Kernmerkmal von F-String ist die Verwendung von Präfixen am Anfang des StringsfoderF, und verwenden Sie geschweifte Klammern{}enthalten, was berechnet und angezeigt werden soll.
Sie können jeden Variablennamen direkt in geschweifte Klammern einfügen.
Name = „Alice“
Alter=30
message = f „Hallo, mein Name ist {name} und ich bin {age} Jahre alt.“
# Ausgabe: Hallo, mein Name ist Alice und ich bin 30 Jahre alt.Die Stärke von f-string besteht darin, dass Sie jeden gültigen Python-Ausdruck in die geschweiften Klammern einfügen können und dieser zur Laufzeit ausgewertet wird.
Preis = 19,99
Steuersatz = 0,05
Gesamt = Preis * (1 + Steuersatz)
# Berechnungen innerhalb des F-Strings durchführen
result = f „Der Gesamtpreis inklusive Steuern beträgt: {price * (1 + tax_rate):.2f} Yuan.“
# Ausgabe: Der Gesamtpreis inklusive Steuern beträgt: 20,99 Yuan.
# Funktion aufrufen
def get_status():
„OK“ zurückgeben
status_msg = f"Systemstatus: {get_status()}"
# Ausgabe: Systemstatus: OKF-Saite unterstützt und.format()Gleiche Methode wie Format Specifier Mini-Language, mit Doppelpunkt:um Ausdrücke und Formatbezeichner zu trennen.
| Formatcode | verwenden | Beispiel | Ausgabe |
|---|---|---|---|
:.2f |
Gleitkommazahl mit zwei Nachkommastellen | f"{3.14159:.2f}" |
3.14 |
: <10 |
Linksbündig, Breite 10 | f"{'Name':<10}" |
Name |
: >10 |
Rechts ausrichten, Breite 10 | f"{'Value':>10}" |
Value |
:^10 |
Mittig ausgerichtet, Breite 10 | f"{'Hi':^10}" |
Hi |
:, |
Numerisches Tausendertrennzeichen | f"{1000000:,}" |
1,000,000 |
Ab Python 3.8 führt f-string eine praktische Debugging-Funktion ein, mit der Sie nach der Variablen ein Gleichheitszeichen hinzufügen können.=, zeigt automatisch Variablennamen und ihre Werte an.
user_id = 42
is_active = True
debug_output = f „Benutzer-ID ist {user_id=}, Status: {is_active=}“
# Ausgabe: Benutzer-ID ist user_id=42, Status: is_active=True'...', können Sie darin doppelte Anführungszeichen verwenden"...",umgekehrt.{{}}。\Es darf nicht zur Darstellung von Zeichenfolgenformaten verwendet werden, zf"{{'\n'}}"wird Fehler verursachen.Klammern in F-Saite{}Intern können Sie direkt verwendenint()Die Funktion konvertiert die Variable zurück in einen Integer-Typ. Dies ist die klarste und direkteste Methode.
inta = 12 # unter der Annahme einer rohen Ganzzahl
float_a = inta * 2.0 # Das Ergebnis ist 24,0 (Gleitkommazahl)
# Konvertieren Sie eine Gleitkommazahl direkt im F-String zurück in eine Ganzzahl
result_str = f"abc def {int(float_a)}"
print(f"Ursprünglicher Wert (float_a): {float_a}")
print(f"Formatiertes Ergebnis: {result_str}")Sie können die ganzzahligen Formatcodes aus der Formatierungs-Minisprache verwendendoder.0fum das Ausgabeformat zu steuern.
:dverwenden:dPython wird aufgefordert, den Wert bei der Anzeige als Ganzzahl zu behandeln. wenn variabelaeine Gleitkommazahl ist, rundet Python sie vor der Anzeige automatisch auf die nächste Ganzzahl (wenn Ihre Berechnung 24,0 $ ergibt, werden 24 $ angezeigt).
float_a = 24,0
result_d = f"abc def {float_a:d}"
# Ausgabe: abc def 24:.0fverwenden:.0fbedeutet, den Wert als Gleitkommazahl zu formatieren, erfordert aber 0 Nachkommastellen. Dies führt auch dazu, dass die Ergebnisse vor der Anzeige gerundet werden.
float_a = 24,0
result_0f = f"abc def {float_a:.0f}"
# Ausgabe: abc def 24Wenn Sie sicherstellen möchten, dass das Ergebnis eine absolute Ganzzahl ohne Dezimalpunkt ist, wird die Verwendung von Option 1 empfohlen:
str = f"abc def {int(a)}"In Python,re.split()Die Funktion istreEin leistungsstarkes Tool im Modul (reguläre Ausdrücke), mit dem Zeichenfolgen gemäß den in regulären Ausdrücken definierten Trennzeichen (Mustern) aufgeteilt und die Ergebnisse als Liste (Liste) zurückgegeben werden.
re.split(pattern, string, maxsplit=0, flags=0)pattern: Reguläres Ausdrucksmuster, das zum Teilen von Zeichenfolgen verwendet wird.string: Die zu schneidende Zielzeichenfolge.maxsplit(Optional): Geben Sie die maximale Anzahl der Schnitte an. Der Standardwert 0 bedeutet, dass die Anzahl der Schnitte nicht begrenzt ist.flags(optional): Flags, die das Verhalten regulärer Ausdrücke steuern (z. B.re.IGNORECASE）。Verwenden Sie reguläre Ausdrücke, um mehrere oder komplexe Trennzeichen zu definieren.
Import bzgl
text = "Apfel, Banane; Orange-Traube"
# Verwenden Sie als Trennzeichen Komma, Semikolon oder Bindestrich
result = re.split(r'[;,-]', text)
drucken(Ergebnis)
# Ausgabe: ['Apfel', 'Banane', 'Orange', 'Traube']mit Standardsaitensplit()anders,re.split()Mehrere aufeinanderfolgende Trennzeichen (z. B. mehrere Leerzeichen) können problemlos gehandhabt und ignoriert werden.
text = „Wort1 Wort2 Wort3“
# Verwenden Sie \s+, um ein oder mehrere Leerzeichen als Trennzeichen zu finden
result = re.split(r'\s+', text)
drucken(Ergebnis)
# Ausgabe: ['Wort1', 'Wort2', 'Wort3']Wenn festgelegtmaxsplit, wird der Schneidvorgang nur eine bestimmte Anzahl von Malen ausgeführt und die restlichen Teile bleiben als letztes Element in der Liste erhalten.
text = "eins:zwei:drei:vier"
# Nur einmal schneiden
result = re.split(r':', text, maxsplit=1)
drucken(Ergebnis)
# Ausgabe: ['eins', 'zwei:drei:vier']Wenn Sie das Trennzeichenmuster innerhalb der Klammern platzieren(), wird auch das Trennzeichen selbst zwischen den Elementen der Ergebnisliste eingefügt.
text = „15.01.2025“
# Setzen Sie Bindestriche in Klammern, damit sie erhalten bleiben
result = re.split(r'(-)', text)
drucken(Ergebnis)
# Ausgabe: ['2025', '-', '01', '-', '15']
startswith()ist ein Python-String (str)-Objektmethode, mit der bestimmt wird, ob die Zeichenfolge mit der angegebenen Teilzeichenfolge beginnt.
Wenn es übereinstimmt, kehren Sie zurückTrue; Ansonsten zurückFalse。
str.startswith(prefix[, start[, end]])
prefix: Die zu vergleichende Startzeichenfolge kann eine einzelne Zeichenfolge oder ein Tupel von Zeichenfolgen sein.start(Optional): Geben Sie an, ab welcher Indexposition der ursprünglichen Zeichenfolge mit der Beurteilung begonnen werden soll.end(Optional): Geben Sie die Indexposition an (ohne Ende).Boolescher Wert: Wenn die Zeichenfolge mit dem angegebenen Präfix beginnt, wird zurückgegebenTrue,ansonstenFalse。
text = „Python-Programmierung“
#Grundlegende Verwendung
print(text.startswith("Py")) # True
print(text.startswith("Java")) # False
#Bereich angeben
print(text.startswith("thon", 2)) # True (beginnend bei Index 2 ist „thon“)
# mehrere Ausrichtungen
print(text.startswith(("Py", "Java", "C"))) # True, weil jede Übereinstimmung
# Groß- und Kleinschreibung wird nicht beachtet (kann zuerst in Kleinbuchstaben umgewandelt werden)
print(text.lower().startswith("py")) # Trueurl = „https://openai.com“
wenn url.startswith("https://"):
print("Sichere Verbindungs-URL")
files = ["data1.csv", "data2.csv", "readme.txt"]
csv_files = [f for f in files if f.startswith("data")]
print(csv_files) # ['data1.csv', 'data2.csv']
Um festzustellen, ob eine Zeichenfolge mit einem bestimmten Text „endet“, können Sie verwendenendswith()Methoden, Syntax undstartswith()Dasselbe.
Dateiname = „Bericht.pdf“
if filename.endswith(".pdf"):
print("Dies ist eine PDF-Datei")In Python sind Strings unveränderliche Objekte. Um das letzte Zeichen zu entfernen, wird normalerweise String-Slicing verwendet, um eine neue Zeichenfolge zu erstellen.
text = "Hallo!"
#Methode 1: Schneiden verwenden
new_text = text[:-1]
print(new_text) #Ausgabe: Hallo
#Methode 2: Verwenden Sie rstrip(), um bestimmte Endzeichen zu entfernen
text2 = „Hallo!!!“
new_text2 = text2.rstrip("!")
print(new_text2) #Ausgabe: Hallo
#Methode 3: Stellen Sie sicher, dass es nicht leer ist, und löschen Sie dann das letzte Zeichen
wenn Text:
text = text[:-1]
drucken(Text)
Hello
Hello
Hello
text[:-1]Der Teilstring vom Anfang bis zum vorletzten Zeichen wird herausgenommen.rstrip(chars)Die angegebenen Zeichen am Ende (nicht auf eines beschränkt) können entfernt werden.Um die führenden Zeichen zu entfernen, verwenden Sie:
text = text[1:]
s[:-1]。rstrip()。Gegeben eine Zeichenfolgestr1, wir hoffen, darin zu findenstrAoderstrBDer Teil, der vorher kommt. Zum Beispiel:
str1 = "Hello World, this is a test. Stop here or continue."
strA = "Stop"
strB = "continue"
Das Ziel ist zu erhalten"Hello World, this is a test. "。
re.split()Sie können eine Zeichenfolge basierend auf mehreren Schlüsselwörtern aufteilen und den ersten Teil nehmen:
import re
def get_substring_before(text, strA, strB):
result = re.split(f"{re.escape(strA)}|{re.escape(strB)}", text, maxsplit=1)[0]
return result
str1 = "Hello World, this is a test. Stop here or continue."
strA = "Stop"
strB = "continue"
print(get_substring_before(str1, strA, strB)) # "Hello World, this is a test. "
re.search()kann passend verwendet werdenstrAoderstrB, und holen Sie sich den Inhalt vor dem Abgleich:
import re
def get_substring_before(text, strA, strB):
match = re.search(f"{re.escape(strA)}|{re.escape(strB)}", text)
return text[:match.start()] if match else text
str1 = "Hello World, this is a test. Stop here or continue."
print(get_substring_before(str1, "Stop", "continue")) # "Hello World, this is a test. "
find()Sie können manuell nach dem frühesten suchenstrAoderstrB, und rufen Sie dann den entsprechenden Teil ab:
def get_substring_before(text, strA, strB):
indexA = text.find(strA)
indexB = text.find(strB)
indices = [i for i in [indexA, indexB] if i != -1]
first_index = min(indices, default=len(text))
return text[:first_index]
str1 = "Hello World, this is a test. Stop here or continue."
print(get_substring_before(str1, "Stop", "continue")) # "Hello World, this is a test. "
re.split()Die einfachste, geeignet für die Einzelsuche.re.search()Bieten Sie ein flexibleres reguläres Matching.find()Die Methode ist die effizienteste und eignet sich für die einfache String-Verarbeitung.Werte = ["str1", "str2", 123, "str3", 456]
s = ", ".join(str(v) für v in Werten)
print(s) # Ausgabe: str1, str2, 123, str3, 456def join_values(*args, sep=", "):
return sep.join(str(v) for v in args)
print(join_values("str1", "str2", 88, "str3"))
# Ausgabe: str1, str2, 88, str3Daten = {
„str1“: „Hallo“,
„str2“: „Welt“,
"int1": 123,
„str3“: „ok“
}
# Nach Schlüssel sortieren und dann beitreten
s = ", ".join(str(data[k]) for k in sorted(data.keys()))
print(s) # Hallo, Welt, 123, oks = ", ".join(f"{k}={v}" für k, v in data.items())
Druck(e)
# Ausgabe: str1=hello, str2=world, int1=123, str3=okrows = [
{"str1": "A", "int1": 10},
{"str1": "B", "int1": 20},
]
for row in rows:
print(", ".join(str(v) for v in row.values()))
# A, 10
# B, 20
def join_values(values, sep=", ", quoted=False):
falls zitiert:
# Verwenden Sie vollständige einfache Anführungszeichen „“
return sep.join(f"‘{v}'" für v in Werten)
sonst:
return sep.join(str(v) für v in Werten)
Werte = ["str1", "str2", 88, "str3"]
print(join_values(values, quoted=False))
# Ausgabe: str1, str2, 88, str3
print(join_values(values, quoted=True))
# Ausgabe: ‚str1‘, ‚str2‘, ‚88‘, ‚str3‘def join_args(*args, sep=", ", quoted=False):
if quoted:
return sep.join(f"‘{v}’" for v in args)
return sep.join(str(v) for v in args)
print(join_args("str1", "str2", 88, "str3", quoted=True))
# ‘str1’, ‘str2’, ‘88’, ‘str3’
data = {"str1": "hello", "str2": "world", "int1": 123}
print(join_values(data.values(), quoted=True))
# ‘hello’, ‘world’, ‘123’
def join_key_value(d, sep=", ", quoted=False):
if quoted:
return sep.join(f"{k}=‘{v}’" for k, v in d.items())
return sep.join(f"{k}={v}" for k, v in d.items())
print(join_key_value(data, quoted=True))
# str1=‘hello’, str2=‘world’, int1=‘123’
Pythonre.matchIst eine Funktion im Modul für reguläre Ausdrücke, die für den Abgleich vom Anfang der Zeichenfolge verwendet wird.
Wenn die Übereinstimmung erfolgreich ist, geben Sie a zurückMatchObjekt; andernfalls zurückgebenNone。
re.match(pattern, string, flags=0)Parameterbeschreibung:
pattern: Regulärer Ausdruck zum Abgleichen.string: Die zu prüfende Zeichenfolge.flags: Optionaler Parameter, der beispielsweise zum Ändern des Matching-Verhaltens verwendet wirdre.IGNORECASE。group(n):Zurück zum erstennerfasste Untergruppen,n=0Geben Sie das gesamte Spiel zurück.start(): Gibt die Startposition des Spiels zurück.end(): Gibt die Endposition des Spiels zurück.span(): Gibt den passenden Bereich (Anfang, Ende) zurück.Import bzgl
#Definieren Sie eine Zeichenfolge
text = „123 Hallo Welt!“
# Verwenden Sie re.match, um Zahlen von Anfang an abzugleichen
match = re.match(r"(\d+)\s+(.*)", Text)
Bei Übereinstimmung:
print(f"Gesamtes Übereinstimmungsergebnis: {match.group(0)}") # 123 Hallo Welt!
print(f"Zahlenteil: {match.group(1)}") # 123
print(f"Textteil: {match.group(2)}") # Hallo Welt!
sonst:
print("Match fehlgeschlagen")Das gesamte Matching-Ergebnis: 123 Hello World!
Numerischer Teil: 123
Textteil: Hallo Welt!re.matchNur ab dem Anfang der Zeichenfolge übereinstimmen. Wenn der Anfang nicht übereinstimmt, wird zurückgegebenNone。re.searchoderre.findall。Regulärer Ausdruck (kurz Regex) ist eine Syntax, die zur Beschreibung von String-Matching-Regeln verwendet wird. Es wird häufig zum Suchen, Ersetzen oder Überprüfen von Zeichenfolgen verwendet.
in PythonreIm ModulpatternDas ist der Kernbestandteil der Definition dieser Regeln.
\d: Entspricht einer beliebigen Zahl (0-9).\D: Entspricht allem, was keine Zahl ist.\w: Entspricht einem beliebigen einzelnen Zeichen (Buchstabe, Zahl, Unterstrich).\W: Entspricht jedem nicht-einzelnen Zeichen.\s: Entspricht jedem Leerzeichen (Leerzeichen, Tabulator usw.).\S: Entspricht jedem Zeichen, das kein Leerzeichen ist..: Entspricht außer Zeilenumbrüchen (\n) außer jedem einzelnen Zeichen.*: Entspricht dem vorherigen Ausdruck mindestens 0 Mal.+: Entspricht mindestens einem Mal dem vorherigen Ausdruck.?: Entspricht dem vorherigen Ausdruck 0 oder 1 Mal.{n}: Entspricht dem vorherigen Ausdruck genau n-mal.{n,}: Entspricht dem vorherigen Ausdruck mindestens n-mal.{n,m}: Entspricht dem vorherigen Ausdruck mindestens n-mal, aber nicht mehr als m-mal.^: Entspricht dem Anfang der Zeichenfolge.$: Entspricht dem Ende der Zeichenfolge.\b: Entspricht Wortgrenzen (z. B. dem Anfang oder Ende eines Wortes).\B: Entspricht Nicht-Wortgrenzen.(...):Group, erfassen Sie den Inhalt in Klammern.|: Logisches „oder“, wie za|bübereinstimmenaoderb。(?:...): Gruppiert, erfasst aber keine Inhalte.(?=...): Vorausschauend muss der Übereinstimmung der angegebene Inhalt folgen.(?!...): Negativer Lookaround, dem Abgleich kann der angegebene Inhalt nicht folgen.(?<=...): Forward-Lookback, dem Abgleich muss der angegebene Inhalt vorausgehen.(?<!...): Negativer Lookback, dem Abgleich kann kein angegebener Inhalt vorausgehen.Import bzgl
# Beispiel 1: Inhalte abgleichen, die mit einer Zahl beginnen
Muster = r"^\d+"
text = "123abc"
match = re.match(Muster, Text)
Bei Übereinstimmung:
print(f"Übereinstimmendes Ergebnis: {match.group()}") # Ausgabe: 123
#Beispiel 2: Text nach Zahlen zuordnen
Muster = r"(\d+)\s+(.*)"
text = „123 Hallo Welt“
match = re.match(Muster, Text)
Bei Übereinstimmung:
print(f"Zahlenteil: {match.group(1)}") # Ausgabe: 123
print(f"Textteil: {match.group(2)}") # Ausgabe: Hello Worldre.search()Wird verwendet, um nach der ersten Übereinstimmung eines regulären Ausdrucks in einer Zeichenfolge zu suchen und diese zurückzugebenMatchObjekt, wird zurückgegeben, wenn keine Übereinstimmung vorliegtNone。
Import bzgl
text = „Hallo 2024!“
match = re.search(r"\d+", text)
Bei Übereinstimmung:
print("Nummer gefunden:", match.group()) # 2024Wannre.search()Wenn eine Übereinstimmung gefunden wird, wird sie zurückgegebenMatchObjekte können über die folgenden Methoden auf Informationen zugreifen:
group(): Gibt die passende Zeichenfolge zurückstart(): passender Startindexend():Endindex der Übereinstimmungspan():Indexbereich (Anfang, Ende) zurückgebenImport bzgl
text = „Python 3.10 ist großartig!“
match = re.search(r"\d+\.\d+", text)
Bei Übereinstimmung:
print("Match content:", match.group()) # 3.10
print("Startindex:", match.start()) # 7
print("End index:", match.end()) # 11
print("range:", match.span()) # (7, 11)durch Klammern()um eine Gruppe zu erstellen und zu verwendengroup(n)um den entsprechenden passenden Inhalt zu extrahieren.
Import bzgl
text = „John Doe, Alter: 25“
match = re.search(r"(\w+) (\w+), Alter: (\d+)", Text)
Bei Übereinstimmung:
print("Nachname:", match.group(1)) # John
print("name:", match.group(2)) # Doe
print("Alter:", match.group(3)) # 25re.search()Es wird nur das erste übereinstimmende Ergebnis zurückgegebenre.findall()Alle passenden Ergebnisse werden zurückgegeben.
import re
text = "Price: $10, Discount: $2, Tax: $1"
match = re.search(r"\$\d+", text)
print("re.search:", match.group()) # $10
matches = re.findall(r"\$\d+", text)
print("re.findall:", matches) # ['$10', '$2', '$1']
re.search()Geeignet zum Finden des ersten passenden Ergebnisses und kann verwendet werdenMatchMelden Sie sich an, um detaillierte Informationen zu erhalten. Für mehrere übereinstimmende Ergebnisse verwenden Siere.findall()。
In einem regulären Ausdruck(...)Passende Inhalte werden erfasst und gespeichertgroup(n), aber nicht die Capture-Gruppe(?:...)Es wird nur für die Organisationsstruktur verwendet und hat keinen Einfluss auf die Gruppennummer, sodass der Abgleich schneller erfolgt.
Bei Verwendung im regulären Ausdruck()passende Bedingungen zu organisieren, die sich auswirkengroup(n)Nummer. verwenden(?:...)Dadurch wird sichergestellt, dass der Gruppenindex unverändert bleibt.
import re
text = "2024-03-12"
pattern = r"(\d{4})-(?:\d{2})-(\d{2})"
match = re.search(pattern, text)
print(match.group(1)) # 2024
print(match.group(2)) # 12
verwenden(?:...|...)kann lassen|Der Operator wirkt sich auf übereinstimmende Inhalte aus, nicht jedoch auf den Gruppenzugriff.
import re
text = "bar123"
pattern = r"(?:foo|bar|baz)\d+"
match = re.search(pattern, text)
print(match.group()) # bar123
Verwenden Sie beim Parsen von Chrome-Parametern(?:...)Dadurch wird sichergestellt, dass das passende Format keinen Einfluss auf die Gruppennummer hat.
import re
cmdline = '--user-data-dir="C:\\Users\\moirg\\AppData\\Local\\Google\\Chrome\\User Data"'
match = re.search(r'--user-data-dir=(?:"([^"]+)"|(\S+))', cmdline)
user_data_dir = match.group(1) or match.group(2)
print(user_data_dir) # C:\Users\moirg\AppData\Local\Google\Chrome\User Data
(?:...)Es kann die Leistung regulärer Ausdrücke verbessern, Auswirkungen auf den Gruppenindex vermeiden und eignet sich für|Operationen und spezifischer Bedingungsabgleich machen den Code effizienter und klarer.
import datetimenow = datetime.datetime.now()
print(now)dt = datetime.datetime(2025, 7, 2, 14, 30, 0)
print(dt)now = datetime.datetime.now()
formatted = now.strftime("%Y-%m-%d %H:%M:%S")
print(formatted)dt_str = "2025-07-02 14:30:00"
parsed = datetime.datetime.strptime(dt_str, "%Y-%m-%d %H:%M:%S")
print(parsed)now = datetime.datetime.now()
delta = datetime.timedelta(days=7)
next_week = now + delta
print(next_week)today = datetime.date.today()
print(today)dt1 = datetime.datetime(2025, 7, 1)
dt2 = datetime.datetime(2025, 7, 2)
print(dt1 < dt2)dt1 = datetime.datetime(2025, 7, 1, 12, 0, 0)
dt2 = datetime.datetime(2025, 7, 2, 14, 30, 0)
diff = dt2 - dt1
print(diff)
print(diff.total_seconds())today = datetime.date.today()
print(today.weekday()) # 0 = Montag, 6 = SonntagWenn ein Datetime-Objekt keine Zeitzone hat (naiv) und das andere eine Zeitzone hat (bewusst) und subtrahiert wird, wird Folgendes erzeugt:
TypeError: can't subtract offset-naive and offset-aware datetimes
from datetime import datetime
def is_aware(dt):
return dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) is not None
def is_naive(dt):
return not is_aware(dt)
dt1 = datetime.now() # naive
dt2 = datetime.now().astimezone() # aware
print(is_naive(dt1), is_aware(dt1))
print(is_naive(dt2), is_aware(dt2))
Geeignet für Situationen über Zeitzonen hinweg oder wenn eine genaue Zeitberechnung erforderlich ist.
aus Datum/Uhrzeit Import Datum/Uhrzeit, Zeitzone
sql_dt = sql_dt.replace(tzinfo=timezone.utc) # SQL-Datenübertragung bewusst
now_dt = datetime.now(timezone.utc) # Aware für die aktuelle Zeit verwenden
diff = now_dt - sql_dt
print(diff.total_seconds())sql_dt = sql_dt.replace(tzinfo=None)
now_dt = datetime.now()
diff = now_dt - sql_dt
In Python können Sie die integrierten Module verwendenstatisticsvonstdev()oderpstdev()Berechnen Sie die Stichprobenstandardabweichung oder Populationsstandardabweichung.
Statistiken importieren
Verhältnisse = [2,3, 2,8, 3,1, 2,5, 3,0]
# Durchschnitt
Durchschnitt = Summe(Verhältnisse) / len(Verhältnisse)
#Stichprobenstandardabweichung (n-1)
std_sample = Statistics.stdev(Verhältnisse)
#Matrix-Standardabweichung (n)
std_population = Statistics.pstdev(Verhältnisse)
print(f"Durchschnitt: {Durchschnitt:.2f}")
print(f"Standardabweichung der Stichprobe: {std_sample:.3f}")
print(f"Standardabweichung der Bevölkerung: {std_population:.3f}")Durchschnitt: 2,74
Probenstandardabweichung: 0,303
Populationsstandardabweichung: 0,271Wenn Sie sich nicht darauf verlassen wollenstatisticsModul, Sie können es mithilfe mathematischer Formeln selbst berechnen:
Verhältnisse = [2,3, 2,8, 3,1, 2,5, 3,0]
Durchschnitt = Summe(Verhältnisse) / len(Verhältnisse)
#Standardabweichung (Grundgesamtheit)
Varianz = Summe((x - Durchschnitt) ** 2 für x in Verhältnissen) / len(Verhältnisse)
std_dev = Varianz ** 0,5
print(f"Standardabweichung: {std_dev:.3f}")Standardabweichung: 0,271statistics.stdev(): Stichprobenstandardabweichung (geteilt durchn-1）statistics.pstdev(): Übergeordnete Standardabweichung (geteilt durchn）pstdev()stdev()avg = sum(data) / len(data)statistics.stdev(data)statistics.pstdev(data)# ANSI-Farbcode-Beispiel
print("\033[31m roter Text\033[0m")
print("\033[32m grüner Text\033[0m")
print("\033[33mgelber Text\033[0m")
print("\033[34m blauer Text\033[0m")
print("\033[35m lila Text\033[0m")
print("\033[36m cyanfarbener Text\033[0m")
print("\033[37m weißer Text\033[0m")print("\033[1;31m fetter roter Text\033[0m")
print("\033[42m grüner Hintergrundtext\033[0m")# Format: \033[style; Vordergrundfarbe; Hintergrundfarbe m
# Stil: 0=Standard, 1=Fett, 4=Unterstrichen
# Vordergrundfarbe: 30~37
# Hintergrundfarbe: 40~47
print("\033[1;33;44m fetter gelber Text + blauer Hintergrund\033[0m")def color_text(text, color_code):
return f"\033[{color_code}m{text}\033[0m"
print(color_text("Warning!", "1;31")) # Fettes Rot
print(color_text("Success!", "1;32")) # Fettgrünimportsys
wenn sys.stdout.isatty():
print("Terminal unterstützt möglicherweise ANSI-Farben")
sonst:
print("Möglicherweise handelt es sich um eine Datei oder eine Ausgabeumgebung, die keine Farbe unterstützt")Colorama importieren
colorama.init()
print("\033[32mDieser Text sollte grün sein\033[0m")def unterstützt_ansi():
Versuchen Sie:
print("\033[31m test red\033[0m")
Rückgabe True
außer:
Gibt False zurück
print("ANSI wird unterstützt", wenn_ansi() unterstützt, sonst "ANSI wird nicht unterstützt")colorama。In Python,input()Die Funktion selbst wird nicht unterstütztTabAutomatisch abgeschlossen.
Um diese Funktion zu erreichen, können Sie kombinierenreadlineModul, das Benutzern die Verwendung ermöglichtTabFühren Sie eine automatische Vervollständigung durch (ähnlich wie Bash oder IPython).
Readline importieren
# Definieren Sie eine Liste von Zeichenfolgen, die vervollständigt werden können
WÖRTER = ['Apfel', 'Banane', 'Kirsche', 'Traube', 'Orange', 'Wassermelone']
defcompleter(text, state):
„“Autovervollständigungsfunktion: Vergleichen Sie verfügbare Zeichenfolgen basierend auf Eingabepräfixen““
Optionen = [w für w in WORDS if w.startswith(text)]
wenn Zustand < len(Optionen):
Rückgabeoptionen[Status]
sonst:
return Keine
# Abschlussfunktion aktivieren
readline.set_completer(Vervollständiger)
readline.parse_and_bind('tab: Complete')
# Benutzereingabe (unterstützt Tab)
user_input = input("Geben Sie den Namen der Frucht ein (zum Vervollständigen können Sie die Tabulatortaste drücken):")
print(f"Was Sie eingegeben haben, ist: {user_input}")readline.set_completer()Legen Sie die Logik für die automatische Vervollständigung fest.readline.parse_and_bind('tab: complete')lassenTabDer Schlüssel löst die automatische Vervollständigung aus.completer(text, state)：
textist der aktuell eingegebene Text.stateStellt das passende Element dar (0, 1, 2...).None。Sie können die Vervollständigungsliste auch basierend auf dem aktuellen Kontext oder dynamischen Inhalten aktualisieren:
Readline importieren
defdynamic_completer(text, state):
current_words = ['Katze', 'Auto', 'Hund', 'Ente', 'Hirsch']
Optionen = [w für w in aktuellen_Wörtern, wenn w.startswith(text)]
wenn Zustand < len(Optionen):
Rückgabeoptionen[Status]
return Keine
readline.set_completer(dynamic_completer)
readline.parse_and_bind('tab: Complete')
command = input("Geben Sie den Tiernamen ein:")
print("Sie geben ein:", Befehl)readlineDas Modul ist drinLinux / macOSDie oben genannten Voreinstellungen sind verfügbar.pip install pyreadline3readlineModule erlaubeninput()Unterstützt die Tab-Vervollständigung.pyreadline3Bausatz.Die gebräuchlichste Schleife wird verwendet, um eine feste Anzahl oder Sequenz auszuführen.
# von 0 bis 4
für i im Bereich(5):
print(i) #0,1,2,3,4
#Geben Sie den Startpunkt, den Endpunkt und die Schrittgröße an
für i im Bereich(2, 10, 2):
print(i) #2,4,6,8Listen, Zeichenfolgen, Wörterbücher usw. direkt iterieren.
Früchte = [„Apfel“, „Banane“, „Kirsche“]
für Obst in Früchten:
drucken(Frucht)
für ch in „Hallo“:
drucken(ch)
#Durch das Wörterbuch iterieren
person = {"name": "Tom", "age": 25}
für Schlüssel, Wert in person.items():
print(Schlüssel, Wert)Es wird immer ausgeführt, wenn die Bedingung wahr ist.
count = 0
while count < 5:
print(count)
count += 1
Steuern Sie den Schleifenprozess.
für i im Bereich(10):
wenn ich == 3:
weiter # dieses Mal überspringen
wenn ich == 7:
Pause # Früh beenden
drucken(i)Gehen Sie zurück in den Kreis und legen Sie es wieder in den Kreis.
for i in range(3):
for j in range(2):
print(f"i={i}, j={j}")
Sie können entweder „für“ oder „während“ hinzufügenelse, wird nur „normaler Abschluss (keine Pause)“ ausgeführt.
für i im Bereich(5):
drucken(i)
sonst:
print("Schleife endet normal")Eine prägnante Schreibmethode kann die Schleife vervollständigen und die Liste in einer Zeile generieren.
squares = [x**2 for x in range(5)]
print(squares) # [0,1,4,9,16]
for in range(): Geeignet für feste Zeiten oder Sequenzen.für in iterierbares Objekt: Geeignet für die Verarbeitung von Listen, Zeichenfolgen und Wörterbüchern.while: Geeignet für Schleifen mit einer unbegrenzten Anzahl an Wiederholungen, die je nach Bedingungen enden.break / continue / else: Steuern Sie den Schleifenprozess.Python verwendet die try...exclusive-Anweisung zum Abfangen und Behandeln von Fehlern, die während der Programmausführung auftreten, um Programmabstürze zu verhindern.
Versuchen Sie:
# Code, der Ausnahmen verursachen kann
Ergebnis=10/0
außer ZeroDivisionError:
# Code wird ausgeführt, wenn eine bestimmte Ausnahme auftritt
print("Der Divisor darf nicht Null sein")
außer Ausnahme als e:
#Alle anderen Arten von Ausnahmen abfangen
print(f"Es ist ein Fehler aufgetreten: {e}")
sonst:
# Ausführen, wenn im Try-Block keine Ausnahme auftritt
print("normaler Betrieb")
endlich:
# Wird unabhängig davon ausgeführt, ob eine Ausnahme auftritt
print("Ressourcen bereinigen oder Dateien schließen")Sie können Tupel in einer Ausnahme verwenden, um mehrere Fehlertypen gleichzeitig zu behandeln.
Versuchen Sie:
# Operationen durchführen
passieren
außer (ValueError, TypeError):
print("Der eingegebene Datentyp oder Wert ist falsch")Verwenden Sie das Schlüsselwort raise, um Ausnahmen basierend auf logischen Anforderungen manuell auszulösen.
age = -1
if age < 0:
raise ValueError("年齡數值不可為負數")Klasse MyClass:
def __init__(self, value):
self.value = Wert
def display(self):
print(f"Wert: {self.value}")
obj = MyClass(10)
obj.display() # Ausgabe: Wert: 10
Statische Methoden werden mit dem Dekorator „@staticmethod“ definiert und haben nichts mit Kategorien und Objekten zu tun. Sie können nicht auf Kategorieeigenschaften oder Objekteigenschaften zugreifen. Gilt für einige Instrumentalfunktionen:
Klasse MyClass:
@staticmethod
def add(a, b):
gib a + b zurück
result = MyClass.add(5, 3)
print(result) # Ausgabe: 8
Klassenmethoden werden mit dem „@classmethod“-Dekorator definiert, der erste Parameter ist die Klasse selbst (normalerweise „cls“ genannt) und auf Klassenattribute kann zugegriffen werden:
classMyClass:
Anzahl = 0
@classmethod
def increment_count(cls):
cls.count += 1
MyClass.increment_count()
print(MyClass.count) # Ausgabe: 1
Python unterstützt die Klassenvererbung. Unterklassen können die Eigenschaften und Methoden der übergeordneten Klasse erben und die Methoden der übergeordneten Klasse überschreiben:
Klasse Elternteil:
auf jeden Fall grüßen(selbst):
print("Hallo vom Elternteil!")
Klasse Kind (Elternteil):
auf jeden Fall grüßen(selbst):
print("Hallo vom Kind!")
obj = Child()
obj.greet() # Ausgabe: Hallo vom Kind!
Kategorieattribute gehören zur gesamten Kategorie und werden von allen Objekten gemeinsam genutzt. Objektattribute gehören zu jedem Objekt:
classMyClass:
class_attr = „Ich bin ein Klassenattribut“
def __init__(self, value):
self.instance_attr = Wert
obj1 = MyClass(10)
obj2 = MyClass(20)
print(MyClass.class_attr) # Ausgabe: Ich bin ein Klassenattribut
print(obj1.instance_attr) # Ausgabe: 10
print(obj2.instance_attr) # Ausgabe: 20
Alle Klassen in Python erben standardmäßig von „object“, einer integrierten Basisklasse, die einige grundlegende Methoden wie „__str__“ und „__eq__“ bereitstellt:
Klasse MyClass(Objekt):
def __init__(self, value):
self.value = Wert
def __str__(self):
return f"MyClass mit dem Wert {self.value}"
obj = MyClass(5)
print(obj) # Ausgabe: MyClass mit Wert 5
In Python ermöglicht die Klassenvererbung, dass Unterklassen (abgeleitete Klassen) die Eigenschaften und Methoden der übergeordneten Klasse (Basisklasse) erben, um eine Wiederverwendung von Code zu erreichen. Zum Beispiel:
Klasse Elternteil:
auf jeden Fall grüßen(selbst):
print("Hallo vom Elternteil!")
Klasse Kind (Elternteil):
passieren
c = Kind()
c.greet() # Ausgabe: Hallo vom Elternteil!
Unterklassen können die Methoden der übergeordneten Klasse überschreiben (Override) und ihre Funktionen neu schreiben:
Klasse Elternteil:
auf jeden Fall grüßen(selbst):
print("Hallo vom Elternteil!")
Klasse Kind (Elternteil):
auf jeden Fall grüßen(selbst):
print("Hallo vom Kind!")
c = Kind()
c.greet() # Ausgabe: Hallo vom Kind!
In der Unterklasse können Sie die Methode der übergeordneten Klasse über „super()“ aufrufen und das Verhalten der übergeordneten Klasse erweitern:
Klasse Elternteil:
auf jeden Fall grüßen(selbst):
print("Hallo vom Elternteil!")
Klasse Kind (Elternteil):
auf jeden Fall grüßen(selbst):
super().greet()
print("Hallo vom Kind!")
c = Kind()
c.greet()
# Ausgabe:
# Hallo von den Eltern!
# Hallo vom Kind!
Python unterstützt die Mehrfachvererbung und Unterklassen können mehrere übergeordnete Klassen gleichzeitig erben:
Klasse Parent1:
auf jeden Fall grüßen(selbst):
print("Hallo von Parent1!")
Klasse Parent2:
auf jeden Fall grüßen(selbst):
print("Hallo von Parent2!")
Klasse Child(Parent1, Parent2):
passieren
c = Kind()
c.greet() # Ausgabe: Hallo von Parent1! (laut Erbfolge)
Bei der Mehrfachvererbung wird MRO (Method Resolution Order) verwendet, um die Auflösungsreihenfolge von Methoden zu bestimmen. Dies kann mit dem Attribut „__mro__“ überprüft werden:
print(Child.__mro__) # Ausgabe: (, , , )
Verwenden Sie das Modul „abc“, um eine abstrakte Basisklasse zu definieren, um Unterklassen zu zwingen, bestimmte Methoden zu implementieren:
from abc import ABC, abstractmethod
Klasse AbstractParent(ABC):
@abstractmethod
auf jeden Fall grüßen(selbst):
passieren
Klasse Child(AbstractParent):
auf jeden Fall grüßen(selbst):
print("Hallo vom Kind!")
c = Kind()
c.greet() # Ausgabe: Hallo vom Kind!
KlasseKlasseB:
auf jeden Fall grüßen(selbst):
print("Hallo aus KlasseB!")
# Erstellen Sie dynamisch eine temporäre Klasse, die von ClassB geerbt wird
TempClass = type('TempClass', (ClassB,), {
'greet': lambda self: (print("Hallo von TempClass!"), super(TempClass, self).greet())[0]
})
#Instanz erstellen und testen
temp = TempClass()
temp.greet()type('TempClass', (ClassB,), {...})greetDie Methode besteht darin, zuerst die neue Nachricht auszudrucken und sie dann zu übergebensuper()übergeordnete Kategorie aufrufengreet。
Hello from TempClass!
Hello from ClassB!Angenommen, es gibt zwei KategorienAClassUndBClass, sie haben Funktionen mit demselben Namen und denselben Parametern.
Wir möchten in der Lage sein, die zu verwendende Kategorie einfach zu wechseln, ohne die Hauptprogrammlogik ändern zu müssen.
Klasse AKlasse:
def Prozess(Selbst, Daten):
print(f"AClass processing: {data}")
def result(self):
Rückgabe „Ergebnis aus AClass“
Klasse BKlasse:
def Prozess(Selbst, Daten):
print(f"BClass processing: {data}")
def result(self):
Rückgabe „Ergebnis aus BClass“
# Sie können über die Einstellungen steuern, welche Kategorie verwendet werden soll
USE_A = True
#Dynamische Auswahl von Kategorien
SelectedClass = AClass, wenn USE_A, sonst BClass
# Erstellen Sie eine Instanz und verwenden Sie sie
obj = SelectedClass()
obj.process("Testdaten")
print(obj.result())AClass-Verarbeitung: Testdaten
Ergebnisse von AClassBClass-Verarbeitung: Testdaten
Ergebnisse von BClassdef get_class(name):
Zuordnung = {
„A“: AKlasse,
„B“: BKlasse
}
Return Mapping.get(name, AClass) # Standard ist AClass
# Dynamische Auswahl
cls = get_class("B")
obj = cls()
obj.process("Testdaten")In Python,Nicht unbedingt erforderlichGeschrieben wie C++ oder Javaabstract class.
Python übernimmt „Duck Typing“. Solange Objekte dieselben Methodennamen und Verhaltensweisen haben, können sie als kompatibel betrachtet werden.
Klasse AKlasse:
def Prozess(Selbst, Daten):
print(f"AClass processing: {data}")
Klasse BKlasse:
def Prozess(Selbst, Daten):
print(f"BClass processing: {data}")
def run(obj):
obj.process("data") # Der Typ muss nicht angegeben werden, solange diese Methode vorhanden ist
run(AClass())
run(BClass())AKlassenverarbeitung: Daten
BClass-Verarbeitung: DatenObwohl Python keine Typen erzwingt, können Sie diese verwenden, wenn Sie die Schnittstelle in der Teamentwicklung oder bei großen Projekten klar definieren möchtenabcMods.
from abc import ABC, abstractmethod
Klasse BaseClass(ABC):
@abstractmethod
def Prozess(Selbst, Daten):
passieren
Klasse AClass(BaseClass):
def Prozess(Selbst, Daten):
print(f"AClass processing: {data}")
Klasse BClass(BaseClass):
def Prozess(Selbst, Daten):
print(f"BClass processing: {data}")
# BaseClass() meldet einen Fehler, da die abstrakte Methode nicht implementiert istabcMods.In Python,Modulist eine Datei, die Programmcode enthält, normalerweise mit der Dateierweiterung.pyDas Ende. Module können Funktionen, Kategorien und Variablen definieren und auch ausführbaren Code enthalten, um die Wiederverwendung und Programmstrukturierung zu erleichtern.
Python überimportSchlüsselwort zur Einleitung des Moduls, zum Beispiel:
Mathematik importieren
print(math.sqrt(16)) # Ausgabe 4.0Entwickler können ihre eigenen Mods erstellen. Erstellen Sie beispielsweise einemymodule.py：
# mymodule.py
def greet(name):
return f"Hello, {name}!"
Verwendung in einer anderen Programmdatei:
import mymodule
print(mymodule.greet("Alice"))
os: Behandelt betriebssystembezogene Vorgänge.sys: Greifen Sie auf Informationen zum Python-Interpreter zu.datetime: Datum und Uhrzeit der Bearbeitung.math: Stellt mathematische Funktionen bereit.random: Zufallszahlen generieren.In Python,PaketEs ist eine Möglichkeit, Module zu organisieren. Ein Paket ist ein Verzeichnis, das mehrere Module enthält, was die Verwaltung und Wartung des Programms durch eine hierarchische Struktur erleichtert.
__init__.pyarchive (in Python 3.3+ weggelassen, aber hinzugefügt, um die Suite klarer zu definieren).Erstellen Sie eine Datei mit dem NamenmypackageKit bestehend aus:
mypackage/
│── __init__.py
│── module1.py
└── module2.py
module1.pyBeispiel:
def add(a, b):
return a + b
module2.pyBeispiel:
def multiply(a, b):
return a * b
importiere mein Paket.module1
importiere mein Paket.module2
print(mypackage.module1.add(2, 3)) # Ausgabe 5
print(mypackage.module2.multiply(2, 3)) # Ausgabe 6aus mypackage.module1 importieren hinzufügen
aus mypackage.module2 importieren und multiplizieren
print(add(10, 5)) # Ausgabe 15
print(multiply(10, 5)) # Ausgabe 50In Python, um die aktuellen Module abzurufenPaketnamekönnen Sie spezielle Variablen verwenden__package__. Dies und__module__Das Konzept zum Abrufen des aktuellen Modulnamens ist ähnlich.
mypackage/
│── __init__.py
└── submodule.py
submodule.pyInhalt:
print("__name__:", __name__)
print("__package__:", __package__)
print("__module__:", __module__)
Bei Verwendung in anderen Programmen alsimport mypackage.submoduleBeim Import sieht die Ausgabe ungefähr wie folgt aus:
__name__: mypackage.submodule
__package__: mypackage
__module__: __main__
__name__: Der vollständige Modulname.__package__: Der Name des Pakets, zu dem das aktuelle Modul gehört. Wenn es sich um ein Modul der obersten Ebene handelt, handelt es sich um eine leere Zeichenfolge.__module__: Wird normalerweise in der Definition einer Klasse oder Funktion verwendet, um anzugeben, in welchem Modul sie definiert ist.__package__Helfen Sie mit, Paketpfade zu bestätigen.Es gibt zwei Möglichkeiten, die Version des Python-Pakets zu überprüfen: über das Terminal (Befehlszeile) oder durch die Ausführung im Python-Code. Dies kann Ihnen helfen zu bestätigen, ob die Umgebung den Projektanforderungen entspricht.
Dies ist die schnellste Methode und erfordert keinen Aufruf der interaktiven Python-Umgebung.
pip zeigt den Paketnamen an(Zum Beispielpip show pandas）。pip list。Pip-Liste | findstr „Paketname“(Windows) bzwPip-Liste | grep "Paketname" (Linux/Mac)。Name des Conda-Listenpakets。Wenn Sie die Version beim Ausführen des Programms ermitteln müssen, können Sie die folgenden zwei Methoden verwenden:
import pandas
print(pandas.__version__)from importlib.metadata import version
print(version('pandas'))| Verfahren | Anweisungen/Code | Anwendbare Situationen |
|---|---|---|
| Pip-Befehl | pip show |
Zeigen Sie detaillierte Informationen wie Installationspfad, Autor, Abhängigkeiten usw. an. |
| Pip-Liste | pip list |
Verschaffen Sie sich einen schnellen Überblick über alle Pakete und Versionen in Ihrer aktuellen Umgebung. |
| interne Eigenschaften | .__version__ |
Treffen Sie logische Urteile, während das Skript ausgeführt wird. |
| Metadata | version() |
Standardisierte Methode zur Überprüfung, ohne die gesamte Suite zu laden. |
Manchmal liegt das Problem nicht bei der Suite, sondern beim Python-Interpreter selbst:
python --versionimport sys
print(sys.version)pip listDie angezeigte Version unterscheidet sich von der in VS Code ausgeführten. Bitte bestätigen Sie diesInterpreterOb die Wahl richtig ist.importlibDie Suche nach deinstallierten Paketen führt zu einem FehlerPackageNotFoundError。pip showGroß- und Kleinschreibung wird nicht beachtet, einige Codelogiken erfordern jedoch möglicherweise präzise Namen.In Python kann über auf Klassenobjekte zugegriffen werdencls.__module__Suchen Sie den Namen des Moduls, das die Kategorie definiert, und verwenden Sie ihn dannsys.modulesHolen Sie sich das Modulobjekt und lesen Sie es schließlich__package__Eigenschaft zum Abrufen des Paketnamens.
importsys
# Angenommen, eine Kategorie ist in mypackage.submodule definiert
classMyClass:
passieren
# Rufen Sie den Namen des Moduls ab, zu dem die Kategorie gehört
module_name = MyClass.__module__
print("Modulname:", Modulname)
# Modulobjekt abrufen
mod = sys.modules[Modulname]
# Holen Sie sich den Paketnamen vom Modulobjekt
print("Paketname:", mod.__package__)Das Modul selbst ist ein Objekt und kann direkt aufgerufen werden__package__Eigentum.
Mathematik importieren
importiere mypackage.submodule als sub
# math ist ein Standardfunktionsbibliotheksmodul, es gibt kein Paket, daher ist __package__ eine leere Zeichenfolge
print("math.__package__:", math.__package__)
# Module für kundenspezifische Kits
print("sub.__package__:", sub.__package__)Modulname: mypackage.submodule
Paketname: meinPaket
math.__Paket__:
sub.__package__: meinPaketKategorie → __module__ → sys.modules[...] → __package__Modulobjekt → __package__Direkt beziehenWenn eine Python-Datei direkt ausgeführt wird, lautet ihr Modulname__main__. Dies erleichtert die Verwendungcls.__module__Der ursprüngliche Dateiname und -pfad konnte nicht abgerufen werden.
Gehen Sie davon aus, dass Ihre Projektstruktur wie folgt aussieht:
/Projekt
|-- test_runner.py <-- Die Datei, die Sie direkt ausführen (wird als __main__ behandelt)
|--test/
|-- db_test.py <-- Datei, die DbCmdAgent definiertWenn Sie den folgenden Code in „test_runner.py“ ausführen:
aus test.db_test DbCmdAgent importieren
agent_obj = DbCmdAgent(...) # Instanziierung
# Zu diesem Zeitpunkt ist cls.__module__ immer noch „test.db_test“ (korrekter Modulname)Wenn Sie jedoch Kategorien in „test_runner.py“ definieren:
# Inhalt von test_runner.py
Klasse DbCmdAgent:
passieren
agent_obj = DbCmdAgent()
#Zu diesem Zeitpunkt cls.__module__ == '__main__' (falscher Modulname)Dies zeigt an, dass die Klasse, für die Sie Informationen erhalten, in einer Datei definiert ist, die als „__main__“ ausgeführt wird.
inspectDas Modul kann den Dateipfad direkt abrufenUnabhängig davon, ob die Kategorie in „__main__“ definiert ist, können Sie das Attribut „__module__“ umgehen und verwendeninspectModul, um den Quellcodedateipfad zu erhalten, der dieser Kategorie entspricht. Dies ist eine zuverlässigere und allgemeinere Methode.
Import prüfen
Betriebssystem importieren
# --- Simulationssituation: Kategorien definiert in __main__ (aktuell ausgeführtes Skript) ---
Klasse DbCmdAgent:
„““Diese Kategorie ist im aktuell ausgeführten Hauptskript definiert““
def __init__(self, data):
self.data = Daten
agent_obj = DbCmdAgent("some_data")
def get_class_location_robust(obj):
„““
Verwenden Sie inspect.getfile, um das __module__ == '__main__'-Problem zu umgehen.
„““
cls = Typ(obj)
# 1. Verwenden Sie inspect.getfile(), um den Dateipfad abzurufen, der die Kategorie definiert
Versuchen Sie:
file_path = inspect.getfile(cls)
# 2. Ermitteln Sie den Dateinamen und das Verzeichnis
file_name = os.path.basename(file_path)
Verzeichnis = os.path.dirname(file_path)
py_name = os.path.splitext(file_name)[0]
# 3. Wenn __module__ __main__ ist, ersetzen Sie es durch den Archivnamen, um mehr Kontext bereitzustellen
module_name = cls.__module__
if module_name == '__main__':
module_name = py_name # Verwenden Sie db_test oder test_runner als Kontext
außerTypeError:
# Behandelt integrierte Typen
file_path = „N/A (integriert oder C-Erweiterung)“
file_name = „N/A“
Verzeichnis = „N/A“
py_name = "N/A"
module_name = cls.__module__
zurück {
„module_name_or_main“: Modulname,
"py_name_no_ext": py_name,
„Verzeichnis“: Verzeichnis,
"file_path": file_path,
}
# Ausführen und Ergebnisse anzeigen
location_info = get_class_location_robust(agent_obj)
print("--- Informationen zur Kategoriedefinitionsdatei ---")
print(f"Dateiname (.py-Name): {location_info['py_name_no_ext']}")
print(f"Verzeichnispfad (Paket): {location_info['directory']}")
print(f"Vollständiger Dateipfad: {location_info['file_path']}")inspect.getfile(type(obj)): Dies ist die zuverlässigste Methode, um den ursprünglichen Definitionsdateipfad direkt abzurufen, völlig unabhängig davon, ob das Modul berücksichtigt wird__main__。__module__Dies spiegelt nur den Modul-Namespace der Klasse im aktuellen Programm wider, nicht unbedingt ihren tatsächlichen Namen in der Projektstruktur.Diese Methode verwendetimportlib.import_moduleVersuchen Sie, das angegebene Modul zu importieren. Wenn Sie stoßenModuleNotFoundError, wird versuchen, seine Submodule aus dem aktuell geladenen Paket zu importieren.
import importlib
importsys
def safe_import(module_name):
Versuchen Sie:
# Versuchen Sie, direkt zu importieren
return importlib.import_module(module_name)
außer ModuleNotFoundError:
# Wenn dies fehlschlägt, versuchen Sie, das Submodul aus einem bekannten Paket zu importieren
für pkg in list(sys.modules.keys()):
wenn pkg und nicht pkg.startswith("_"):
Versuchen Sie:
return importlib.import_module(f"{pkg}.{module_name}")
außer ModuleNotFoundError:
weitermachen
raise # Wenn immer noch nicht gefunden, eine Ausnahme auslösenNumpy importieren
mod1 = safe_import("random") # Es kann direkt erfolgreich sein, da es sich um eine Standardbibliothek handelt
mod2 = safe_import("linalg") # Werde numpy.linalg ausprobieren
print(mod2.__name__) # Ausgabe numpy.linalgsys.modulesSpeichern Sie alle geladenen Module.package.module_nameMethode, um es erneut zu versuchen.In Python,sys.pathist eine Liste mit allen Verzeichnispfaden, die der Python-Interpreter der Reihe nach durchsucht, wenn er versucht, ein Modul zu importieren. Wenn Sie ausführenimport some_module, Python wird der Reihe nach prüfensys.pathjedes Verzeichnis in der Liste, bis Sie ein Verzeichnis mit dem Namen findensome_moduleDateien (z.B.some_module.py、some_module/__init__.pyWarten).
sys.pathListen bestehen normalerweise aus den folgenden drei Teilen und werden in der folgenden Reihenfolge durchsucht:
sys.path[0]) ist normalerweise das aktuell ausgeführte Python-Skript (z. B.main.py) befindet sich im Verzeichnis.'', das das aktuelle Arbeitsverzeichnis (Current Working Directory, CWD) darstellt.PYTHONPATHSystemumgebungsvariablen.sys.pathMitte.PYTHONPATHWird normalerweise verwendet, um einige häufig verwendete Projekt- oder Bibliotheksverzeichnisse, die sich an nicht standardmäßigen Speicherorten befinden, dauerhaft zum Suchpfad hinzuzufügen, ohne sie in jedem Projekt manuell festlegen zu müssen.os, sys, json, socket) Installationsverzeichnis.pipInstallierte Pakete von Drittanbietern (z. B.fastapi, numpy, pandas) Installationsverzeichnis. In einer virtuellen Umgebung befindet sich dieser normalerweise in der Umgebunglib/site-packagesVerzeichnis.Zusätzlich zu den oben genanntenPYTHONPATHDarüber hinaus gibt es mehrere Umgebungsvariablen im Zusammenhang mit der Python-Ausführungsumgebung, die sich auf das Verhalten des Interpreters und die Pfadfindung auswirkensys.pathDie Hauptvariablen, aus denen sich das zusammensetztPYTHONPATH：
| Systemvariablen | Funktionsbeschreibung | Beziehung zu sys.path |
|---|---|---|
PYTHONPATH |
Definiert zusätzliche Verzeichnisse, die dem Mod-Suchpfad hinzugefügt werden sollen. | direkte Wirkungsys.pathZusammensetzung. |
PYTHONHOME |
Wird verwendet, um einen alternativen Pfad zum Python-Installationsverzeichnis festzulegen, insbesondere für eingebettete Systeme. | Beeinflusst indirekt die Standardbibliothek undsite-packagesStandort. |
PATH |
Wird vom Betriebssystem verwendet, um ausführbare Dateien zu finden (z. B.python.exe) Weg. |
wirkt sich nicht direkt aussys.path, beeinflusst aber, welcher Python-Interpreter ausgeführt wird. |
VIRTUAL_ENV |
Wenn Sie sich in einer virtuellen Umgebung befinden, verweist diese Variable auf das Stammverzeichnis der virtuellen Umgebung. | indirekte Wirkungsys.path, wie es sicherstelltsite-packagesEs kommt eher aus der virtuellen Umgebung als aus dem gesamten System. |
Weilsys.pathist eine gewöhnliche Python-Liste, die Sie dynamisch ändern können, während das Programm ausgeführt wird. Solche Änderungen werden jedoch nur innerhalb der aktuellen Interpretersitzung wirksam:
importsys
Betriebssystem importieren
# Fügen Sie das übergeordnete Verzeichnis zum Suchpfad hinzu (wird häufig zum Testen oder als interne Projektreferenz verwendet).
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))Module Shadowing (oder Name Shadowing) ist ein häufiger Fehler oder Programmierproblem in Python. Es tritt auf, wenn Sie versehentlich eine Codedatei oder einen Variablennamen erstellen, der mit dem Namen eines integrierten Moduls oder einer Drittanbieterbibliothek, die Sie importieren oder verwenden möchten, in Konflikt steht.
sys.path), um den Mod zu finden.socket, json, random) oder eine Datei oder ein Verzeichnis mit demselben Namen wie eine Drittanbieterbibliothek (z. B. erstellen Sie eine Datei mit dem Namensocket.pyDatei), lädt Python zuerst Ihre lokale Datei.Das Ergebnis davon ist, dass Ihre lokale Datei das Standardmodul, das geladen werden soll, „überdeckt“ oder „überschreibt“, sodass Ihr Code nicht auf Standardmodulfunktionen zugreifen kann (z. Bsocket.AF_UNSPEC) schlägt fehl, da die von Ihnen geladene lokale Datei nicht über diese Eigenschaften verfügt.
| Standardmodulname | Der lokale Dateiname, der den Schatten verursacht hat | als Ergebnis |
|---|---|---|
socket |
socket.py |
Standard kann nicht verwendet werdensocketDie Netzwerkkonstanten des Moduls (z. BAF_INET, AI_PASSIVE）。 |
json |
json.py |
Standard kann nicht verwendet werdenjsonModularloadsoderdumpsFunktion. |
test(Projektname) |
test.py |
In einer Unit-Testumgebung kann es zu Konflikten mit der internen Logik des Test-Frameworks kommen. |
socket.pyumbenanntnetwork_handler.py。import sys; print(sys.path)Überprüfen Sie den Suchpfad von Python, um festzustellen, ob Ihre lokalen Dateien anstelle des Standardbibliotheksverzeichnisses geladen werden.Um die aktuelle Ausführung des Python-Programms abzurufen__main__Der Name der .py-Datei, zu der es gehört und die verwendet werden kann__main__.__file__odersys.argv[0]. Aber im interaktiven Modus, Jupyter, oder-cMöglicherweise ist es zum Zeitpunkt der Ausführung noch nicht vorhanden und erfordert daher eine sichere Handhabung.
Betriebssystem importieren
importsys
__main__ importieren
def get_main_py_path():
"""Gibt den absoluten Pfad von .py zurück, zu dem main gehört. Wenn es nicht gefunden werden kann, wird None zurückgegeben"""
# Fall 1: Normale Ausführung von .py
main_file = getattr(__main__, "__file__", None)
wenn main_file:
return os.path.abspath(main_file)
# Fall 2: Urteil von sys.argv[0]
wenn len(sys.argv) > 0:
argv0 = sys.argv[0]
wenn argv0 nicht in ("", "-c", ""):
Kandidat = os.path.abspath(argv0)
wenn os.path.exists(candidate):
Rückkehrkandidat
# Fall 3: Interaktiver Modus, Jupyter, Einbetten usw.
return Keine
# Beispiel
path = get_main_py_path()
wenn Pfad:
print("Hauptpfad:", Pfad)
print("Hauptdateiname:", os.path.basename(path))
sonst:
print("main.py nicht gefunden (vielleicht in interaktiver Umgebung oder nicht aus dem Archiv ausgeführt)") path = get_main_py_path()
filename = os.path.basename(path) if path else None
print(filename)__main__.__file__ist der zuverlässigste Weg, existiert aber nicht immer.sys.argv[0]ist eine Sicherungsmethode, Sie müssen jedoch bestätigen, dass der Wert dies nicht ist-coder<stdin>。
To get the parameter names and their corresponding values of a function in Python, you can use the `inspect` module, which provides introspection utilities. Specifically, `inspect.signature()` can help you retrieve the names of the parameters, and you can pass the current frame's local variables to get their values.
Here is an example that demonstrates how to get the function name, parameter names, and their values:
```python
import inspect
# Sample function
def my_function(a, b, c=5):
# Get the current frame
frame = inspect.currentframe()
# Get the function name
func_name = frame.f_code.co_name
print(f"Function name: {func_name}")
# Get the parameter names and their values
args, _, _, values = inspect.getargvalues(frame)
# Print parameter names and values
for arg in args:
print(f"Parameter name: {arg}, Value: {values[arg]}")
# Call the function
my_function(1, 2)
```
### Output:
```
Function name: my_function
Parameter name: a, Value: 1
Parameter name: b, Value: 2
Parameter name: c, Value: 5
```
### Explanation:
1. **`inspect.currentframe()`**: Retrieves the current execution frame.
2. **`frame.f_code.co_name`**: Extracts the name of the current function.
3. **`inspect.getargvalues(frame)`**: Gets the argument names and their corresponding values from the frame. This function returns a tuple containing:
- `args`: List of argument names.
- `_`: Placeholder for unused information.
- `values`: Dictionary containing argument names as keys and their values.
This allows you to print both the names of the function's parameters and their values at runtime.
In Python können Sie verwendeninspect.signature()Informationen zu Funktionsparametern abrufen,
und weiter wegParameter.annotationDie Eigenschaft erhält für jeden Parameter die Typanmerkung (Typhinweis).
Import prüfen
def my_function(a: int, b: str, c: float = 3.14) -> bool:
return str(a) == b
sig = inspect.signature(my_function)
für Name, Parameter in sig.parameters.items():
print(f"Parametername: {name}")
print(f"Standardwert: {param.default}")
print(f"Typanmerkung: {param.annotation}")
print()Parametername: a
Standard: <class 'inspect._empty'>
Typanmerkung: <class 'int'>
Parametername: b
Standard: <class 'inspect._empty'>
Typanmerkung: <class 'str'>
Parametername: c
Standard: 3.14
Typanmerkung: <class 'float'>param.annotationErhält Typanmerkungen (z. Bint、str）。inspect._empty。get_type_hints()Holen Sie sich das vollständige Typhinweis-Wörterbuch.Diese Methode löst Vorwärtsverweise (als Zeichenfolgen markierte Typen) automatisch auf.
from typing import get_type_hints
hints = get_type_hints(my_function)
print(hints)
{'a': <class 'int'>, 'b': <class 'str'>, 'c': <class 'float'>, 'return': <class 'bool'>}
inspect.signature()Die Parameterreihenfolge und der Name können abgerufen werden.param.annotationSie können die Typanmerkung jedes Parameters überprüfen.get_type_hints()Es ist einfacher, alle Typhinweise (einschließlich Rückgabewerte) auf einmal abzurufen.In Python können Sie die Objekte verwenden__class__Attribut bzwtype()Funktion,
Rufen Sie die Kategorie (Klasse) ab, zu der es gehört, und rufen Sie dann den Kategorienamen ab.
Klasse Tier:
passieren
Klasse Hund (Tier):
passieren
obj = Hund()
#Methode 1: Verwenden Sie __class__.__name__
print(obj.__class__.__name__) # Ausgabe: Hund
#Methode 2: Verwenden Sie type()
print(type(obj).__name__) # Ausgabe: Hund
#Methode 3: Holen Sie sich den vollständigen Modul- und Kategorienamen
print(obj.__class__) # Ausgabe: <class '__main__.Dog'>
print(obj.__class__.__module__) # Ausgabe: __main__
Dog
Dog
<class '__main__.Dog'>
__main__
obj.__class__: Rufen Sie das Kategorieobjekt des Objekts ab.obj.__class__.__name__: Ruft die Kategorienamenzeichenfolge ab.type(obj)Äquivalent zuobj.__class__。__module__: Der Name des Moduls, in dem die Kategorie definiert ist, kann abgerufen werden.Um gleichzeitig den vollständigen „Modul- und Kategorienamen“ zu erhalten, können Sie Folgendes schreiben:
cls = type(obj)
full_name = f"{cls.__module__}.{cls.__name__}"
print(full_name)
__main__.Dog
type(obj).__name__Dies ist der einfachste Weg, den Kategorienamen zu erhalten.f"{obj.__class__.__module__}.{obj.__class__.__name__}"。Im Folgenden finden Sie Beispielcode, der mithilfe von Python ermittelt, zu welcher Vererbungsklasse eine Eigenschaft gehört:
Import prüfen
Klasse BaseClass:
base_attr = „Ich bin ein Attribut von BaseClass“
Klasse SubClass(BaseClass):
sub_attr = „Ich bin ein Attribut aus SubClass“
# Definieren Sie eine Funktion, um die Kategorie zu finden, zu der ein Attribut gehört
def find_attribute_owner(cls, attr_name):
für Basis in inspect.getmro(cls): # MRO abrufen (Reihenfolge der Methodenauflösung)
wenn attr_name in base.__dict__:
Rückkehrbasis
return Keine
# Test
sub_obj = SubClass()
attributes = sub_obj.__class__.__dict__.items() # Alle Attribute auf Kategorieebene abrufen
für Name, Wert in Attributen:
Eigentümer = find_attribute_owner(sub_obj.__class__, Name)
print(f"Attribut '{name}' gehört zur Kategorie: {owner.__name__}")__dict__, das die durch die Kategorie definierten Attribute speichert.Für die Kategorien im Beispiel lauten die Ausführungsergebnisse wie folgt:
Das Attribut „__module__“ gehört zur Klasse: SubClass
Das Attribut „sub_attr“ gehört zur Klasse: SubClass
Das Attribut „__doc__“ gehört zur Klasse: SubClass
Das Attribut „base_attr“ gehört zur Klasse: BaseClassclass MyClass:
def fun1(self):
'''
Fun1 comment
'''
pass
obj = MyClass()
print(obj.fun1.__doc__)
import inspect
class MyClass:
def fun1(self):
'''
Fun1 comment
'''
pass
print(inspect.getdoc(MyClass.fun1))
In Python können Sie die integrierte Funktion verwendenwarningsModule, die Benutzer zur Ausführungszeit (und nicht zur Kompilierungszeit) darauf aufmerksam machen, dass eine Funktion veraltet ist, und neue Alternativen vorschlagen.
Warnungen importieren
def old_function(x, y):
warnings.warn(
„Die Funktion old_function() ist veraltet, bitte verwenden Sie stattdessen new_function(x, y).“,
Kategorie=DeprecationWarning,
Stapelebene=2
)
gib x + y zurück
def neue_Funktion(x, y):
gib x + y zurück
result = old_function(3, 4)
print(result)
DeprecationWarning: Die Funktion old_function() ist veraltet. Bitte verwenden Sie stattdessen new_function(x, y).
Ergebnis = alte_Funktion(3, 4)
7warnings.warn()Die Warnung wird während der Ausführungsphase angezeigt und unterbricht das Programm nicht.category=DeprecationWarningWird zum Markieren von veralteten Warnungen verwendet.stacklevel=2Lassen Sie die Warnmeldung auf den Standort des Anrufers verweisen, nicht innerhalb der Funktion.python -W error::DeprecationWarning your_script.pyDekoratoren können verwendet werden, um zu ermöglichen, dass mehrere alte Funktionen die gleiche Veraltungsaufforderungslogik verwenden:
Warnungen importieren
von functools Import Wraps
definitiv veraltet (new_func_name):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
warnings.warn(
f „Funktion {func.__name__}() ist veraltet, bitte verwenden Sie stattdessen {new_func_name}().“,
Kategorie=DeprecationWarning,
Stapelebene=2
)
return func(*args, **kwargs)
Rückumschlag
zurück Dekorateur
@deprecated("new_function")
def old_function(x, y):
gib x + y zurückIn Python,@staticmethodUnd@classmethodBeide Dekoratoren können Methoden definieren, die aufgerufen werden können, ohne die Klasse zu instanziieren, aber ihr Zweck und ihr Verhalten unterscheiden sich.
@staticmethodakzeptiert kein implizites erstes Argument (keinesselfodercls) Methode. Es ist wie eine normale Funktion und gehört nur zum Namensraum der Klasse.@staticmethod。Klasse MyClass:
@staticmethod
def static_method(x, y):
gib x + y zurück
# Statische Methoden können aufgerufen werden, ohne eine Instanz zu erstellen
result = MyClass.static_method(5, 10) # Ergebnis: 15Fokus：@staticmethodAuf die Kategorie kann nicht zugegriffen werden (cls) oder Instanz (self）。
@classmethodist die Akzeptanzkategorie selbst (cls) als erster Parameter. Dadurch kann auf den Status der Kategorie zugegriffen und dieser geändert werden.@classmethod。Klasse MyClass:
class_variable = 0
def __init__(self, value):
self.value = Wert
MyClass.class_variable += 1
@classmethod
def get_class_variable(cls):
cls.class_variable zurückgeben
#Instanz erstellen
obj1 = MyClass(10)
obj2 = MyClass(20)
# Kategoriemethode aufrufen
print(MyClass.get_class_variable()) # Ergebnis: 2Fokus：@classmethodKann auf den Status auf Kategorieebene zugreifen (cls）。
| Besonderheit | @staticmethod | @classmethod |
|---|---|---|
| erster Parameter | Kein implizites erstes Argument | cls(Kategorie selbst) |
| Zugriffsinstanz | keiner | keiner |
| Zugriffskategorie | keiner | haben |
| Verwendung | Hilfsfunktionen, die sich auf Kategorien beziehen, aber keine Instanzen oder Kategorien erfordern | Sie müssen Daten auf Kategorieebene manipulieren oder alternative Konstruktoren bereitstellen |
Python selbst bietet keine „statische Standardmethode“ oder „Standardklassenmethode“, d. h. die Funktion, eine Methode beim ersten Aufruf einer statischen oder Klassenmethode automatisch auszuführen. Aber wir können ein ähnliches Verhalten durch Lazy-Loading-Techniken erreichen.
Sie können eine statische Variable in der Klasse definieren, um den Initialisierungsstatus zu verfolgen, und dann die Initialisierungslogik ausführen, wenn die statische Methode oder die Klassenmethode zum ersten Mal aufgerufen wird.
Klasse MyClass:
initialized = False # Statische Variable, die verfolgt, ob sie initialisiert wurde
@staticmethod
def init_once():
wenn nicht MyClass.initialized:
print("Ausführung der Initialisierungslogik ...")
MyClass.initialized = True
@classmethod
def class_method(cls):
cls.init_once()
print("Klassenmethode aufrufen")
@staticmethod
def static_method():
MyClass.init_once()
print("Statische Methode aufrufen")
# Rufen Sie die Kategoriemethode zum ersten Mal auf, um die Initialisierung auszulösen
MyClass.class_method() # Ausgabe: Ausführung der Initialisierungslogik...Klassenmethode aufrufen
# Rufen Sie die Kategoriemethode zum zweiten Mal auf und führen Sie keine Initialisierung mehr durch
MyClass.class_method() # Ausgabe: Klassenmethode aufrufen
# Beim ersten Aufruf der statischen Methode wird keine Initialisierung durchgeführt, da sie bereits initialisiert wurde.
MyClass.static_method() # Ausgabe: Statische Methode aufrufeninitialized: Diese Variable wird verwendet, um zu verfolgen, ob die Kategorie initialisiert wurde. Der Anfangswert istFalse。init_once()Verfahren: Diese Methode ist für die Ausführung der Initialisierungslogik verantwortlich und wird ausgeführtinitializedeingestellt aufTrue, um eine wiederholte Initialisierung zu verhindern.Obwohl Python nicht über eine integrierte „statische Standardmethode“ oder „Standardklassenmethode“ verfügt, können Sie durch die Verwendung statischer Variablen und Lazy-Loading-Techniken die Initialisierungslogik automatisch ausführen, wenn die statische Methode oder Klassenmethode zum ersten Mal aufgerufen wird, und sicherstellen, dass diese Logik nur einmal ausgeführt wird.
In Python ist Thread ein Mechanismus zur Implementierung der Parallelität. Es ermöglicht einem Programm, mehrere Aufgaben gleichzeitig innerhalb eines einzigen Prozesses (Prozesses) auszuführen. Dies ist sehr nützlich für die Durchführung von E/A-intensiven Vorgängen (z. B. Netzwerkkommunikation, Lesen und Schreiben von Dateien) und kann verhindern, dass das Programm blockiert (Blockierung) und auf den Abschluss externer Vorgänge wartet.
Im Standard-CPython-Interpreter gibt es eine „Global Interpreter Lock“ (Global Interpreter Lock, GIL). Die GIL stellt sicher, dass jeweils nur ein Thread Python-Bitcode ausführen kann. Das heisst:
multiprocessingModul).threadingPython verwendet die StandardfunktionsbibliothekthreadingModul zur Verarbeitung von Ausführungsthreads. Es gibt zwei Hauptmethoden zur Thread-Erstellung:
Dies ist die einfachste und gebräuchlichste Verwendung.
Threading importieren
Importzeit
def task(name, Verzögerung):
„““Aufgabenfunktion, die vom Thread ausgeführt werden soll““
print(f"Thread {name}: Startet ...")
time.sleep(delay) # Simulieren Sie zeitaufwändige E/A-Vorgänge
print(f"Thread {name}: Aufgabe abgeschlossen.")
#Ausführungsthread erstellen
thread1 = threading.Thread(target=task, args=("T1", 2))
thread2 = threading.Thread(target=task, args=("T2", 4))
# Starten Sie den Thread
thread1.start()
thread2.start()
# Warten Sie, bis alle Threads abgeschlossen sind (blockieren Sie den Hauptthread, bis sie fertig sind)
thread1.join()
thread2.join()
print("Alle Ausführungsthreads wurden abgeschlossen. Das Hauptprogramm wird beendet.")threading.ThreadKategorieGeeignet für komplexere Szenarien, indem die Logik des Ausführungsthreads in einer Kategorie gekapselt wird.
Threading importieren
Importzeit
Klasse MyThread(threading.Thread):
def __init__(selbst, Name, Verzögerung):
super().__init__()
self.name = Name
self.delay = Verzögerung
def run(self):
„““
Wenn der Thread startet, wird die run()-Methode automatisch aufgerufen.
Hier definieren Sie die Aufgaben, die der Thread ausführen soll.
„““
print(f"Thread {self.name}: Starting...")
time.sleep(self.delay)
print(f"Thread {self.name}: Aufgabe abgeschlossen.")
#Erstelle und starte den Thread
thread3 = MyThread("T3", 3)
thread3.start()
thread3.join()
print("Der benutzerdefinierte Ausführungsthread wurde abgeschlossen.")Wenn mehrere Threads auf gemeinsam genutzte Daten zugreifen und diese ändern, kann es zu Race Conditions kommen. Sie müssen einen Synchronisierungsmechanismus verwenden, um Ihre Daten zu schützen:
Lock: Lock ist das grundlegendste Synchronisationsprimitiv. Wird aufgerufen, bevor ein Thread auf eine gemeinsam genutzte Ressource zugreiftlock.acquire(), nach Fertigstellung anrufenlock.release()。RLock(Wiedereintretende Sperre): Ermöglicht demselben Thread, die Sperre mehrmals zu erhalten.Semaphore(Protokoll): Wird verwendet, um die Anzahl der Threads zu begrenzen, die gleichzeitig auf Ressourcen zugreifen können.Threading importieren
# Gemeinsame Ressourcen
Zähler = 0
# Sperre erstellen
lock = threading.Lock()
def increment_counter():
globaler Zähler
# Erhalten Sie die Sperre, um sicherzustellen, dass nur ein Thread diesen Block gleichzeitig ausführen kann
lock.acquire()
Versuchen Sie:
# Wettbewerbsbereich
current_value = Zähler
time.sleep(0.001) # Schalten simulieren
Zähler = aktueller_Wert + 1
schließlich:
# Sperre aufheben
lock.release()
Threads = []
für i im Bereich(100):
t = threading.Thread(target=increment_counter)
threads.append(t)
t.start()
für t in Threads:
t.join()
print(f"Endgültiger Zählerwert: {counter}") # Wenn keine Sperre vorhanden ist, beträgt dieser Wert möglicherweise nicht 100PythonthreadingDas Modul bietet die Funktion zum Erstellen und Verwalten von Ausführungsthreads. Aufgrund von Einschränkungen des Betriebssystems und der Designphilosophie bietet Python jedoch keine sichere, direkte und erzwungene Methode zum Stoppen (Töten) externer Ausführungsthreads. Ein erzwungenes Stoppen kann zu Ressourcenverlust oder Datenbeschädigung führen.
Daher muss das Stoppen des Ausführungsthreads durch einen **kooperativen Mechanismus**** erreicht werden, d. h. indem der Ausführungsthread selbst ein Stoppflag überprüft und ordnungsgemäß beendet wird.
Dies ist die sicherste und am meisten empfohlene Methode zum Stoppen von Threads. Es erfordert, dass der Thread in der Schleife der Ausführung der Aufgabe regelmäßig eine externe Variable (Flag) überprüft.
Threading importieren
Importzeit
# Gemeinsames Stopp-Flag
stop_flag = threading.Event()
defmonitored_task(name,verzögerung):
„““
Eine Aufgabenfunktion, die das Stoppflag regelmäßig überprüft
„““
print(f"Thread {name}: Startet ...")
ich = 0
while not stop_flag.is_set(): # Überprüfen Sie, ob das Flag gesetzt ist
ich += 1
print(f"Thread {name}: Ausführungsschritt {i}")
# Simulieren Sie zeitaufwändige Vorgänge und überprüfen Sie sie regelmäßig
time.sleep(Verzögerung)
# Hier können Sie die Anzahl der Ausführungen begrenzen, um sicherzustellen, dass keine Endlosschleife entsteht
wenn i >= 5:
Pause
print(f"Ausführungsthread {Name}: hat ein Stoppsignal erhalten oder die Aufgabe wurde beendet und ordnungsgemäß beendet.")
# --- Hauptprogramm-Steuerblock ---
#Ausführungsthread erstellen
worker_thread = threading.Thread(target=monitored_task, args=("Worker-1", 1))
# Starten Sie den Thread
worker_thread.start()
print("\nHauptprogramm: Der Ausführungsthread wurde gestartet, warte 3 Sekunden...\n")
time.sleep(3) # Lassen Sie den Thread eine Weile laufen
# Stoppsignal senden
print("\nHauptprogramm: Stopp-Flag setzen...\n")
stop_flag.set() # Event setzen und is_set() True zurückgeben lassen
# Warten Sie, bis der Thread ordnungsgemäß beendet ist, und beenden Sie ihn (normalerweise schnell).
worker_thread.join()
print("\nHauptprogramm: Der Thread wurde sicher gestoppt und beigetreten. Das Programm wurde beendet.")threading.Event(): Ein einfaches Synchronisationsprimitiv. Es verwaltet intern eine Bollinger-Flagge.stop_flag.is_set(): Überprüfen Sie, ob das Flag True ist (d. h. ob ein Stoppsignal ausgegeben wird).stop_flag.set():Setzen Sie das Flag auf True, um ein Stoppsignal zu senden.while not stop_flag.is_set():: Dies ist die Hauptkontrollstruktur des Threads. Solange kein Stoppsignal empfangen wird, wird die Schleife weiter ausgeführt.worker_thread.join(): Stellen Sie sicher, dass das Hauptprogramm auf den Abschluss des Arbeitsthreads (ordnungsgemäßes Beenden) wartet, bevor es mit der Ausführung fortfährt. Dies ist ein wichtiger Schritt, um einen sauberen Abschluss des Eingriffs zu gewährleisten.Obwohl es einige experimentelle oder unsichere Möglichkeiten gibt, einen Stopp zu erzwingen, wie z. B. die Verwendung von „_thread.stop()“ oder das Auslösen einer Ausnahme, können diese Methoden Folgendes verursachen:
Daher sollten Sie in Python immer einen koordinierten Flagging-Mechanismus verwenden, um Threads zu stoppen.
Dies ist der am meisten empfohlene Ansatz in Multithread-Umgebungen. Anstatt dass alle Threads dasselbe Objekt erfassen, verfügt jeder Thread über eine unabhängige Kopie des Objekts. In Python können Sie verwendenthreading.local()zu erreichen.
Threading importieren
# Erstellen Sie einen Thread-Bereich zum Speichern von Objekten
thread_data = threading.local()
def get_service():
# Wenn der aktuelle Thread keinen eigenen Dienst hat, erstellen Sie einen
wenn nicht hasattr(thread_data, 'service'):
print(f"Erstelle eine neue Verbindung für Thread {threading.current_thread().name}")
thread_data.service = create_new_connection()
Geben Sie thread_data.service zurück
def task():
service = get_service()
# Operationen ausführen...Wenn das Objekt identisch sein muss (z. B. in dieselbe Datei schreiben oder mit demselben globalen Zähler arbeiten), müssen Sie es verwendenLock. Dadurch wird sichergestellt, dass nur ein Thread gleichzeitig auf das Objekt zugreifen kann, wodurch Race Conditions vermieden werden.
lock = threading.Lock()
def safe_task():
mit Schloss:
# Innerhalb dieses Blocks müssen andere Threads warten
shared_object.do_something()Wenn Sie das Risiko von Sperrenkonflikten oder Abstürzen vermeiden möchten, die mit mehreren Threads einhergehen, gibt es zwei Hauptalternativen, die Sie in Betracht ziehen sollten:
Dies ist derzeit der beliebteste Ansatz in Python (z. B. das Kernprinzip von FastAPI). Es läuft innerhalb eines einzelnen Threads und wartet auf E/A (z. B. API-Anfragen, Datenbankabfragen), indem es Aufgaben wechselt.
Asynchron importieren
async def fetch_api(url):
# Verwenden Sie asynchrone Bibliotheken wie aiohttp
Antwort = Warten auf call_api(url)
Antwort zurückgeben
async def main():
# Führen Sie mehrere Aufgaben gleichzeitig aus, wechseln Sie jedoch innerhalb eines einzelnen Threads
Ergebnisse = Warten auf asyncio.gather(fetch_api("url1"), fetch_api("url2"))Der Ausführungsthread von Python ist durch GIL (Global Interpreter Lock) eingeschränkt und kann Vorgänge nicht wirklich parallelisieren.multiprocessingEs werden mehrere unabhängige Python-Interpreter-Instanzen geöffnet.
aus dem Multiprocessing-Importprozess
def task(name):
print(f"Prozess {Name} wird ausgeführt")
if __name__ == "__main__":
p = Process(target=task, args=('A',))
p.start()
p.join()Wenn Sie Aufgaben vollständig entkoppeln möchten, können Sie Celery oder Redis Queue verwenden. Legen Sie die Aufgabe in die Warteschlange und lassen Sie sie vom Back-End-Worker (bei dem es sich um mehrere Prozesse oder mehrere Maschinen handeln kann) abholen und ausführen.
---| planen | Lösung | Anwendbare Situationen |
|---|---|---|
| Thread-Local | Jeder Thread erhält eine Kopie | API-Service, Datenbankanbindung |
| Asyncio | Single-Thread-Switching (nicht synchron) | Hohe gleichzeitige Netzwerkanforderungen (empfohlen) |
| Multiprocessing | unabhängiger Speicherplatz | CPU-Computing, wodurch Freigabekonflikte vollständig vermieden werden |
Wenn Sie Thread-Local Storage (TLS) verwenden, besteht der Zweck darin, diese „nicht threadsicheren“ Objekte (z. B. API-Service, Datenbankverbindungen) zu schützen. Wenn jedoch Daten zwischen Threads ausgetauscht werden müssen (z. B. müssen die von Thread A heruntergeladenen Ergebnisse von Thread B verarbeitet werden), müssen Sie einen speziellen „Kommunikationskanal“ einrichten.
Pythonqueue.QueueIst threadsicher. Dies ist die standardmäßigste und sicherste Methode zum Übertragen von Informationen zwischen Threads. Die gesamte Sperrlogik wurde bereits intern verarbeitet.
Threading importieren
Importwarteschlange
# Erstellen Sie eine globale Warteschlange, auf die alle Ausführungsthreads zugreifen können
task_queue = queue.Queue()
def Produzent():
# Daten produzieren und in die Warteschlange stellen
data = {"video_id": "abc", "status": "pending"}
task_queue.put(data)
def Consumer():
# Daten aus der Warteschlange abrufen
data = task_queue.get()
# Daten verarbeiten...
task_queue.task_done()Wenn Sie eine große Liste oder ein großes Wörterbuch freigeben müssen, können Sie allgemeine globale Variablen verwenden, der Zugriff auf sie muss jedoch über einen Abgleich erfolgenthreading.Lock。
shared_results = []
results_lock = threading.Lock()
def task():
result = „Einige Operationsergebnisse“
#Vor dem Zugriff auf freigegebene Ressourcen sperren
mit results_lock:
shared_results.append(result)
# Nach Verlassen des With-Blocks automatisch entsperrenManchmal möchten Sie nicht „Daten“, sondern „Status“ teilen (zum Beispiel: anderen Threads mitteilen, dass die API initialisiert wurde).
api_ready = threading.Event()
def initializer():
#Initialisierung durchführen
api_ready.set() # Signal senden
def worker():
api_ready.wait() # Warten Sie auf das Signal, bis der Initialisierer set() aufruft
print("Beginne zu arbeiten")| Inhaltstyp | Speicherort | Führungsstil |
|---|---|---|
| Werkzeugobjekte(API, DB-Verbindung) | Thread-Local (Region) | Jeder hat eine Kopie, um Abstürze zu vermeiden. |
| Missionsinformationen(ID, Parameter) | Warteschlange (global) | Verwenden Sie die Thread-sichere Warteschlangenübergabe. |
| Berechnungsergebnis(Statistiken) | Globale Liste/Dikt (global) | Muss übereinstimmenthreading.Lock。 |
Um es einfach auszudrücken: ** „Besorgen Sie sich die privaten Tools (Verbindungen) selbst und holen Sie sich die öffentlichen Informationen (Daten) in der Warteschlange (Warteschlange/Sperre).“**
Wenn in einer Multithread-Umgebung mehrere Threads gleichzeitig versuchen, dieselbe globale Variable oder gemeinsam genutzte Ressource (z. B. eine Datei, eine Datenbankverbindung oder eine globale Liste) zu ändern, tritt ein Fehler auf.Rennbedingung, was zu Datenverwirrung führt.threading.LockIst ein Synchronisierungsprimitiv, das sicherstellt, dass jeweils nur ein Thread in einen geschützten Codeblock eintreten kann.
Der sicherste und empfehlenswerteste Weg ist das MatchingwithVerwenden Sie narrative Sätze. Dadurch wird sichergestellt, dass die Sperre auch dann ordnungsgemäß aufgehoben wird, wenn innerhalb des Blocks eine Ausnahme auftritt, um einen Deadlock zu vermeiden.
Threading importieren
# 1. Erstellen Sie ein Sperrobjekt
my_lock = threading.Lock()
shared_counter = 0
def increment_task():
globaler shared_counter
# 2. Verwenden Sie with, um acquire() und release() automatisch zu verwalten
mit my_lock:
# Der Code in diesem Block kann jeweils nur von einem Thread ausgeführt werden
temp = shared_counter
Temperatur += 1
shared_counter = temp
# Starten Sie mehrere Thread-Tests
threads = [threading.Thread(target=increment_task) for _ in range(100)]
für t in Threads: t.start()
für t in Threads: t.join()
print(f"Endgültige Zählung: {shared_counter}")Obwohl dies nicht empfohlen wird, ist manchmal eine feinere Steuerung erforderlich. Sie müssen manuell anrufenacquire()Erwerben Sie das Schloss undfinallyAnrufblockrelease()。
lock = threading.Lock()
def manual_task():
lock.acquire() #Erwerbe die Sperre. Wenn die Sperre bereits belegt ist, wird hier blockiert (wartet).
Versuchen Sie:
# Aufgaben ausführen
passieren
schließlich:
lock.release() # Muss freigegeben werden, sonst können andere Threads nie ausgeführt werdenthreading.LockEs ist nicht reentrant. Das heißt, wenn derselbe Thread die gleiche Sperre erneut anfordert, während er die Sperre bereits hält, wird er sich selbst „sperren“ (Deadlock).
threading.RLock()(Wiedereintrittssperre).Google API ServiceObjekt.Eine übermäßige Verwendung von Sperren führt zu einer Verringerung der Programmleistung, da mehrere Threads „zur Ausführung in die Warteschlange gestellt“ werden. Wenn möglich, geben Sie der Verwendung Vorrangqueue.Queueoder was wir zuvor besprochen habenThread-Local StorageDiese Methoden sind in der Regel effizienter und weniger fehleranfällig als häufiges Sperren.
In Python,async defUndawaitwird realisiertAsynchrone ProgrammierungKernsyntax. Sie verhindern, dass das Programm beim Warten auf E/A-Aufgaben (z. B. Netzwerkanfragen, Lesen von Dateien) hängen bleibt und können stattdessen andere Aufgaben erledigen, was die Leistung erheblich verbessert.
Wenn Sie einer Funktionsdefinition voranstellenasync, wird die Funktion zu aCoroutine-Funktion. Wenn Sie es aufrufen, führt es den Inhalt nicht sofort aus, sondern gibt ein „Coroutine-Objekt“ zurück.
async def fetch_data():
print("Datenabruf starten...")
# Simulieren Sie zeitaufwändige Aufgaben
return {"data": "success"}
# Ein direkter Aufruf ruft nur das Coroutine-Objekt ab und führt keinen Druck aus
result = fetch_data()
print(result) # Ausgabe: <coroutine object fetch_data at ...>awaitkann nur seinasync defFür den internen Gebrauch. Seine Funktion besteht darin, „die aktuelle Coroutine vorübergehend anzuhalten, auf den Abschluss der nachfolgenden Aufgaben zu warten und den Rückgabewert abzurufen“. Während des Wartens kann das System andere asynchrone Aufgaben ausführen.
Asynchron importieren
async def main():
# Verwenden Sie „await“, um die Coroutine auszuführen und die Ergebnisse zu erhalten
data = warte auf fetch_data()
print(f"Ergebnisse erfassen: {data}")
# Starten Sie den Eintrag für asynchrone Programme
asyncio.run(main())| Grammatik | Funktionsbeschreibung | Dinge zu beachten |
|---|---|---|
| async def | Deklarieren Sie eine asynchrone Funktion | Zurückgegeben wird das Coroutine-Objekt, nicht das Ausführungsergebnis. |
| await | Warten Sie, bis die asynchronen Aufgaben abgeschlossen sind | Kann nur innerhalb asynchroner Funktionen geschrieben werden. |
| asyncio.run() | Starten Sie den äußersten asynchronen Eintrag | Ein Programm muss in der Regel nur einmal aufgerufen werden. |
await, du wirst bekommencoroutineObjekt, wenn Sie versuchen, Eigenschaften zu lesen (zresult.text) wird herausspritzen, wennAttributeError。SyntaxError. Sie müssen sicherstellen, dass die äußere Funktion vorhanden istasyncKörperpflege.asyncin Funktionen verwendettime.sleep()Dadurch wird die gesamte Ereignisschleife blockiert. Bitte verwenden Sie stattdessenawait asyncio.sleep()。Stellen Sie sich vor, Sie kochen:
await) Gleichzeitig ruft Sie das Geräusch von kochendem Wasser (Ereignisbenachrichtigung) zurück, um sich darum zu kümmern, wenn Sie Gemüse hacken.loop.run_until_complete()JaasyncioDie untergeordnete Methode im Modul wird verwendet, um die Coroutine auszuführen, bis sie abgeschlossen ist, und das Ergebnis zurückzugeben. Nach Python 3.7, obwohl die Verwendung offiziell empfohlen wirdasyncio.run(), aber Sie müssen diese Methode dennoch in bestimmten Situationen verwenden (z. B. wenn Sie Ereignisschleifen wiederverwenden oder die Startlogik anpassen müssen).
verwendenrun_until_completeSie müssen zunächst ein Ereignisschleifenobjekt abrufen oder erstellen und ihm dann die Coroutine übergeben.
Asynchron importieren
async def my_task():
warte auf asyncio.sleep(1)
Rückgabe „Aufgabe abgeschlossen“
# 1. Ereignisschleife abrufen
loop = asyncio.get_event_loop()
# 2. Führen Sie die Coroutine bis zum Abschluss aus und erhalten Sie den Rückgabewert direkt
result = loop.run_until_complete(my_task())
print(result) #Output: Aufgabe abgeschlossenBeide können den Rückgabewert erhalten, verwalten den Lebenszyklus jedoch unterschiedlich:
| Merkmal | asyncio.run() (empfohlen) | loop.run_until_complete() |
|---|---|---|
| Grad der Automatisierung | hoch. Erstellen und schließen Sie automatisch Schleifen und bereinigen Sie Aufgaben. | Niedrig. Der Lebenszyklus der Schleife muss manuell verwaltet werden. |
| Wiederverwendbarkeit | Niedrig. Jeder Aufruf erzeugt eine neue Schleife. | hoch. Mehrere Aufgaben können in derselben Schleife ausgeführt werden. |
| Nutzungsbeschränkungen | Kann nicht innerhalb einer bereits laufenden Schleife verwendet werden. | Flexibler und häufig in Legacy-Code oder Testumgebungen verwendet. |
Wenn Sie sich in einem Skript befinden, das bereits ausgeführt wird, und sicherstellen möchten, dass eine Coroutine ausgeführt und der Wert erhalten wird, können Sie diese Methode verwenden:
Asynchron importieren
async def add(a, b):
gib a + b zurück
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
Versuchen Sie:
# Führen Sie die erste Aufgabe aus
val1 = loop.run_until_complete(add(10, 20))
#Führen Sie die zweite Aufgabe aus
val2 = loop.run_until_complete(add(val1, 5))
print(f"Endergebnis: {val2}")
schließlich:
# Muss manuell geschlossen werden
loop.close()Wenn Sie möchten, dass mehrere Coroutinen parallel ausgeführt werden und den Rückgabewert einheitlich abrufen, müssen Sie eine Übereinstimmung erzielenasyncio.gather：
asynchrone Def-Aufgabe (ID):
return f"result {id}"
loop = asyncio.get_event_loop()
# Gather packt mehrere Coroutinen in eine Aufgabe und run_until_complete wartet, bis alle abgeschlossen sind.
Ergebnisse = loop.run_until_complete(asyncio.gather(task(1), task(2), task(3)))
print(results) #Output: ['Ergebnis 1', 'Ergebnis 2', 'Ergebnis 3']async defAufruf innerhalb der Funktionrun_until_complete, wird herausspritzenThis event loop is already running. Bitte verwenden Sie es immer innerhalb asynchroner Funktionen.await。loop.close()um Ressourcen freizugeben, da das Programm andernfalls möglicherweise nicht normal beendet wird oder eine Warnung generiert.run_until_completeWird Coroutine zurückgebenreturnWenn in der Coroutine eine nicht abgefangene Ausnahme auftritt, wird die Ausnahme an das aufrufende Ende geworfen.asyncio.run()Es handelt sich um eine High-Level-API, die seit Python 3.7 eingeführt wurde. Dies ist die am meisten empfohlene Methode zum Starten asynchroner Programme. es wird sich automatisch darum kümmernErstellen Sie eine Ereignisschleife, führen Sie die Coroutine aus und schließen Sie die Schleife nach Abschluss. Das Wichtigste ist, dass es direkt an die Coroutine zurückgegeben wirdreturnWert.
Du musst es einfach tunasync defDer an übergebene Funktionsaufrufasyncio.run(), wird das Ergebnis wie eine normale synchrone Funktion zurückgegeben.
Asynchron importieren
async def berechne_score(name):
print(f"Berechnung der Punktzahl von {name}...")
wait asyncio.sleep(1) # Simulieren Sie zeitaufwändige Aufgaben
Rückkehr 95
# Erhalten Sie das Ergebnis der Rückgabe direkt
final_score = asyncio.run(calculate_score("Zhang Xiaoming"))
print(f"Das Endergebnis ist: {final_score}") # Ausgabe: 95Normalerweise definieren wir amain()Funktioniert als Einstiegspunkt und erhält die Ergebnisse aller Unteraufgaben innerhalb und schließlich vonasyncio.run(main())Einheitliche Ausgabe.
async def task_a():
„Apfel“ zurückgeben
async def task_b():
„Banane“ zurückgeben
async def main():
# Verwenden Sie „gather in main“, um gleichzeitig auszuführen
Ergebnisse = Warten auf asyncio.gather(task_a(), task_b())
return results # Gibt eine Liste zurück
# Rufen Sie den Rückgabewert von main über asyncio.run ab
all_fruits = asyncio.run(main())
print(all_fruits) # Ausgabe: ['apple', 'banana']| Regelelemente | veranschaulichen |
|---|---|
| Einzeleingang | Wird in einer Ausführungsfortsetzung normalerweise nur einmal aufgerufenasyncio.run()。 |
| Automatische Reinigung | Es bricht automatisch alle verbleibenden Aufgaben ab und schließt den Thread-Pool, was sehr sicher ist. |
| Verschachtelungsgrenze | kann nichtist schonasync defFunktionsinterner Aufrufasyncio.run()。 |
Wenn Sie sich in einer asynchronen Funktion befinden und versuchen, die Ergebnisse einer anderen asynchronen Funktion abzurufen, verwenden Sieawait, anstattasyncio.run()。
# Fehlerdemonstration
async def sub_task():
Rückkehr 10
async def main():
# Hier tritt ein Fehler auf: RuntimeError: asyncio.run() kann nicht aus einer laufenden Ereignisschleife aufgerufen werden
res = asyncio.run(sub_task())
# Richtige Korrektur
async def main():
res = wait sub_task() # Bitte verwenden Sie „await“ in einer asynchronen Umgebungasyncio.run()Platzieren Sie es als Startknopf des Programmsif __name__ == "__main__":im Block.asyncio.run()Die Ausnahme wird direkt ausgelöst. Es wird empfohlenrundie äußere Schicht plustry...except。asyncio.run()kann intakt entnommen werden.NumPy(Numerical Python) ist die wichtigste wissenschaftliche Computerbibliothek in Python. Es bietet effiziente mehrdimensionale Array-Objektendarrayund eine große Bibliothek mathematischer Funktionen zum Bearbeiten dieser Arrays. Es ist die grundlegende Säule der Datenwissenschaft, des maschinellen Lernens (wie Pandas, Scikit-learn, TensorFlow) und anderer Bereiche.
forKreis.numpy als np importieren
# Erstellen Sie eindimensionale und zweidimensionale Arrays
arr1 = np.array([1, 2, 3])
arr2 = np.array([[1, 2], [3, 4]])
# Erstellen Sie schnell ein bestimmtes Array
nullen = np.zeros((3, 3)) # 3x3-Matrix mit allen Nullen
ones = np.ones((2, 4)) # 2x4-Matrix mit allen Einsen
eye = np.eye(3) # 3x3 Identitätsmatrix
range_arr = np.arange(0, 10, 2) # [0, 2, 4, 6, 8]| Funktion | Codebeispiel | veranschaulichen |
|---|---|---|
| Formprüfung | arr.shape |
Gibt die Größe jeder Dimension zurück (z. B. (3, 2)). |
| Form ändern | arr.reshape(1, 6) |
Ändern Sie Dimensionen, ohne die Daten zu ändern. |
| Matrixmultiplikation | np.dot(a, b)odera @ b |
Führen Sie eine Matrixmultiplikation in der linearen Algebra durch. |
| statistische Funktion | np.mean(), np.std() |
Berechnen Sie den Mittelwert, die Standardabweichung sowie die Maximal- und Minimalwerte. |
Die Slicing-Syntax von NumPy ähnelt der von Python List, ist jedoch leistungsfähiger und unterstützt mehrdimensionales gleichzeitiges Slicing:
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# Holen Sie sich die zweite Spalte (Index 1)
print(arr[1, :]) # [4, 5, 6]
# Holen Sie sich die 2x2-Submatrix in der unteren rechten Ecke
print(arr[1:, 1:]) # [[5, 6], [8, 9]]pip install numpyoderconda install numpy。import numpy as np
print(np.__version__)Wie bereits erwähnt,NumbaEs kann die Array-Struktur von NumPy perfekt erkennen und komplexe NumPy-Operationen weiter in Maschinencode kompilieren, wodurch die Ausführungsgrenze nahe der nativen C-Sprache erreicht wird.
NumbaEs handelt sich um einen Open-Source-JIT-Compiler (Just-In-Time), der speziell zur Beschleunigung von Python-Code entwickelt wurde, der große Datenmengen verarbeitet. Es kann Python-Funktionen mit einer mit C, C++ oder Fortran vergleichbaren Ausführungsgeschwindigkeit in Maschinencode übersetzen und eignet sich besonders fürNumPyArray-Operationen.
Der einfachste Weg, Numba zu verwenden, ist das Hinzufügen@jitoder@njitDekorateur.
von numba import njit
numpy als np importieren
# @njit stellt den „nopython“-Modus dar, der sicherstellt, dass der Python-Parser nicht aufgerufen wird, und der am schnellsten ist
@njit
def fast_function(n):
gesamt=0
für i im Bereich(n):
insgesamt += i
Gesamtrücklauf
# Der erste Aufruf wird kompiliert, der zweite Aufruf führt den Maschinencode direkt aus
print(fast_function(10000000))| Modell | Dekorateur | veranschaulichen |
|---|---|---|
| Nopython-Modus | @njit |
Empfohlen.Vollständig vom Python-Interpreter getrennt und direkt in Maschinencode kompiliert. Enthält der Programmcode Teile, die nicht kompilierbar sind, wird ein Fehler gemeldet. |
| Objektmodus | @jit |
Wenn es nicht kompiliert werden kann, wird es zur Ausführung auf den Python-Parser zurückgegriffen. Leistungsverbesserungen sind normalerweise begrenzt. |
Um die Multi-Core-Fähigkeiten Ihrer CPU zu nutzen, schalten Sie sie einfach einparallel=Trueund verwendenprange。
from numba import njit, prange
@njit(parallel=True)
def parallel_sum(A):
s = 0
# prange weist Schleifen automatisch verschiedenen CPU-Kernen zu
für i in prange(A.shape[0]):
s += A[i]
Rückkehr spip install numbaoderconda install numba。llvmliteBibliothek).import numba
print(numba.__version__)dict、listOder die Leistung beim Anpassen von Objekten ist schlecht.Pandas ist ein Python-basiertes Datenanalyse- und -manipulationstool, das für die Verarbeitung strukturierter Daten wie Tabellendaten oder Zeitreihendaten entwickelt wurde.
Pandas als PD importieren
# DataFrame erstellen
data = {'Name': ['Alice', 'Bob', 'Charlie'],
'Alter': [25, 30, 35],
'Stadt': ['Taipei', 'Taichung', 'Kaohsiung']}
df = pd.DataFrame(data)
# Daten anzeigen
drucken(df)
# Informationen filtern, die älter als 28 sind
filtered_df = df[df['age'] > 28]
print(filtered_df)
Pandas bietet effiziente, flexible und intuitive Bedienmethoden, die sich besonders für die Datenanalyse und -verarbeitung eignen. Es ist eines der unverzichtbaren Werkzeuge in der Datenwissenschaft und im maschinellen Lernen.
Pandas ist ein leistungsstarkes Datenanalysetool und sowohl Anfänger als auch Fortgeschrittene können von seinem benutzerfreundlichen Design und der umfangreichen Funktionalität profitieren.
Zuerst müssen Sie installierengoogletransBausatz. Geben Sie in der Befehlszeile den folgenden Befehl ein:
pip install googletrans==4.0.0-rc1Hinweis: Bitte bestätigen Sie bei der Installation die Version4.0.0-rc1, da ältere Versionen möglicherweise nicht mehr funktionieren.
Hier ist ein Beispiel für die Übersetzung von Englisch ins traditionelle Chinesisch:
vom Googletrans-Importübersetzer
#Initialisieren Sie das Translator-Objekt
Übersetzer = Übersetzer()
# Text übersetzen
text = „Hallo, wie geht es dir?“
result = translator.translate(text, src="en", dest="zh-tw")
# Übersetzungsergebnisse ausgeben
print("Originaltext:", Text)
print("Übersetzung:", result.text)Sie können mehrere Sprachen übersetzen. Hier sind die allgemeinen Sprachcodes:
enzh-twzh-cnjakofrdeGoogletrans ist eine inoffizielle Google Translate-API und funktioniert aufgrund von Änderungen seitens Google möglicherweise nicht mehr. Wenn Sie feststellen, dass die Übersetzungsfunktion nicht funktioniert, ziehen Sie bitte die Verwendung anderer Übersetzungs-APIs in Betracht, beispielsweise die offizielle Cloud-Übersetzung von Google API.
DeepL bietet hochpräzise Übersetzungsdienste, erfordert jedoch einen API-Schlüssel, um seine Entwickler-API zu verwenden.
Das von Microsoft bereitgestellte Übersetzungstool unterstützt mehrsprachige Übersetzungen, erfordert jedoch die Verwendung von Azure-API-Schlüsseleinstellungen.
Der von Amazon Web Services (AWS) bereitgestellte Übersetzungsdienst ermöglicht die effiziente Übersetzung mehrsprachiger Texte und muss über den von AWS bereitgestellten API-Schlüssel aufgerufen werden.
LibreTranslate ist ein Open-Source-Übersetzungstool, das einen eigenen Server einrichten kann und keinen API-Schlüssel benötigt. Einige öffentliche Server von Drittanbietern bieten auch die Möglichkeit, diese ohne API-Schlüssel zu verwenden.
TextBlob ist ein auf der Verarbeitung natürlicher Sprache basierendes Tool mit integrierter Google Translate-Funktionalität. Ältere Versionen erfordern jedoch keinen API-Schlüssel und müssen möglicherweise auf die Versionsunterstützung achten.
MyMemory bietet speicherbasierte Übersetzung. Für einige Funktionen ist kein API-Schlüssel erforderlich, für die erweiterte Nutzung ist jedoch möglicherweise eine Anwendung erforderlich.
Unter den Konkurrenten von Googletrans bieten LibreTranslate und einige Versionen von TextBlob Optionen, die keinen API-Schlüssel erfordern. Wenn Sie ein Tool benötigen, das völlig kostenlos ist und keine zusätzliche Einrichtung erfordert, sollten Sie diese Optionen in Betracht ziehen.
OpenCC(Open Chinese Convert) ist ein Open-Source-Projekt, das sich der Konvertierung von vereinfachtem Chinesisch in traditionelles Chinesisch widmet. Es handelt sich nicht nur um eine einfache Wort-zu-Wort-Konvertierung, sondern, was noch wichtiger ist, es funktioniertWortschatzniveauKonvertierung und Unterschiede in den Wortgebrauchsgewohnheiten in verschiedenen Regionen (Festlandchina, Taiwan, Hongkong).
In Python ist die am häufigsten verwendete Verpackungsbibliothekopencc-python-reimplemented。
# Installationsanweisungen
pip install opencc-python-reimplemented
# Grundlegendes Codebeispiel
aus opencc importieren OpenCC
# Initialisierung, s2t steht für Simplified to Traditional (vereinfacht zu traditionell)
cc = OpenCC('s2t')
text = „Künstliche Intelligenz hat die Welt verändert“
Ergebnis = cc.convert(text)
print(result) #Output: Künstliche Intelligenz hat die Welt verändert| Schemaname | veranschaulichen | Anwendbare Situationen |
|---|---|---|
| s2t | Vereinfachtes Chinesisch zu traditionellem Chinesisch | Konvertieren Sie Standardzeichen von einfach in traditionell. |
| t2s | Traditionelles Chinesisch bis vereinfachtes Chinesisch | Standardzeichen werden von traditionell in vereinfacht umgewandelt. |
| s2twp | Vereinfachtes Chinesisch in taiwanesisches traditionelles Chinesisch (einschließlich Wortschatz) | Am häufigsten in Taiwan verwendet.Wandelt „Software“ in „Software“ um. |
| tw2s | Traditionelles Taiwan-Chinesisch bis vereinfachtes Chinesisch | Konvertieren Sie taiwanesische Redewendungen in vereinfachtes Chinesisch vom chinesischen Festland. |
| s2hk | Vereinfacht zu Hong Kong Traditional | Es entspricht den Wortgebrauchsgewohnheiten in Hongkong (z. B. wird „里“ in „里“ geändert). |
Wenn Sie kein Programm schreiben möchten, kann OpenCC auch direkt im Terminal bedient werden:
# Konvertieren Sie „input.txt“ in „output.txt“ im vereinfachten in den traditionellen taiwanesischen Modus
opencc -i input.txt -o output.txt -c s2twp.jsonreimplementedVersion..jsonDateidefinitionen: Sie können zum OpenCC-Installationsverzeichnis gehen, um zu sehen, wie diese Wörterbücher funktionieren.Das folgende Beispiel zeigt, wie Sie mit Python die gesamte phonetische Notation chinesischer Schriftzeichen abfragen. wir nutzenpypinyinKit zum Ermitteln des Pinyin chinesischer Schriftzeichen und zum Anpassen der Entsprechungstabelle von Pinyin zu phonetischen Symbolen.
pip install pypinyinDas Folgende ist der Python-Code, einschließlich der phonetischen Korrespondenztabelle und der Programmlogik zum Abfragen und Generieren von HTML-Ergebnissen.
aus Pypinyin Pinyin importieren, Stil
aus der Jinja2-Importvorlage
# Einfache Korrespondenztabelle von Pinyin nach Zhuyin
pinyin_to_zhuyin = {
„a“: „ㄚ“, „ai“: „ㄞ“, „an“: „ㄢ“, „ang“: „ㄤ“, „ao“: „ㄠ“,
„ba“: „ㄅㄚ“, „bai“: „ㄅㄞ“, „ban“: „ㄅㄢ“, „bang“: „ㄅㄤ“, „bao“: „ㄅㄠ“,
# Lassen Sie einige Korrespondenzen aus und müssen Sie diese selbst verbessern
„hao“: „ㄏㄠ“, „hao“: „ㄏㄠ“, „hǎo“: „ㄏㄠˇ“, „hào“: „ㄏㄠˋ“
}
# Fragen Sie alle Pinyin-Zeichen chinesischer Schriftzeichen ab und konvertieren Sie sie in Pinyin
def get_zhuyin(char):
pinyins = pinyin(char, style=Style.NORMAL, heteronym=True)
unique_pinyins = set(pinyins[0])
zhuyins = {p: pinyin_to_zhuyin.get(p, p) for p in unique_pinyins} # Konvertieren Sie Pinyin in Zhuyin
Rückgabeliste(zhuyins.values())
# Zeichen abfragen
chinese_char = 'good' # kann durch andere Zeichen ersetzt werden
zhuyin_results = get_zhuyin(chinese_char)pinyin_to_zhuyinWörterbuch zur Zuordnung von Pinyin zu phonetischen Symbolen. Diese Korrespondenztabelle muss selbst erweitert werden.heteronym=TrueStellen Sie sicher, dass alle Aussprachen multiphonetischer Zeichen angezeigt werden.Betriebssystem importieren
# Überprüfen Sie, ob es sich um eine Datei handelt
if os.path.isfile("example.txt"):
print("Datei existiert")
# Überprüfen Sie, ob es sich um einen Ordner handelt
if os.path.isdir("my_folder"):
print("Der Ordner existiert")
# Überprüfen Sie, ob die Datei oder der Ordner vorhanden ist
wenn os.path.exists("path/to/check"):
print("Pfad vorhanden")aus pathlib import Path
path = Path("example.txt")
wenn path.exists():
print("Pfad vorhanden")
if path.is_file():
print("ist eine Datei")
if path.is_dir():
print("Es ist ein Ordner")In Python ist das standardmäßigste und leistungsstärkste Modul zum Kopieren, Verschieben, Umbenennen und Löschen von Dateienshutil(für hochrangige Operationen) undos(für grundlegende Pfadoperationen).
Der Kopiervorgang hat unterschiedliche Funktionen, je nachdem, ob Metadaten erhalten bleiben müssen (z. B. Erstellungszeitpunkt, Berechtigungen):
Shutil importieren
# Eine einzelne Datei kopieren
Shutil.copy2('source.txt', 'destination.txt')
# Kopieren Sie den gesamten Ordner (der Zielordner darf nicht existieren)
Shutil.copytree('my_folder', 'backup_folder')Die zugrunde liegende Logik des Verschiebens und Umbenennens ist sehr ähnlich. verwendenshutil.moveKann währenddessen plattenübergreifend ausgeführt werdenos.renameEs wird häufig verwendet, um dieselbe Festplatte umzubenennen.
| Funktion | Allgemeine Befehle | veranschaulichen |
|---|---|---|
| Verschieben Sie Dateien oder Verzeichnisse | shutil.move(src, dst) |
Verschieben Sie Dateien oder ganze Verzeichnisse in neue Pfade und unterstützen Sie so mehrere Partitionen. |
| Datei umbenennen | os.rename(old, new) |
Datei- oder Verzeichnisnamen ändern. |
Shutil importieren
Betriebssystem importieren
# Dateien verschieben
Shutil.move('test.txt', 'archive/test.txt')
# Umbenennen
os.rename('old_name.txt', 'new_name.txt')Löschvorgänge sollten mit Vorsicht verwendet werden, da diese Befehle normalerweise nicht über den Papierkorb wandern, sondern sie direkt dauerhaft entfernen.
# Eine einzelne Datei löschen
wenn os.path.exists('temp.txt'):
os.remove('temp.txt')
# Den gesamten Ordner zwangsweise löschen
Shutil.rmtree('old_data_folder')Überprüfen Sie vor dem Kopieren oder Verschieben, ob der Pfad vorhanden ist, um Programmabstürze zu vermeiden:
os.path.join()oderpathlibModul zum Kombinieren von Pfaden, um sicherzustellen, dass das Programm zwischen Windows (Backslashes) und Linux (Schrägstriche) funktioniert.try...exceptPack.shutil.copyUndshutil.moveWenn im Zielpfad bereits eine Datei mit demselben Namen vorhanden ist, wird diese normalerweise direkt überschrieben. Vor der Ausführung sollten Sie bestätigen, ob eine Umbenennung erforderlich ist, um dies zu vermeiden.PythonloggingDie Suite ist ein leistungsstarkes integriertes Set für die effektive Protokollverwaltung in Anwendungen. Ob Protokollierung von Debugging-Informationen, Fehlerverfolgung oder Leistungsüberwachung,loggingJede Suite kann Protokollierungsmethoden auf mehreren Ebenen und in mehreren Formaten bereitstellen.
DEBUG、INFO、WARNING、ERRORUndCRITICAL。Hier ist eine grundlegendeloggingBeispiel für eine Kit-Konfiguration:
Protokollierung importieren
# Logger einstellen
logger = logging.getLogger('my_logger')
logger.setLevel(logging.DEBUG)
# Handler festlegen
console_handler = logging.StreamHandler()
file_handler = logging.FileHandler('app.log')
# Formatierer festlegen
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)
# Handler zum Logger hinzufügen
logger.addHandler(console_handler)
logger.addHandler(file_handler)
# Testen Sie verschiedene Protokollebenen
logger.debug('Dies ist eine Debug-Nachricht')
logger.info('Dies ist eine Informationsnachricht')
logger.warning('Dies ist eine Warnmeldung')
logger.error('Dies ist eine Fehlermeldung')
logger.critical('Dies ist eine ernste Nachricht')loggingDie folgenden Protokollebenen werden unterstützt:
DEBUG: Die unterste Ebene, die für Debugging-Informationen verwendet wird.INFO: Allgemeine Informationen, z. B. Systembetriebsstatus.WARNING: Warninformationen, die jedoch nicht zum Stoppen des Programms führen.ERROR: Fehlerinformationen, die normalerweise aufgrund von Fehlern zu Problemen führen.CRITICAL: Der schwerwiegendste Fehler, der zum Beenden des Programms führen kann.Kann verwendet werdenFormatterKlasse zum Definieren des Ausgabeformats des Protokolls. Zum Beispiel:
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')Dieses Format gibt etwa Folgendes aus:
25.10.2024 10:00:00 – my_logger – INFO – Dies ist eine InformationsmeldungloggingDie Suite bietet eine Vielzahl von Protokollverwaltungsoptionen, die es Entwicklern ermöglichen, Protokollebenen, Ausgabeformate und Ziele je nach Bedarf anzupassen und so die Wartbarkeit und Debugging-Effizienz von Anwendungen zu verbessern.
in Pythonloggingim Bausatz,HandlerEs ist eine Schlüsselkomponente, die für die Definition des Ausgabeorts des Protokolls verantwortlich ist. Verschiedene Prozessoren können Protokolle an unterschiedliche Ziele ausgeben, darunter die Konsole, eine Datei, das Netzwerk und sogar E-Mail.StreamHandlerAls einer der am häufigsten verwendeten Prozessoren ist er für die Ausgabe von Protokollen an die Konsole verantwortlich.
existierenlogging, einige häufigHandlerenthalten:
StreamHandler: Das Protokoll ausgeben anstdoutoderstderr(normalerweise die Konsole).FileHandler: Protokolle in eine Datei ausgeben.NullHandler: Protokollausgabe ignorieren, geeignet für Situationen, in denen keine Anzeige erforderlich ist.SMTPHandler: Protokolle per E-Mail senden.StreamHandlerist der am häufigsten verwendete Prozessor für die Konsolenausgabe. Er sendet normalerweise Protokollmeldungen an den Standardfehler (stderr). durch EinstellungenStreamHandler, wodurch die Protokolle direkt auf der Konsole angezeigt werden können und sich für die Echtzeitüberwachung des Systemstatus eignen.
Wenn Sie nicht möchten, dass die Protokolle auf der Konsole angezeigt werden, können Sie sie aus dem Logger entfernenStreamHandler, oder stattdessen verwendenNullHandlerAusgabe zu vermeiden.
Das folgende Beispiel zeigt die Konfigurationloggingund entfernen Sie die KonsolenausgabeStreamHandler：
Protokollierung importieren
# Logger einstellen
logger = logging.getLogger('my_logger')
logger.setLevel(logging.DEBUG)
# StreamHandler zur Ausgabe an die Konsole hinzufügen
console_handler = logging.StreamHandler()
logger.addHandler(console_handler)
# Testausgabe
logger.info("Diese Meldung wird auf der Konsole angezeigt")
# Konsolenausgabe entfernen
logger.removeHandler(console_handler)
logger.info("Diese Meldung wird nicht auf der Konsole angezeigt")Kann verwendet werdenNullHandlerSo deaktivieren Sie die gesamte Ausgabe des Protokolls:
Protokollierung importieren
# Logger einrichten und NullHandler hinzufügen
logger = logging.getLogger('my_logger')
logger.addHandler(logging.NullHandler())
# Diese Meldung wird nicht in der Konsole angezeigt
logger.info("Diese Meldung wird nicht angezeigt")HandlerJaloggingEine Komponente in einer Suite, die den Ausgabeort definiert. durchStreamHandlerkönnen Protokollmeldungen zur Echtzeitüberwachung auf der Konsole angezeigt werden. Wenn die Konsolenausgabe nicht benötigt wird, kann sie entfernt werdenStreamHandleroder verwendenNullHandlerum die Protokollierungsausgabe zu deaktivieren.
Um eine Thread-ID in logging.Formatter einzuschließen, können Sie die verwenden%(thread)dEigentum. Hier wird die eindeutige Ganzzahl-ID angezeigt, die dem Thread vom System zugewiesen wurde.
Protokollierung importieren
# %(thread)d hinzufügen, um die Thread-ID anzuzeigen
log_formatter = logging.Formatter(
'%(asctime)s.%(msecs)03d %(thread)d %(levelno)s %(message)s',
„%Y-%m-%d %H:%M:%S“
)
#Beispielausgabe:
# 2025-12-20 16:30:45.123 140735612345678 20 Dies ist eine ProtokollnachrichtZusätzlich zur ganzzahligen ID können Sie je nach Bedarf auch den Namen des Threads anzeigen lassen:
Dieser Code zeigt, wie dieses Format in einer Multithread-Umgebung angewendet wird:
Protokollierung importieren
Threading importieren
# 1. Formatierer einstellen
log_format = '%(asctime)s.%(msecs)03d [Thread:%(thread)d] %(levelno)s %(message)s'
date_format = „%Y-%m-%d %H:%M:%S“
formatter = logging.Formatter(log_format, date_format)
# 2. Protokollprozessor einstellen
handler = logging.StreamHandler()
handler.setFormatter(formatter)
logger = logging.getLogger("ThreadTest")
logger.addHandler(handler)
logger.setLevel(logging.INFO)
# 3. Testfunktion
def task():
logger.info("Subthread wird ausgeführt")
# Beginnen Sie mit dem Testen
logger.info("Hauptthread gestartet")
t = threading.Thread(target=task)
t.start()
t.join()Python bietet integrierte SQLite-Unterstützung und eignet sich für kleine Anwendungen.
import sqlite3
conn = sqlite3.connect("example.db")
cursor = conn.cursor()
cursor.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)")
cursor.execute("INSERT INTO users (name) VALUES (?)", ("Alice",))
conn.commit()
cursor.execute("SELECT * FROM users")
print(cursor.fetchall())
cursor.close()
conn.close()Wird verwendet, um eine Verbindung zur MySQL-Datenbank herzustellen.
pip install pymysqlimport pymysql
conn = pymysql.connect(host="localhost", user="root", password="password", database="test")
cursor = conn.cursor()
cursor.execute("SELECT * FROM users")
print(cursor.fetchall())
cursor.close()
conn.close()Wird zur Verbindung mit PostgreSQL verwendet.
pip install psycopg2import psycopg2
conn = psycopg2.connect(dbname="testdb", user="user", password="password", host="localhost")
cursor = conn.cursor()
cursor.execute("SELECT * FROM users")
print(cursor.fetchall())
cursor.close()
conn.close()Wird zur Verbindung mit Microsoft SQL Server verwendet.
pip install pyodbcimport pyodbc
conn = pyodbc.connect("DRIVER={SQL Server}; SERVER=localhost; DATABASE=test; UID=user; PWD=password")
cursor = conn.cursor()
cursor.execute("SELECT * FROM users")
print(cursor.fetchall())
cursor.close()
conn.close()Geeignet für dateibasierte Datenbanken.
pip install pymongoimport pymongo
client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["testdb"]
collection = db["users"]
collection.insert_one({"name": "Alice", "age": 25})
print(list(collection.find()))Geeignet für Caching und leistungsstarken Schlüsselwertzugriff.
pip install redisimport redis
r = redis.Redis(host="localhost", port=6379, decode_responses=True)
r.set("name", "Alice")
print(r.get("name"))Geeignet für die Volltextsuche und -analyse.
pip install elasticsearchfrom elasticsearch import Elasticsearch
es = Elasticsearch("http://localhost:9200")
doc = {"name": "Alice", "age": 25}
es.index(index="users", document=doc)
print(es.search(index="users", query={"match_all": {}}))Unterstützt mehrere SQL-Datenbanken und bietet ORM-Funktionen.
pip install sqlalchemyfrom sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import declarative_base, sessionmaker
engine = create_engine("sqlite:///example.db")
Base = declarative_base()
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True)
name = Column(String)
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()
session.add(User(name="Alice"))
session.commit()
print(session.query(User).all())sqlite3(eingebaut),pymysql（MySQL）、psycopg2（PostgreSQL）、pyodbc（SQL Server）。pymongo（MongoDB）、redis（Redis）、elasticsearch（Elasticsearch）。SQLAlchemy(Unterstützt mehrere SQL-Datenbanken).Installieren Sie PyMySQL mithilfe der folgenden Anweisungen:
pip install pymysqlVerwenden Sie PyMySQL, um eine Verbindung zum MySQL-Server herzustellen:
importpymysql
# Verbindung herstellen
conn = pymysql.connect(
host="localhost",
user="Ihr_Benutzer",
Passwort="Ihr_Passwort",
Datenbank="Ihre_Datenbank",
charset="utf8mb4",
Cursorclass=pymysql.cursors.DictCursor # Wörterbuchformat zurückgeben
)
#Cursor erstellen
Cursor = conn.cursor()
# Informationen abfragen
Cursor.execute("SELECT * FROM your_table")
Ergebnis = Cursor.fetchall()
für Zeile im Ergebnis:
drucken(Zeile)
# Verbindung schließen
Cursor.close()
conn.close()Beim Ausführen von INSERT-, UPDATE- und DELETE-Anweisungen müssen Änderungen übermittelt werden:
Versuchen Sie:
mit conn.cursor() als Cursor:
sql = „INSERT INTO Benutzer (Name, Alter) VALUES (%s, %s)“
Cursor.execute(sql, ("Alice", 25))
conn.commit() # Änderungen übermitteln
außer Ausnahme als e:
conn.rollback() # Rollback, wenn ein Fehler auftritt
print("Es ist ein Fehler aufgetreten:", e)Kann verwendet werdencallprocRufen Sie die gespeicherte Prozedur auf:
with conn.cursor() as cursor:
cursor.callproc("your_stored_procedure", (param1, param2))
result = cursor.fetchall()
print(result)verwendenexecutemanySo führen Sie Masseneinfügungen durch:
data = [("Bob", 30), ("Charlie", 28), ("David", 35)]
sql = "INSERT INTO users (name, age) VALUES (%s, %s)"
with conn.cursor() as cursor:
cursor.executemany(sql, data)
conn.commit()Verwenden Sie parametrisierte Abfragen, um SQL-Injection-Angriffe zu verhindern:
name = "Alice"
sql = "SELECT * FROM users WHERE name = %s"
with conn.cursor() as cursor:
cursor.execute(sql, (name,))
result = cursor.fetchall()
print(result)Stellen Sie sicher, dass Sie die Datenbankverbindung schließen, wenn das Programm beendet wird:
conn.close()PyMySQL wird automatischdatetime.datetimeKonvertiert in MySQL DATETIME und kann direkt übergeben werden.
import pymysql
import datetime
conn = pymysql.connect(
host="localhost",
user="root",
password="pwd",
database="testdb",
cursorclass=pymysql.cursors.DictCursor
)
with conn:
with conn.cursor() as cur:
now = datetime.datetime.now()
sql = """
INSERT INTO logs (msg, created_at)
VALUES (%s, %s)
"""
cur.execute(sql, ("hello world", now))
conn.commit()
today = datetime.date.today()
sql = "INSERT INTO records (start_date) VALUES (%s)"
cur.execute(sql, (today,))
conn.commit()
Das gefundene Feld wird automatisch zudatetime.datetimeTyp.
sql = „SELECT id,created_at FROM logs ORDER BY id DESC LIMIT 1“
cur.execute(sql)
row = cur.fetchone()
dt = row["created_at"]
print(dt, type(dt))
# Zum Beispiel: 2025-07-01 15:22:33
formatted = dt.strftime("%Y-%m-%d %H:%M:%S")
print(formatted)
start = datetime.datetime(2025, 1, 1, 0, 0, 0)
sql = """
SELECT * FROM logs
WHERE created_at >= %s
"""
cur.execute(sql, (start,))
rows = cur.fetchall()
begin = datetime.datetime(2025, 1, 1)
end = datetime.datetime(2025, 1, 31, 23, 59, 59)
sql = """
SELECT * FROM logs
WHERE created_at BETWEEN %s AND %s
"""
cur.execute(sql, (begin, end))
rows = cur.fetchall()
sql = "SELECT created_at FROM logs_str LIMIT 1"
cur.execute(sql)
row = cur.fetchone()
dt = datetime.datetime.strptime(row["created_at"], "%Y-%m-%d %H:%M:%S")
print(dt)
items = [
("log1", datetime.datetime.now()),
("log2", datetime.datetime.now()),
]
sql = "INSERT INTO logs (msg, created_at) VALUES (%s, %s)"
cur.executemany(sql, items)
conn.commit()
strptimeManuelles Parsen.importpymysql
Datum/Uhrzeit importieren
# Datenbankverbindung herstellen
conn = pymysql.connect(
host='localhost',
user='root',
passwort='Ihr_Passwort',
Datenbank='Ihre_Datenbank',
Cursorclass=pymysql.cursors.DictCursor # Felder als Wörterbuch zurückgeben
)
mit Verbindung:
mit conn.cursor() als Cursor:
sql = „SELECT id,created_at FROM your_table LIMIT 1“
Cursor.execute(sql)
Ergebnis = Cursor.fetchone()
dt = result['created_at'] # Angenommen, das Feld „created_at“ ist vom Typ datetime
drucken(dt)
print(type(dt))dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
print(dt_str)# Wenn „created_at“ im String-Format gespeichert wird (z. B. CHAR / VARCHAR)
dt = datetime.datetime.strptime(result['created_at'], "%Y-%m-%d %H:%M:%S")
drucken(dt)# Wenn DictCursor nicht festgelegt ist, handelt es sich bei den Daten um Tupel und die Wertmethode lautet wie folgt:
Cursor = conn.cursor()
Cursor.execute("SELECT id,created_at FROM your_table")
row = Cursor.fetchone()
dt = Zeile[1]importpymysql
Datum/Uhrzeit importieren
# Datenbankverbindung herstellen
conn = pymysql.connect(
host='localhost',
user='root',
passwort='Ihr_Passwort',
Datenbank='Ihre_Datenbank',
Cursorclass=pymysql.cursors.DictCursor
)
mit Verbindung:
mit conn.cursor() als Cursor:
sql = „SELECTcreated_at FROM your_table LIMIT 1“
Cursor.execute(sql)
Ergebnis = Cursor.fetchone()
dt_from_sql = result['created_at'] # datetime-Typ
now = datetime.datetime.now()
# Zeitunterschied berechnen
diff = now - dt_from_sql
print(f"Differenz in Tagen: {diff.days}")diff = now.date() - dt_from_sql.date()
print(f"Reine Datumsdifferenz, Anzahl der Tage: {diff.days}")importpymysql
Datum/Uhrzeit importieren
# Datenbankverbindung herstellen
conn = pymysql.connect(
host='localhost',
user='root',
passwort='Ihr_Passwort',
Datenbank='Ihre_Datenbank',
Cursorclass=pymysql.cursors.DictCursor
)
mit Verbindung:
mit conn.cursor() als Cursor:
sql = „SELECTcreated_at FROM your_table LIMIT 1“
Cursor.execute(sql)
Ergebnis = Cursor.fetchone()
dt_from_sql = result['created_at'] # datetime-Typ
now = datetime.datetime.now()
# Zeitunterschied berechnen
diff = now - dt_from_sql
Stunden = diff.total_seconds() / 3600
print(f"Differenz in Stunden: {hours}")print(f"Die Differenz ist eine ganzzahlige Anzahl von Stunden: {int(hours)}")In InnoDB, der Standardspeicher-Engine von MySQL, ist die StandardisolationsstufeREPEATABLE READ(wiederholbare Lektüre).
Dies bedeutet, dass MySQL nach der Ausführung der ersten Abfrage in derselben Transaktion (Transaktion) einen „Schnappschuss“ der Transaktion erstellt. Selbst wenn die Daten in der Datenbank eine Sekunde später von anderen Programmen geändert werden, werden bei der zweiten Abfrage immer noch dieselben Snapshot-Daten wie beim ersten Mal angezeigt, solange Ihre Transaktion noch nicht beendet ist. Dadurch soll die Konsistenz des „wiederholbaren Lesens“ gewährleistet werden.
Dies ist der Standardansatz. Rufen Sie auf, bevor Sie die zweite Abfrage ausführenconnection.commit(). Durch das Absenden wird die aktuelle Transaktion beendet und MySQL erstellt bei der nächsten Abfrage einen neuen Snapshot und liest die neuesten Daten.
# Erste Abfrage
Cursor.execute(sql)
Ergebnis1 = Cursor.fetchall()
# Aktualisierung erzwingen: Aktuelle Transaktion festschreiben
Verbindung.commit()
# Die zweite Abfrage erfasst die neuesten Informationen.
Cursor.execute(sql)
Ergebnis2 = Cursor.fetchall()Wenn Sie möchten, dass jeder SQL-Befehl sofort wirksam wird und die neuesten Ergebnisse angezeigt werden, können Sie die automatische Übermittlung nach dem Verbindungsaufbau aktivieren. Also jederexecute()werden als eigenständige Angelegenheiten behandelt.
Connection.autocommit = True
# Alle nachfolgenden Ausführungen (SQL) lesen direkt den neuesten Status der DatenbankSie können die Isolationsstufe auf ändernREAD COMMITTED(Commit-Inhalt lesen). Auf dieser Ebene werden jedes Mal, wenn eine Abfrage innerhalb derselben Transaktion ausgeführt wird, die zuletzt übermittelten Daten gelesen.
# Wird vor der Ausführung der Abfrage festgelegt
Cursor.execute("SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED")connection(kabelgebundener) Transaktionsbereich, nichtcursorDas Objekt selbst. Wenn Sie den Cursor neu erstellen, aber dieselbe Verbindung verwenden und keinen Commit durchführen, besteht das Problem weiterhin.Wenn in der Multithread-Umgebung von Python mehrere Threads dieselbe Datenbankverbindung teilen, kommt es zu schwerwiegenden Konflikten. Dies liegt daran, dass verbundene Objekte normalerweise nicht threadsicher sind. Mehrere Threads, die gleichzeitig SQL-Befehle senden oder Ergebnisse lesen, führen zu Datenverwirrung, Transaktionsausnahmen oder Verbindungsunterbrechungen. Daher empfiehlt es sich, einen Verbindungspool zu verwenden, um jedem Thread unabhängige Verbindungen zuzuweisen.
mysql-connector-pythonIntegrierte einfache Verbindungspoolfunktion. Sie können im Voraus einen Pool erstellen und Verbindungen daraus „ausleihen“, wenn Threads diese benötigen.
Threading importieren
mysql.connector importieren
aus mysql.connector Import-Pooling
# 1. Erstellen Sie einen Verbindungspool (globale Variable)
db_config = {
„host“: „localhost“,
„Benutzer“: „root“,
„Passwort“: „Passwort“,
„Datenbank“: „test_db“
}
Connection_pool = mysql.connector.pooling.MySQLConnectionPool(
pool_name="mein_pool",
pool_size=5, # Legen Sie die Poolgröße fest, die größer oder gleich der Anzahl der Threads sein sollte
**db_config
)
# 2. Führen Sie die Thread-Aufgabenfunktion aus
def thread_task(task_id):
conn=Keine
Versuchen Sie:
# Erhalten Sie eine unabhängige Verbindung vom Pool
conn = Connection_pool.get_connection()
Cursor = conn.cursor()
# Operationen durchführen
Cursor.execute("JETZT AUSWÄHLEN()")
Ergebnis = Cursor.fetchone()
print(f"Ausführungsthread {task_id} Lesezeit: {result}")
# Hinweis: Denken Sie bei dieser Isolationsstufe daran, bei Änderungen einen Commit durchzuführen.
# conn.commit()
außer Ausnahme als e:
print(f"Ein Fehler ist im Thread {task_id}: {e}" aufgetreten.)
endlich:
# Wichtig: Schließen Sie den Cursor und die Verbindung (hier wird durch Schließen die Verbindung zum Pool wiederhergestellt, anstatt sie tatsächlich zu unterbrechen)
wenn conn und conn.is_connected():
Cursor.close()
conn.close()
# 3. Starten Sie mehrere Ausführungsthreads
Threads = []
für i im Bereich(3):
t = threading.Thread(target=thread_task, args=(i,))
threads.append(t)
t.start()
für t in Threads:
t.join()Wenn Sie eine größere Anwendung entwickeln, bietet SQLAlchemy eine leistungsfähigere und automatisierte Verbindungsverwaltung (QueuePool). Es verarbeitet automatisch Verbindungsfehler, Recycling und Thread-Zuweisung.
aus sqlalchemy import create_engine
Von sqlalchemy.orm Sessionmaker importieren
# Der Verbindungspool wird beim Erstellen der Engine automatisch aktiviert
engine = create_engine(
„mysql+mysqlconnector://root:password@localhost/test_db“,
pool_size=10,
max_overflow=20
)
# Verwenden Sie Sessionmaker, um sicherzustellen, dass jeder Thread eine unabhängige Sitzung erhält
Session = Sessionmaker(bind=engine)
def sqlalchemy_task():
Sitzung = Sitzung()
Versuchen Sie:
# Operationen durchführen
# session.execute(...)
session.commit()
endlich:
session.close() # Verbindung zurückgebenwithSyntax zum Verwalten von Cursor und Verbindung, um sicherzustellen, dass die Verbindung auch dann zurückgegeben werden kann, wenn eine Ausnahme auftritt.commit()oderrollback(), andernfalls hat die Verbindung möglicherweise den Status einer nicht abgeschlossenen Transaktion, wenn sie an den Pool zurückgegeben wird, was sich auf den nächsten Benutzer auswirkt.Um gespeicherte MySQL-Prozeduren in Python auszuführen, können Sie verwendenmysql-connector-pythonoderPyMySQL。
pip install mysql-connector-pythonmysql.connector importieren
# Mit Datenbank verbinden
conn = mysql.connector.connect(
host="localhost",
user="Ihr_Benutzer",
Passwort="Ihr_Passwort",
Datenbank="Ihre_Datenbank"
)
Cursor = conn.cursor()
# Rufen Sie die gespeicherte Prozedur auf
Cursor.callproc("your_stored_procedure", (param1, param2))
# Erhalten Sie Ergebnisse
für Ergebnis in Cursor.stored_results():
print(result.fetchall())
# Verbindung schließen
Cursor.close()
conn.close()Um gespeicherte SQL Server-Prozeduren in Python auszuführen, können Sie Folgendes verwenden:pyodbc。
pip install pyodbcpyodbc importieren
# Stellen Sie eine Verbindung zu SQL Server her
conn = pyodbc.connect("DRIVER={SQL Server};"
„SERVER=Ihr_Server;“
„DATABASE=your_database;“
„UID=Ihr_Benutzer;“
„PWD=Ihr_Passwort“)
Cursor = conn.cursor()
# Gespeicherte Prozedur ausführen
Cursor.execute("{CALL your_stored_procedure (?, ?)}", (param1, param2))
# Erhalten Sie Ergebnisse
rows = Cursor.fetchall()
für Zeile für Zeile:
drucken(Zeile)
# Verbindung schließen
Cursor.close()
conn.close()Um gespeicherte PostgreSQL-Prozeduren in Python auszuführen, können Sie verwendenpsycopg2。
pip install psycopg2psycopg2 importieren
# Stellen Sie eine Verbindung zu PostgreSQL her
conn = psycopg2.connect(
Datenbankname="Ihre_Datenbank",
user="Ihr_Benutzer",
Passwort="Ihr_Passwort",
host="localhost",
Port="5432"
)
Cursor = conn.cursor()
# Gespeicherte Prozedur ausführen
Cursor.callproc("your_stored_procedure", (param1, param2))
# Erhalten Sie Ergebnisse
rows = Cursor.fetchall()
für Zeile für Zeile:
drucken(Zeile)
# Verbindung schließen
Cursor.close()
conn.close()fetchall()oderstored_results()um Ergebnisse zu erzielen.requestsEs ist die am häufigsten verwendete HTTP-Anforderungssuite in Python, die zum Zugriff auf die REST-API, zum Herunterladen von Webseiten, zum Senden von Formulardaten usw. verwendet wird. Sie ist besser als die integrierteurllibPrägnanter und einfacher zu verwenden.
pip install requests
Importanfragen
#GET-Anfrage senden
url = „https://api.pionex.com/api/v1/common/symbols“
Antwort = Anfragen.get(URL)
# Überprüfen Sie, ob erfolgreich
wenn Response.status_code == 200:
Daten = Antwort.json()
print("Anfrage erfolgreich, Feld zurückgeben:", list(data.keys()))
sonst:
print("Anfrage fehlgeschlagen:", Response.status_code)
import requests
url = "https://httpbin.org/post"
payload = {"key": "value", "symbol": "BTC_USDT"}
headers = {"Content-Type": "application/json"}
res = requests.post(url, json=payload, headers=headers)
print(res.json())
| Verfahren | verwenden |
|---|---|
requests.get() | Informationen abrufen (am häufigsten verwendet) |
requests.post() | Senden Sie Informationen oder Formulare |
requests.put() | Informationen aktualisieren |
requests.delete() | Daten löschen |
response.status_code | HTTP-Statuscode |
response.json() | JSON-Antwort analysieren |
response.text | Erhalten Sie Originaltextinhalte |
response.raise_for_status() | HTTP-Fehlerausnahmen automatisch auslösen |
Importanfragen
Versuchen Sie:
r = request.get("https://api.pionex.com/api/v1/unknown")
r.raise_for_status()
außer request.Exceptions.HTTPError als e:
print("HTTP-Fehler:", e)
außer request.Exceptions.RequestException als e:
print("Allgemeiner Anforderungsfehler:", e)pandasoderasyncioMit ihm können große Datenmengen abgerufen werden.raise_for_status()JarequestsIm ModulResponseObjektmethode, mit der überprüft wird, ob der HTTP-Antwortstatuscode ein Fehler ist (z. B. 4xx oder 5xx).
Wenn der Statuscode anzeigt, dass die Anfrage fehlgeschlagen ist, wird sie automatisch ausgelöstrequests.exceptions.HTTPErrorAusnahmen werden verwendet, um das Debuggen zu erleichtern oder die Ausführung zu stoppen.
Importanfragen
url = „https://api.pionex.com/api/v1/common/symbols“
Antwort = Anfragen.get(URL)
# Überprüfen Sie, ob der HTTP-Statuscode erfolgreich ist (200 ~ 299).
Response.raise_for_status()
# Bei Erfolg kann JSON sicher analysiert werden
Daten = Antwort.json()
print("Die Anfrage war erfolgreich, die Anzahl der erhaltenen Handelspaare:", len(data.get("data", [])))Die Anfrage war erfolgreich und die Anzahl der erhaltenen Handelspaare: 248Importanfragen
Versuchen Sie:
r = request.get("https://api.pionex.com/api/v1/invalid_endpoint")
r.raise_for_status()
außer request.Exceptions.HTTPError als e:
print("HTTP-Fehler:", e)
außer request.Exceptions.RequestException als e:
print("Ausnahme anfordern:", e)HTTPError。Importanfragen
# API aufrufen
url = "https://api.example.com/data"
Antwort = Anfragen.get(URL)
# Bestätigen Sie, dass die Antwort erfolgreich ist
wenn Response.status_code == 200:
print("Daten erfolgreich erhalten")
sonst:
print(f"Fehler: {response.status_code}")
# JSON-Antwort analysieren Daten = Antwort.json() #Zugriff auf JSON-Daten print(data["key1"]) print(data["key2"]["subkey"])
Importanfragen
# API-URL
url = „https://jsonplaceholder.typicode.com/posts“
# Anfrage senden
Antwort = Anfragen.get(URL)
# Antwortstatus prüfen und analysieren
wenn Response.status_code == 200:
Daten = Antwort.json()
# Listen Sie die Titel jedes Artikels auf
zum Beitrag in Daten:
print(f"Beitrags-ID: {post['id']}, Titel: {post['title']}")
sonst:
print(f"API-Aufruf fehlgeschlagen, Statuscode: {response.status_code}")
Versuchen Sie:
Daten = Antwort.json()
drucken(Daten)
außer ValueError:
print("Die Antwort hat kein gültiges JSON-Format")
Python bietetjsonModul zum Konvertieren (Serialisieren) von Daten in das JSON-Format,
Und es kann als Datei gespeichert (Dump) oder neu geladen (Load) werden, um einen Cache-Effekt zu erzielen.
json.dump(obj, file): Schreiben Sie ein Python-Objekt in eine Datei (JSON-Format).json.dumps(obj): Konvertieren Sie das Objekt in einen JSON-String.json.load(file): JSON aus einer Datei lesen und zurück in ein Python-Objekt konvertieren.json.loads(str): JSON-String zurück in Python-Objekt konvertieren.json importieren
Betriebssystem importieren
Cache_file = „data_cache.json“
# Simulationsdatenquelle
Daten = {
„Name“: „Alice“,
„Alter“: 30,
„Hobbys“: [„Lesen“, „Musik“, „Programmieren“]
}
#Daten in JSON-Datei schreiben (Dump)
mit open(cache_file, "w",kodierung="utf-8") als f:
json.dump(data, f, secure_ascii=False, indent=2)
print("Daten wurden in der Datei zwischengespeichert.")
# JSON-Daten aus der Datei lesen (laden)
wenn os.path.exists(cache_file):
mit open(cache_file, "r",kodierung="utf-8") als f:
geladene_daten = json.load(f)
print("Geladene Daten:", geladene_Daten)Die Daten wurden in der Datei zwischengespeichert.
Geladene Daten: {'name': 'Alice', 'age': 30, 'hobbys': ['reading', 'music', 'coding']}ensure_ascii=False: Stellen Sie sicher, dass chinesische Zeichen nicht in die Unicode-Kodierung konvertiert werden.indent=2: JSON-Datei einrücken und leichter lesbar machen.json.load()Stellt JSON automatisch in den entsprechenden Typen wie dict, list, int, str usw. wieder her.json,os importieren
CACHE_PATH = „result_cache.json“
auf jeden Fall teuere_Berechnung():
print("Komplexe Operation wird ausgeführt...")
return [x**2 für x im Bereich(5)]
def get_cached_result():
#Laden Sie den Cache, falls vorhanden
wenn os.path.exists(CACHE_PATH):
mit open(CACHE_PATH, "r") als f:
json.load(f) zurückgeben
# Andernfalls nach der Berechnung in den Cache schreiben
result = teuer_berechnung()
mit open(CACHE_PATH, "w") als f:
json.dump(result, f)
Ergebnis zurückgeben
data = get_cached_result()
print("Daten abrufen:", Daten)Komplexe Operationen durchführen...
Daten abrufen: [0, 1, 4, 9, 16]Daten abrufen: [0, 1, 4, 9, 16]json.dump():In JSON-Datei schreiben.json.load(): Aus JSON-Datei lesen.dumps()Undloads()Zeichenfolgen verarbeiten.Dies ist die gängigste und gebräuchlichste Methode zum Speichern einer Reihe von Datensätzen im gleichen Format. Behandeln Sie alle Datenpunkte als Liste (entsprechende eckige Klammern in JSON).[]) Element.
[
{"time": 1759028400000, "open": "109398.3", "close": "109364.8", "high": "109489.2", "low": "109364.8", "volume": "518.7594"},
{"time": 1759024800000, "open": "109305.6", "close": "109398.3", "high": "109496.4", "low": "109296.0", "volume": "757.0290"},
...
]In Python erstellen Sie einfach eine Liste von Wörterbüchern und verwenden diese dannjson.dumps()Führen Sie die Serialisierung durch.
import json
data_list = [
{'time': 1759028400000, 'open': '109398.3', 'close': '109364.8', 'high': '109489.2', 'low': '109364.8', 'volume': '518.7594'},
{'time': 1759024800000, 'open': '109305.6', 'close': '109398.3', 'high': '109496.4', 'low': '109296.0', 'volume': '757.0290'}
]
json_output = json.dumps(data_list, indent=4)
# print(json_output)Wenn jeder DatenpunkttimeDer Wert ist eindeutig und Sie können ihn als Schlüssel des Objekts der obersten Ebene verwenden, um eine Wörterbuchstruktur zu erstellen. Diese Struktur ermöglicht die direkte Abfrage spezifischer Daten durch Zeitstempel.
{
"1759028400000": {"open": "109398.3", "close": "109364.8", "high": "109489.2", "low": "109364.8", "volume": "518.7594"},
"1759024800000": {"open": "109305.6", "close": "109398.3", "high": "109496.4", "low": "109296.0", "volume": "757.0290"},
...
}Sie müssen die Datenliste durchlaufen und jeden Datenpunkt konvertierentimeDer Wert wird als Wörterbuchschlüssel entnommen.
json importieren
source_data = [
{'time': 1759028400000, 'open': '109398.3', 'close': '109364.8', 'high': '109489.2', 'low': '109364.8', 'volume': '518.7594'},
{'time': 1759024800000, 'open': '109305.6', 'close': '109398.3', 'high': '109496.4', 'low': '109296.0', 'volume': '757.0290'}
]
data_dict = {}
für Element in Quelldaten:
# Stellen Sie sicher, dass der Zeitstempel eine Zeichenfolge ist, da JSON-Schlüssel Zeichenfolgen sein müssen
time_key = str(item['time'])
# Kopieren oder erstellen Sie ein neues Wörterbuch und entfernen Sie das Feld „Zeit“, da es jetzt der Schlüssel ist
value_data = item.copy()
del value_data['time']
data_dict[time_key] = value_data
json_output = json.dumps(data_dict, indent=4)
# print(json_output)Verwenden Sie in Python die integrierte FunktionjsonModule sind die beste Möglichkeit, Python-Datenstrukturen wie Listen und Wörterbücher in das JSON-Format zu serialisieren. Ihre Zielstruktur entspricht in Python einer Liste mit Wörterbüchern.
Gehen Sie davon aus, dass die Daten, die Sie aus der Datenbankabfrage erhalten, bereits eine Liste sind, bei der jedes Element ein Wörterbuch ist und die Schlüsselnamen mit den gewünschten JSON-Feldnamen übereinstimmen.
db_data = [
{'time': 1759028400000, 'open': '109398.3', 'close': '109364.8', 'high': '109489.2', 'low': '109364.8', 'volume': '518.7594'},
{'time': 1759024800000, 'open': '109305.6', 'close': '109398.3', 'high': '109496.4', 'low': '109296.0', 'volume': '757.0290'},
# ... weitere Daten
]json.dumps()Sie müssen nur importierenjsonModul und Verwendungjson.dumps()Die Funktion konvertiert ein Python-Listenobjekt in eine JSON-formatierte Zeichenfolge.
json importieren
# Angenommen, db_data ist bereit
# Verwenden Sie json.dumps(), um Python-Listen in JSON-Strings zu serialisieren
# indent=4 wird verwendet, um die Ausgabe zu verschönern und leichter lesbar zu machen
json_output_string = json.dumps(db_data, indent=4)
print(json_output_string)Dadurch wird eine JSON-Zeichenfolge erzeugt, die Ihrem Ziel entspricht:
[
{
"time": 1759028400000,
"open": "109398.3",
"close": "109364.8",
"high": "109489.2",
"low": "109364.8",
"volume": "518.7594"
},
{
"time": 1759024800000,
"open": "109305.6",
"close": "109398.3",
"high": "109496.4",
"low": "109296.0",
"volume": "757.0290"
}
]Wenn Ihr Datenbanktreiber eine Liste von Tupeln zurückgibt (zum Beispiel:[(1759028400000, '109398.3', ...), ...]), müssen Sie es in eine Wörterbuchliste konvertieren, bevor Sie die obige Serialisierung durchführen.
# Angenommen, der Feldname lautet wie folgt
field_names = ['time', 'open', 'close', 'high', 'low', 'volume']
tuple_data = [
(1759028400000, '109398,3', '109364,8', '109489,2', '109364,8', '518,7594'),
#...
]
# Listenverständnis
list_of_dicts = [
dict(zip(field_names, row))
für Zeile in tuple_data
]
# Jetzt kann list_of_dicts zur Serialisierung direkt an json.dumps() übergeben werden.In Python hängt die Art und Weise, wie Sie eine Web-API implementieren und JSON ausgeben, vom verwendeten Framework ab. Entspricht am ehesten PHPecho json_encode()Die Logik ist mit Python eingebautjsonModule, aber in einer Webumgebung werden Header normalerweise automatisch durch vom Framework bereitgestellte Tools verarbeitet.
FastAPI ist die erste Wahl für die moderne Python-Entwicklung, es konvertiert Pythons automatischdict(Wörterbuch) oderlist(list) auf JSON und stellen Sie das Richtige einContent-Type。
aus Fastapi FastAPI importieren
app = FastAPI()
@app.get("/api/stocks")
def get_stocks():
# Geben Sie das Python-Wörterbuch direkt zurück. FastAPI verarbeitet json_encode automatisch
data = ["AAPL", "TSLA", "NVDA", "GOOGL"]
return {"stocks": data}
In Flask, offiziell bereitgestelltjsonifyMit dieser Funktion können Sie nicht nur Daten konvertieren, sondern auch den Antwortheader auf festlegenapplication/json。
aus Flask Import Flask, jsonify
app = Flask(__name__)
@app.route('/api/stocks')
def get_stocks():
data = ["AAPL", "TSLA", "NVDA", "GOOGL"]
# Entspricht PHPs echo json_encode($data) und fügt Header hinzu
jsonify(data) zurückgeben
Wenn Sie das große Framework Django verwenden, verwenden Sie normalerweiseJsonResponseObjekt.
from django.http import JsonResponse
def stock_api(request):
data = {"stocks": ["AAPL", "TSLA"]}
return JsonResponse(data)
Wenn Sie einfach nur die JSON-Zeichenfolge abrufen möchten (z. B. zum Schreiben in eine Datei oder für eine benutzerdefinierte Ausgabe), können Sie diese verwendenjson.dumps()。
json importieren
data = {"name": "Gemini", "age": 18}
# Dies kommt der Low-Level-Implementierung von PHP json_encode() am nächsten.
json_string = json.dumps(data)
print(json_string)
| Funktion | PHP (Vanilla) | Python (FastAPI / Flask) |
|---|---|---|
| Legen Sie JSON-Header fest | header('Content-Type: application/json') |
Automatische Rahmenbearbeitung (mitreturn dictoderjsonify) |
| Objekt in JSON-Zeichenfolge | json_encode($data) |
json.dumps(data) |
| Ausgabe und Ende | echo ...; exit; |
return ... |
returnEin Wörterbuch und sie übernehmen alle Formatkonvertierungen für Sie.Google API ist hauptsächlich ein über die Google Cloud Platform (GCP) bereitgestellter Dienst, der Entwicklern den Zugriff auf verschiedene Google-Funktionen (wie Suche, Karten, Cloud-Laufwerke usw.) ermöglicht. Die meisten Google-APIs folgen einer RESTful-Architektur und verwenden das JSON-Format für den Datenaustausch.
Bevor Sie eine Google-API verwenden, müssen Sie zunächst ein Projekt in der Google Cloud Console erstellen und eine Authentifizierungsmethode einrichten. Hauptsächlich in zwei Typen unterteilt:
In Python werden zur Vereinfachung der Entwicklung offiziell die folgenden Bibliotheken empfohlen:
google-api-python-client: Universeller API-Client für die meisten Discovery-Dienste.google-auth: Behandelt speziell die Authentifizierung und Token-Verwaltung.google-cloud-storage / google-cloud-vision: Client-Bibliothek, optimiert für bestimmte Cloud-Dienste.pip install google-api-python-client google-auth-httplib2 google-auth-oauthlib。execute()。Google APIs sind nicht völlig kostenlos und unbegrenzt. Jede API verfügt über ihre eigene Kontingentabrechnungsmethode:
| Kategorie | Repräsentative API | Hauptzweck |
|---|---|---|
| Arbeitsautomatisierung | Google Sheets / Calendar / Gmail | Automatisieren Sie Formulare, planen Sie und versenden Sie E-Mails. |
| Daten und Speicherung | Cloud Storage / BigQuery | Speichern Sie große Dateien und führen Sie Big-Data-Analysen durch. |
| KI | Vision / Translation / Natural Language | Bilderkennung, Textübersetzung und Stimmungsanalyse. |
| Multimedia | YouTube Data API | Durchsuchen Sie Videos und verwalten Sie Kanalinhalte. |
Verwenden Sie Google APIs (wie YouTube, Drive, Gmail usw.) in Python, normalerweise übergoogle-api-python-clientin der BibliothekbuildFunktion zum Erstellen eines Serviceobjekts. Dieses Objekt kapselt alle API-Methoden und ist Ihr Hauptkommunikationskanal mit Google-Servern.
Um ein Serviceobjekt zu erstellen, benötigen Sie den API-Namen, die Version und den Authentifizierungsschlüssel (API-Schlüssel) oder Anmeldeinformationen (OAuth2).
aus dem Import-Build von googleapiclient.discovery
# YouTube Data API v3 initialisieren
youtube = bauen(
'youtube',
'v3',
DeveloperKey='YOUR_API_KEY'
)
# API-Beispiel aufrufen
request = youtube.videos().list(part="snippet", id="dQw4w9WgXcQ")
Antwort = request.execute()Dies ist der Hauptgrund, warum Sie den Absturz schon einmal erlebt haben.build()Das generierte Serviceobjekt und seine internenhttpTransportschichtobjektNicht Thread-sichervon. Befolgen Sie in einer Multithread-Umgebung unbedingt die folgenden Richtlinien:
youtube.execute()。run()Wird in der Methode ausgeführtbuild()。googleapiclient.discovery.ResourceBeispiel.rufe häufig anbuild()Die Leistung wird durch wiederholtes Herunterladen des „Discovery Document“ reduziert (ca. 1–2 Sekunden zusätzliche Verzögerung). Sie können optimieren, indem Sie:
# Deaktivieren Sie das Herunterladen von Explorationsdateien (wenn Sie vorkompilierte Bibliotheken installiert haben oder die Dinge beschleunigen möchten)
# Hinweis: Dies setzt voraus, dass in Ihrer Umgebung bereits relevante Definitionen vorhanden sind
youtube = build('youtube', 'v3', DeveloperKey='KEY', static_discovery=True)Der häufigste Fehler beim Aufrufen von Servicemethoden istHttpError. Sie müssen es abfangen, um Kontingentausschöpfung oder Berechtigungsprobleme zu beheben.
aus googleapiclient.errors HttpError importieren
Versuchen Sie:
Antwort = youtube.channels().list(part="statistics", mine=True).execute()
außer HttpError als e:
wenn e.resp.status == 403:
print("API-Kontingent erschöpft oder unzureichende Berechtigungen")
elif e.resp.status == 401:
print("Authentifizierung ungültig")
sonst:
print(f"HTTP-Fehler: {e}")| API-Funktionen | Namensparameter | Versionsparameter |
|---|---|---|
| YouTube Data | 'youtube' | 'v3' |
| Google Drive | 'drive' | 'v3' |
| Google Sheets | 'sheets' | 'v4' |
| Gmail API | 'gmail' | 'v1' |
Wenn Sie dasselbe Google API Service-Objekt in mehreren Threads teilen (z. B.YoutubeApi.youtube), kann es zu Thread-Sicherheitsproblemen kommen. untenhttplib2oderurllib3Wenn mehrere Threads gleichzeitig auf dasselbe Verbindungsobjekt zugreifen, generiert die Transportschicht eine Rennbedingung (Race Condition), was dazu führt, dass das Programm direkt auf der darunter liegenden Netzwerkschicht abstürzt. Manchmal wird sogar ein Fehler auf C-Sprachebene ausgelöst, der dazu führt, dass der Python-Interpreter direkt geschlossen wird. Aus diesem Grundtry...exceptDer Grund, warum es nicht abgefangen werden kann.
Erstellen Sie im Hauptthread keine globale DomäneyoutubeObjekte stehen jedem zur Verfügung. Jeder Thread sollte beim Start eine eigene API-Service-Instanz erstellen. Auf diese Weise verfügt jeder Thread über eine eigene Netzwerkverbindung und einen eigenen Cache, ohne sich gegenseitig zu beeinträchtigen.
Threading importieren
aus dem Import-Build von googleapiclient.discovery
def get_youtube_service():
# Rufen Sie diese Funktion in jedem Thread intern auf, um unabhängige Objekte zu erstellen
return build('youtube', 'v3', DeveloperKey='YOUR_API_KEY')
def thread_task(video_id):
Versuchen Sie:
# Erstellen Sie einen dedizierten Dienst innerhalb des Ausführungsthreads
local_youtube = get_youtube_service()
request = local_youtube.videos().list(
part="snippet,statistics",
id=video_id
)
Antwort = request.execute()
print(f"Erfolgreich erhalten: {video_id}")
außer Ausnahme als e:
print(f"Thread-Fehler: {e}")
# Mehrere Threads starten
t1 = threading.Thread(target=thread_task, args=("vid1",))
t2 = threading.Thread(target=thread_task, args=("vid2",))
t1.start()
t2.start()Wenn Sie Objekte nicht wiederholt erstellen möchten, können Sie verwendenthreading.LockStellen Sie sicher, dass nur ein Thread gleichzeitig ausgeführt werden kannexecute(). Dies führt zwar dazu, dass der API-Aufruf in die Warteschlange gestellt wird (wodurch der Parallelitätsbeschleunigungseffekt verloren geht), es stellt jedoch sicher, dass er nicht abstürzt.
Threading importieren
# Erstellen Sie eine globale Sperre
api_lock = threading.Lock()
def thread_task_with_lock(video_id):
# Verwenden Sie mit, um sicherzustellen, dass die Sperre automatisch aufgehoben wird
mit api_lock:
Versuchen Sie:
request = YoutubeApi.youtube.videos().list(
part="snippet",
id=video_id
)
vlist = request.execute()
außer Ausnahme als e:
print(f"Fehler: {e}")Wenn Sie eine ältere Version der Clientbibliothek verwenden, können Sie diese beim Erstellen des Dienstes explizit angebenhttpObjekt entfernen und es nicht mehr threadsicher machen oder verwendenhttplib2.Http()unabhängige Instanz. Da dies jedoch in der Regel komplizierter ist, empfiehlt es sich, Option 1 den Vorrang zu geben.
socket.setdefaulttimeout(10), um zu verhindern, dass ein bestimmter Ausführungsthread aufgrund von Netzwerkstau dauerhaft Ressourcen belegt.pip install smtplib emailDiese beiden Module sind im Allgemeinen in Python integriert und erfordern keine zusätzliche Installation.
smtplib importieren
aus email.mime.text MIMEText importieren
aus email.mime.multipart MIMEMultipart importieren
# Absender, Empfänger, Betreff und Inhalt festlegen
sender = '[email protected]'
Receiver = '[email protected]'
subject = 'Test-E-Mail'
body = 'Dies ist eine von Python gesendete Test-E-Mail. '
# Erstellen Sie E-Mail-Inhalte
msg = MIMEMultipart()
msg['From'] = Absender
msg['To'] = Empfänger
msg['Subject'] = Betreff
msg.attach(MIMEText(body, 'plain'))
#Mit Gmail SMTP senden
smtp_server = 'smtp.gmail.com'
smtp_port=587
Benutzername = '[email protected]'
passwort = 'your_app_password' # Es wird empfohlen, das App-Passwort anstelle des allgemeinen Passworts zu verwenden
mit smtplib.SMTP(smtp_server, smtp_port) als Server:
server.starttls()
server.login(Benutzername, Passwort)
server.send_message(msg)
print('E-Mail wurde gesendet')pip install google-api-python-client google-auth-httplib2 google-auth-oauthlibÜber die Gmail-API können Filter erstellt werden, die beispielsweise automatisch eine Beschriftung hinzufügen, wenn der Absender ein bestimmtes Postfach ist.
aus dem Import-Build von googleapiclient.discovery
aus google_auth_oauthlib.flow InstalledAppFlow importieren
aus google.auth.transport.requests Importanfrage
Betriebssystem importieren
Gurke importieren
# Erforderlicher Autorisierungsumfang
SCOPES = ['https://www.googleapis.com/auth/gmail.settings.basic',
'https://www.googleapis.com/auth/gmail.modify']
def gmail_service():
Anmeldeinformationen=Keine
wenn os.path.exists("token.pickle"):
mit open("token.pickle", "rb") als Token:
creds = pickle.load(token)
wenn nicht creds oder not creds.valid:
wenn creds und creds.expired und creds.refresh_token:
creds.refresh(Request())
sonst:
flow = InstalledAppFlow.from_client_secrets_file("credentials.json", SCOPES)
creds = flow.run_local_server(port=0)
mit open("token.pickle", "wb") als Token:
pickle.dump(creds, token)
return build("gmail", "v1", credentials=creds)
# Gmail-Filter erstellen
def create_filter():
service = gmail_service()
filter_config = {
„Kriterien“: {
„from“: „[email protected]“ # Bedingung: Absender
},
„Aktion“: {
„addLabelIds“: [„Label_123456“], # interne Gmail-Label-ID
„removeLabelIds“: [„INBOX“] # Optional: Posteingang entfernen
}
}
result = service.users().settings().filters().create(
userId="me",
body=filter_config
).execute()
print("Erfolgreich erstellt, Filter-ID:", result["id"])
if __name__ == "__main__":
create_filter()Label_123456ist die Label-ID von Gmail, zugänglich überusers().labels().list()erhalten.Die von der Gmail-API erstellten Regeln (Filter) werden automatisch ausgelöst, wenn neue E-Mails eingehen, und es ist keine zusätzliche „Ausführung“ erforderlich.
Verwenden Sie die Gmail-API, um nach passenden Nachrichten zu suchen und diese dann stapelweise zu kennzeichnen oder zu verschieben.
aus dem Import-Build von googleapiclient.discovery
aus google_auth_oauthlib.flow InstalledAppFlow importieren
aus google.auth.transport.requests Importanfrage
Betriebssystem importieren
Gurke importieren
SCOPES = ['https://www.googleapis.com/auth/gmail.modify']
def gmail_service():
Anmeldeinformationen=Keine
wenn os.path.exists("token.pickle"):
mit open("token.pickle", "rb") als Token:
creds = pickle.load(token)
wenn nicht creds oder not creds.valid:
wenn creds und creds.expired und creds.refresh_token:
creds.refresh(Request())
sonst:
flow = InstalledAppFlow.from_client_secrets_file("credentials.json", SCOPES)
creds = flow.run_local_server(port=0)
mit open("token.pickle", "wb") als Token:
pickle.dump(creds, token)
return build("gmail", "v1", credentials=creds)
#Wenden Sie Gmail-Regeln auf vorhandene E-Mails an
def run_rule():
service = gmail_service()
# Suchkriterien, z. B. von:[email protected]
query = "from:[email protected]"
results = service.users().messages().list(userId="me", q=query).execute()
Nachrichten = results.get("Nachrichten", [])
wenn nicht Meldungen:
print("Keine E-Mails, die den Kriterien entsprechen")
Rückkehr
für msg in Nachrichten:
service.users().messages().modify(
userId="me",
id=msg["id"],
Körper={
"addLabelIds": ["Label_123456"], # Neues Label hinzufügen
"removeLabelIds": ["INBOX"] # Entfernen Sie den Posteingang
}
).execute()
print(f"{len(messages)} Nachrichten verarbeitet")
if __name__ == "__main__":
run_rule()qBedingungen und Chargenänderungen.from:, subject:, has:attachment。Die gebräuchlichste und empfohlene Methode zum Erstellen eines HTTP-API-Servers in Python ist die Verwendung eines effizienten und funktionsreichen Webframeworks. Im Folgenden werden die drei gängigen Frameworks und ihre Eigenschaften vorgestellt:
FastAPI ist ein modernes, schnelles (unterstützt von Starlette und Pydantic) Web-Framework zum Erstellen von APIs. Es unterstützt nativ asynchrone Vorgänge (async/await) und generiert automatisch OpenAPI-Dateien (Swagger UI).
# Installation: pip install fastapi uvicorn
aus Fastapi FastAPI importieren
app = FastAPI()
# Definieren Sie eine Root-Route (GET-Anfrage)
@app.get("/")
def read_root():
return {"Hallo": "Welt"}
# Definieren Sie eine Route mit Parametern
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "q": q}
# Ausführungsserver (vorausgesetzt, der Dateiname lautet main.py)
# Im Terminal ausführen: uvicorn main:app --reloadFlask ist ein Mikro-Framework, das den Kern einfach hält und es Entwicklern ermöglicht, Komponenten wie Datenbanken und Verifizierungsbibliotheken frei auszuwählen. Es eignet sich für kleine Projekte oder Anwendungen, die ein hohes Maß an Anpassung erfordern.
# Installation: pip install flask
from flask import Flask, jsonify, request
app = Flask(__name__)
#Definieren Sie eine API-Route
@app.route("/data", method=['GET'])
def get_data():
return jsonify({"message": "This is Flask API data"})
#Definieren Sie eine POST-Route
@app.route("/submit", Methoden=['POST'])
def post_data():
data = request.get_json()
return jsonify({"received": data}), 201
#Server ausführen
# if __name__ == '__main__':
# app.run(debug=True)DRF ist ein leistungsstarkes Tool zum schnellen Erstellen von RESTful-APIs basierend auf dem voll funktionsfähigen Django-Webframework. Es bietet alle für große APIs erforderlichen Funktionen wie Serialisierer, Modellansichtssätze, Authentifizierung und Berechtigungskontrolle.
Hinweis: Der DRF-Beispielcode ist länger und erfordert zunächst die Erstellung eines Django-Projekts und einer Django-Anwendung. Daher wird er hier weggelassen, ist jedoch die erste Wahl für große Projekte.
Obwohl der idiomatische Ansatz von FastAPI darin besteht, Dekoratoren zu verwenden@app.get()Funktionen direkt dekorieren, aber um große Anwendungen besser zu organisieren und zu strukturieren (insbesondere bei Verwendung von Abhängigkeitsinjektion oder Routenmodularisierung), können Sie Routenhandler in Klassen kapseln, die oft als „APIRouter“-Muster oder „Klassenbasierte Ansichten“ bezeichnet werden.
Dies erfordert die Verwendung von **fastapi.APIRouter** und **Methodendekoratoren**, um dies zu erreichen.
wir werden es nutzenAPIRouterum die Route zu definieren und dann die Klassenmethode als Handler zu registrieren.
# Installation: pip install fastapi uvicorn
aus Fastapi-Import APIRouter, FastAPI, Hängt davon ab
von der Eingabe von import Annotated
# Schritt 1: APIRouter-Instanz erstellen
router = APIRouter(
prefix="/api/v1", # Legen Sie das Präfix für diese Routinggruppe fest
tags=["items"] # Wird zur Dateiklassifizierung verwendet
)
# Schritt 2: Definieren Sie Kategorien mit Routing-Logik
Klasse ItemService:
„“„Verarbeiten aller artikelbezogenen Geschäftslogik- und Routing-Verarbeitung““
def __init__(self, db_dependency: str):
# Abhängigkeitsinjektion simulieren (Abhängigkeitsinjektion)
self.db_connection = db_dependency
# Verwenden Sie @router.get, um Klassenmethoden zu dekorieren
@router.get("/")
def read_root(self):
# Implementieren Sie die read_root-Logik
return {"message": "Hello World from ItemService Class!", "db_status": self.db_connection}
# Implementieren Sie die read_item-Logik
# Parameter {item_id} stammt vom URL-Pfad
@router.get("/{item_id}")
def read_item(self, item_id: int, q: str | None = None):
zurück {
„item_id“: item_id,
„Abfrage“: q,
„status“: „Verarbeitung abgeschlossen“
}
#Hilfsfunktion: Abhängigkeitsinjektion simulieren (Abhängigkeit)
def get_db():
# In der Praxis wird dadurch eine Datenbankverbindung zurückgegeben
Rückgabe „Datenbank erfolgreich verbunden“
# Schritt 3: Erstellen Sie eine Factory-Funktion für Klasseninstanzen und fügen Sie Abhängigkeiten ein
# Annotated[str, Depends(get_db)] gibt an, dass db_connection von get_db bereitgestellt wird
def get_item_service(db_connection: Annotated[str, Depends(get_db)]):
# Gibt eine Instanz von ItemService zurück
return ItemService(db_connection)
# Schritt 4: Erstellen Sie einen FastAPI-Anwendungsprinzipal
app = FastAPI()
# Schritt 5: Kern! Verwenden Sie Depends, um Methoden der ItemService-Klasse in der Anwendung bereitzustellen
# Depends werden hier verwendet, um FastAPI mitzuteilen, wie es die Instanz von ItemService erhält
app.include_router(
Router,
dependencies=[Depends(get_item_service)]
)Speichern Sie den obigen Code untermain.py, und führen Sie den Uvicorn-Server aus:
uvicorn main:app --reloadItemService.read_rootVerfahren.ItemService.read_itemVerfahren.Der Schlüssel zu diesem Muster ist:
APIRouterRouten zu definieren.@router.get/@router.postund andere Dekorateure.app.include_routervondependenciesParameter.Dies hat den Vorteil, dass die Geschäftslogik (inItemService(intern) ist von der Routing-Definition getrennt, was die Modularisierung und Testbarkeit des Programmcodes verbessert.
Wenn Sie eine Flask-Anwendung in einem Terminal ausführen und diese mit „app.run()“ starten, ist es am einfachsten, das Tastatur-Interrupt-Signal zu verwenden.
Bei Unit-Tests oder Szenarien, in denen Sie den Server nach der Ausführung eines bestimmten Vorgangs automatisch herunterfahren müssen, müssen Sie den Stoppbefehl über den Code senden.
Der integrierte Entwicklungsserver von Flask verwendet tatsächlich die Werkzeug-Bibliothek. Sie können eine bestimmte HTTP-Anfrage an den Server senden, um ihn zu veranlassen, sich selbst herunterzufahren. Dazu müssen Sie in Ihrer Anwendung eine spezielle Route definieren.
aus Kolbenimport Kolben, Anfrage
app = Flask(__name__)
# Definieren Sie eine geheime Route zum Herunterfahren
@app.route('/shutdown', method=['POST'])
def Shutdown_server():
# Stellen Sie sicher, dass nur autorisierte Benutzer diesen Endpunkt aufrufen können
func = request.environ.get('werkzeug.server.shutdown')
wenn func None ist:
raise RuntimeError('Läuft nicht auf dem Werkzeug-Entwicklungsserver')
func() # Rufen Sie die Abschlussfunktion auf
return 'Der Server wird heruntergefahren...'
# ... andere Routen ...
# Senden Sie eine POST-Anfrage an http://127.0.0.1:5000/shutdown in einem anderen Programm oder Skript, um den Server herunterzufahren.Standardmäßig blockiert „app.run()“. Um weiterhin andere Logik im Hauptcode auszuführen, während der Server im Hintergrund läuft, müssen Sie Folgendes verwendenthreadingodermultiprocessingMods.
Threading importieren
Importzeit
aus Kolben importieren Kolben
app = Flask(__name__)
# ...deine Route ...
def run_server():
# Hinweis: debug=True sollte nicht in Produktionsumgebungen verwendet werden
app.run(port=5000)
# Starten Sie den Server in einem neuen Thread
thread = threading.Thread(target=run_server)
thread.start()
print("Der Flask-Server wurde im Hintergrund gestartet ...")
# Lassen Sie den Server eine Weile laufen
time.sleep(5)
# (Programm herunterfahren) In diesem Thread-Modus gibt es keine integrierte Funktion zum einfachen Herunterfahren.
# Sie müssen die oben genannte Route /shutdown verwenden oder den Thread direkt beenden (nicht empfohlen, möglicherweise nicht sauber).
# Beispiel: Warten Sie, bis der Server-Thread beendet ist (nachdem Strg+C angehalten wurde)
# thread.join()In einer Produktionsumgebung würden Sie „app.run()“ nicht verwenden. Sie verwenden einen WSGI-Server (z. B. Gunicorn oder uWSGI). So stoppen Sie diese Server:
Wenn eine Flask-Anwendung nicht auf dem Standard-Werkzeug-Entwicklungsserver ausgeführt wird (z. B. in einer Produktionsumgebung mit Gunicorn, uWSGI oder anderen ASGI-Servern), besteht die zuverlässigste Methode zur Bestimmung der aktuellen Umgebung darin, die **WSGI/ASGI-Umgebungsvariablen** zu überprüfen (d. h.request.environoderrequest.scope）。
request.environ(Gilt für WSGI-Server wie Gunicorn)Auf eine Flask-Route-Funktion können Sie zugreifenrequest.environWörterbuch, das bestimmte vom WSGI-Server festgelegte Schlüssel überprüft, um den Servertyp zu bestimmen.
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/server_info')
def get_server_info():
# Standard: Vorausgesetzt, dass es sich um einen Werkzeug-Entwicklungsserver handelt
server_name = "Werkzeug (Entwicklungsserver)"
# Suchen Sie nach allgemeinen WSGI-Server-IDs
# Überprüfen Sie Gunicorn
wenn 'gunicorn.version' in request.environ:
server_name = f"Gunicorn (Version: {request.environ.get('gunicorn.version')})"
# Überprüfen Sie uWSGI
elif 'uwsgi.version' in request.environ:
# uWSGI verfügt normalerweise nicht über einen Standardversionsschlüssel, sondern über spezifische Umgebungsvariablen
server_name = "uWSGI"
# Check Waitress (allgemeiner WSGI-Produktionsserver)
elif 'waitress.version' in request.environ:
server_name = f"Waitress (Version: {request.environ.get('waitress.version')})"
# Überprüfen Sie die allgemeinen Identifikatoren anderer WSGI-Server
elif 'SERVER_SOFTWARE' in request.environ:
# Viele Server legen diesen Standard-WSGI-Schlüssel fest
server_name = request.environ.get('SERVER_SOFTWARE')
# Wenn werkzeug.server.shutdown existiert, handelt es sich mit ziemlicher Sicherheit um Werkzeug
elif 'werkzeug.server.shutdown' in request.environ:
server_name = "Werkzeug (Entwicklungsserver, Herunterfahren verfügbar)"
return jsonify({
„aktueller_Server“: Servername,
"is_dev_server": (server_name.startswith("Werkzeug"))
})
# Starten Sie die Anwendung
# if __name__ == '__main__':
# app.run(debug=True)In Ihrer Server-Shutdown-Logik können Sie diese Prüfung direkt verwenden, um zu entscheiden, ob „shutdown_func“ ausgeführt werden soll:
aus der Flaschenimportanfrage, jsonify
@app.route('/shutdown', method=['POST'])
def Shutdown_server():
Shutdown_func = request.environ.get('werkzeug.server.shutdown')
wenn Shutdown_func None ist:
# Nicht-Werkzeug-Umgebung (normalerweise Produktionsumgebung)
return jsonify({
„error“: „Dieser Endpunkt ist nur für Entwicklungsumgebungen. Bitte verwenden Sie Betriebssystembefehle, um den Server zu stoppen.“
}), 400
#WerkzeugUmfeld
Shutdown_func()
return jsonify({"message": "Der Server wird heruntergefahren..."}), 200Obwohl „SERVER_SOFTWARE“ eine Standard-WSGI-Umgebungsvariable ist, wird sie nicht unbedingt von allen Servern festgelegt, oder das Einstellungsformat ist nicht unbedingt Standard. Die zuverlässigste Methode ist die Überprüfung eines eindeutigen Schlüssels für eine bestimmte Serverkonfiguration (z. B. „gunicorn.version“).
In Flask wird es zum Verarbeiten von Abfragezeichenfolgenparametern in URLs (z. B/my_api?abc=3&def=xyInabcUnddef) Die Hauptwerkzeuge stammen vonflaskModularrequestObjekt. Sie können verwendenrequest.argsWörterbuch für den Zugriff auf diese Parameter.
request.argsWörterbuchrequest.argsist ein wörterbuchähnliches Objekt, das Fragezeichen enthält (?) nach allen Schlüssel-Wert-Paaren.
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/my_api', method=['GET'])
def get_query_parameters():
#Greifen Sie auf das gesamte Abfrageparameterwörterbuch zu
all_params = request.args
print(f"Alle Parameter: {all_params}")
# --- Methode zum Abrufen spezifischer Parameter ---
# 1. Verwenden Sie .get(), um Parameter abzurufen (empfohlen: sicher und bietet Standardwerte)
# Rufen Sie den Parameter „abc“ ab. Der Standardwert ist „None“, wenn er nicht vorhanden ist
abc_value = request.args.get('abc')
# Rufen Sie den Parameter „def“ ab. Wenn er nicht vorhanden ist, wird er standardmäßig auf „default_value“ gesetzt.
def_value = request.args.get('def', 'default_value')
# 2. Verwenden Sie [] direkt für den Zugriff (nicht empfohlen: KeyError wird ausgelöst, wenn der Parameter nicht vorhanden ist)
# versuche:
# require_param = request.args['required']
# außer KeyError:
# require_param = "Fehlend"
# --- Umgang mit mehrwertigen Parametern ---
# Wenn die URL /my_api?item=apple&item=banana lautet
item_list = request.args.getlist('item') # Return ['apple', 'banana']
return jsonify({
„status“: „Erfolg“,
„abc“: abc_value,
„def“: def_value,
„item_list“: item_list
})
if __name__ == '__main__':
# Test-URL 1: http://127.0.0.1:5000/my_api?abc=3&def=xy&item=A&item=B
# Test-URL 2: http://127.0.0.1:5000/my_api
app.run(debug=True)| Verfahren | verwenden | Verhalten | Beispiel |
|---|---|---|---|
request.args.get('key') |
Erhalten Sie sicher einen einzelnen Parameter | Wenn der Parameter nicht vorhanden ist, kehren Sie zurückNone, wird kein Fehler ausgegeben. |
request.args.get('user') |
request.args.get('key', 'default') |
Rufen Sie Parameter ab und geben Sie Standardwerte an | Wenn der Parameter nicht vorhanden ist, wird der von Ihnen angegebene Standardwert zurückgegeben. | request.args.get('page', 1) |
request.args['key'] |
Direkter Zugriff auf Parameter | Wenn der Parameter nicht vorhanden ist, wird er ausgelöstKeyErrorFehler, der zu einem 500-Serverfehler führt. |
request.args['id'] |
request.args.getlist('key') |
Rufen Sie mehrere Parameter mit demselben Namen ab | Gibt eine Liste mit allen Werten zurück. | request.args.getlist('filter') |
ausrequest.argsAlle erhaltenen Werte sind Zeichenfolgen. Wenn das Argument eine Zahl oder ein boolescher Wert sein soll, müssen Sie die Typkonvertierung manuell durchführen:
# Parameter abrufen (String)
num_str = request.args.get('num', '0')
#In Ganzzahl konvertieren
Versuchen Sie:
num_int = int(num_str)
außer ValueError:
num_int = 0 # Konvertierungsfehler behandeln
# In Boolean konvertieren (Hinweis: Alle nicht leeren Zeichenfolgen sind in Python wahr)
bool_str = request.args.get('is_admin', 'false').lower()
is_admin = bool_str == 'true'In Flask ist der Endpunkt der Schlüssel zur Unterscheidung einer Route, nicht der Funktionsname, den Sie in Ihrem Python-Code definieren. Sie können Schleifen und die Abschlussfunktionen (Closure) von Python verwenden, um Routen dynamisch zu definieren und zu registrieren und ihnen eindeutige Endpunkte zuzuweisen.
Wir werden eine Factory-Funktion verwenden, um jeden Routenprozessor zu erstellen und bei der Registrierung einen eindeutigen „Endpunkt“-Namen anzugeben.
aus Flask Import Flask, jsonify
Betriebssystem importieren
app = Flask(__name__)
# Angenommen, dies ist Ihre Datenquelle
dynamische_apis = {
„user_info“: {“method“: „GET“, „handler“: lambda: {“data“: „Benutzerinformationen abgerufen“}},
„product_list“: {“method“: „GET“, „handler“: lambda: {“data“: „Produkte aufgelistet“}},
"submit_form": {"method": "POST", "handler": lambda: {"data": "Formular subscribed"}, "methods": ['POST']},
}
filename_base = „db_agent“
# --- Kernlogik: Routing-Factory-Funktion ---
def create_dynamic_route(funstr, handler_func, Methoden):
„““
Erstellen Sie eine Routenhandlerfunktion (Abschluss) und geben Sie sie zurück.
Diese Funktion erfasst die Werte von funstr und handler_func.
„““
defdynamic_route_handler():
# Der Funktionsname ist festgelegt, aber auf funstr kann zur Laufzeit zugegriffen werden
print(f"Verarbeitungsanforderung: {funstr}")
# Führen Sie die eigentliche Geschäftslogik aus
result = handler_func()
jsonify(result) zurückgeben
# Gibt die erstellte Funktion zurück
Rückgabe von Dynamic_route_handler
# --- Dynamische Registrierungsschleife ---
für funstr, api_info indynamic_apis.items():
# 1. URL-Pfad erstellen
url_path = f"/{filename_base}/{funstr}"
# 2. Definieren Sie den Endpunktnamen (verwenden Sie funstr, um die Eindeutigkeit sicherzustellen)
endpoint_name = f"{filename_base}_{funstr}_api"
# 3. HTTP-Methode abrufen
methoden = api_info.get("methods", ['GET']) # Standard ist GET
# 4. Routing-Verarbeitungsfunktion erstellen
handler_func = create_dynamic_route(funstr, api_info["handler"], Methoden)
# 5. Route registrieren
# Verwenden Sie den Parameter endpoint=, um einen eindeutigen Namen anstelle des Funktionsnamens anzugeben
app.add_url_rule(
URL_Pfad,
endpoint=endpoint_name,
view_func=handler_func,
Methoden=Methoden
)
print(f"Registrierte Route: {url_path} (Endpunkt: {endpoint_name})")
if __name__ == '__main__':
# Endpunkt testen, zum Beispiel: http://127.0.0.1:5000/db_agent/user_info
app.run(debug=True)Gradioist eine Open-Source-Python-Bibliothek, die darauf ausgelegt ist, Modelle für maschinelles Lernen zugänglicher und interaktiver zu machen. Mit einfachem Code können Sie schnell eine Weboberfläche für Ihr maschinelles Lernmodell erstellen, die andere testen und verwenden können.
Die Verwendung von Gradio ist sehr einfach. Das Folgende ist ein einfaches Beispiel, das zeigt, wie eine einfache Texteingabe- und -ausgabeschnittstelle erstellt wird:
importgradioasgr
#Funktionen zur Verarbeitung von Eingabedaten definieren
auf jeden Fall grüßen(Name):
return „Hallo“, + Name + „!“
# Gradio-Schnittstelle erstellen
iface = gr.Interface(fn=greet, inputs="text", outputs="text")
# Schnittstelle starten
iface.launch()Der obige Code erstellt eine einfache Weboberfläche, die es Benutzern ermöglicht, einen Namen einzugeben und dann eine personalisierte Begrüßung anzuzeigen.
Gradio stellt Entwicklern ein einfaches und leistungsstarkes Tool zur Verfügung, mit dem maschinelle Lernmodelle schnell in Webanwendungen umgewandelt werden können, sodass ein breiterer Benutzerkreis die Ergebnisse von KI einfach testen und erleben kann. Ob für persönliche Projekte oder Teamarbeit, Gradio ist ideal für die Werbung und Präsentation von Modellen.
Wenn Sie die Ausgabe der Gradio-Schnittstelle auf eine Seite auf dem Apache-HTTP-Server (z. B. „/results“) umleiten möchten, können Sie Pythons verwendenrequestsModul zur Konvertierung von Gradio
Die Ergebnisse werden an den Server gesendet. Hier sind die grundlegenden Schritte zur Integration von Gradio und Apache:
Stellen Sie zunächst sicher, dass Ihr Apache-HTTP-Server läuft und über einen konfigurierten Endpunkt verfügt, der Daten verarbeiten kann (z. B./results). Dieser Endpunkt kann PHP, Python oder eine andere Backend-Sprache sein, um die eingehenden Daten zu verarbeiten.
Hier ist ein Beispielcode zum Schreiben einer Gradio-Anwendung und zum Umleiten ihrer Ausgabe an einen HTTP-Server:
importgradioasgr
Importanfragen
# Verarbeiten Sie Gradio-Eingaben und leiten Sie sie an den HTTP-Server weiter
def process_and_redirect(input_data):
# Verarbeiten Sie die Eingabedaten
result = f"Verarbeitet: {input_data}"
#Senden Sie eine HTTP-POST-Anfrage an den Apache-HTTP-Server und übertragen Sie die verarbeiteten Daten
url = 'http://your-apache-server-address/results' # Ersetzen Sie es durch Ihre Serveradresse
Nutzlast = {'result': result}
Versuchen Sie:
Antwort = request.post(URL, Daten=Nutzlast)
wenn Response.status_code == 200:
return f „Erfolgreich weitergeleitet zu {url}.“
sonst:
return f „Umleitung fehlgeschlagen. Statuscode: {response.status_code}“
außer Ausnahme als e:
return f"Es ist ein Fehler aufgetreten: {str(e)}"
# Gradio-Schnittstelle erstellen
iface = gr.Interface(
fn=process_and_redirect,
Eingaben = „Text“,
Ausgänge = „Text“,
title="Gradio-Weiterleitung zum HTTP-Server"
)
iface.launch()Ihr Apache-Server sollte mit einem Endpunkt zur Verarbeitung von POST-Anfragen konfiguriert sein, beispielsweise einem einfachen PHP-Skript zum Empfang von Gradio-Daten:
<?php
// POST-Anfragen von Gradio bearbeiten
if ($_SERVER["REQUEST_METHOD"] == "POST") {
$result = $_POST['result']; // Holen Sie sich den Parameter „result“ aus der POST-Anfrage
echo "Von Gradio empfangene Daten: " . htmlspecialchars($result);
}
?>Dadurch können Sie mit der Gradio-Anwendung die Ausgabe an einen Apache-HTTP-Server umleiten und die Daten serverseitig verarbeiten. Durch diese Integration können die interaktiven Funktionen von Gradio in Webumgebungen umfassender genutzt werden.
Der einfachste Weg, die Gradio-Schnittstelle in eine Apache-Seite einzubetten, ist die Verwendung voniframeEtikett. aufstellensrcDas Attribut ist die URL des Gradio-Servers.
<!DOCTYPE html>
<html lang="zh">
<Kopf>
<meta charset="UTF-8">
<title>In die Apache-Schnittstelle eingebettetes Gradio</title>
</head>
<Körper>
<h1>Eingebettete Gradio-Schnittstelle</h1>
<iframe src="http://your-gradio-server-address:7860" width="100%" height="800px" frameborder="0"></iframe>
</body>
</html>Wenn Sie über die Apache-URL direkt auf die Gradio-Schnittstelle zugreifen möchten, können Sie einen Reverse-Proxy konfigurieren. Dadurch entfällt die Notwendigkeit, die ursprüngliche Gradio-URL anzuzeigen.
mod_proxyUndmod_proxy_httpMods. Führen Sie die folgenden Anweisungen aus:sudo a2enmod proxy
sudo a2enmod proxy_httpOder kommentieren Sie:
#LoadModule proxy_module modules/mod_proxy.so
#LoadModule proxy_http_module modules/mod_proxy_http.so/gradio)。<Location "/gradio">
ProxyPass "http://localhost:7860/"
ProxyPassReverse "http://localhost:7860/"
</Location>
sudo systemctl restart apache2Sobald Sie fertig sind, können Sie es verwendenhttp://your-apache-server-address/gradioZeigen Sie Schnittstelleninhalte von Gradio auf Apache-Seiten an.
Stellen Sie in Apache sicher, dass es aktiviert istproxyUndproxy_httpMods. Wenn es noch nicht aktiviert ist, können Sie den folgenden Befehl ausführen:
sudo a2enmod proxy
sudo a2enmod proxy_http
In der Apache-Konfigurationsdatei der Gradio-Anwendung (z. B./etc/apache2/sites-available/yourdomain.conf), fügen Sie die folgenden Einstellungen hinzu, um ProxyPass zu konfigurieren
und ProxyPassReverse:
<VirtualHost *:80>
Servername yourdomain.com
# Verweisen Sie das Gradio-Stammverzeichnis auf den Gradio-Server
ProxyPass/http://localhost:7860/
ProxyPassReverse/http://localhost:7860/
# Stellen Sie sicher, dass statische Ressourcen normal weitergeleitet werden können
ProxyPass /static/ http://localhost:7860/static/
ProxyPassReverse /static/ http://localhost:7860/static/
</VirtualHost>
Nach Abschluss der Einrichtung starten Sie Apache neu, um die Änderungen zu übernehmen:
sudo systemctl restart apache2Eine solche Konfiguration kann explizit Anforderungen an statische Gradio-Ressourcen verarbeiten, ztheme.css) sollte das fehlende Stilproblem beheben. Wenn der statische Dateipfad von Gradio nicht vorhanden ist/static/Bitte passen Sie den Pfad entsprechend der tatsächlichen Situation an.
Erhältlich in Gradiogr.DataFrameWidget zum Anzeigen oder Bearbeiten tabellarischer Daten, z. B. eines Pandas DataFrame oder eines anderen Tabellenformats. Hier erklären wir Ihnen, wie Sie Gradio verwenden
Die DataFrame-Komponente wird in Anwendungen zum Erstellen interaktiver Datentabellen verwendet.
Wenn Gradio noch nicht installiert ist, können Sie es mit dem folgenden Befehl installieren:
pip install gradio
gr.DataFrameTabellendaten anzeigenHier erfahren Sie, wie Sie mit Gradio einen DataFrame anzeigen. Nehmen wir an, wir haben einen Pandas DataFrame, der in einer Gradio-App angezeigt werden muss:
import gradio as gr
import pandas as pd
#Erstellen Sie einen Beispiel-DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Alter': [25, 30, 35], 'Beruf': ['Ingenieur', 'Designer', 'Arzt']}
df = pd.DataFrame(data)
# Definieren Sie eine Funktion, um DataFrame zurückzugeben
def show_dataframe():
return df
#Gradio-Schnittstelle erstellen
interface = gr.Interface(fn=show_dataframe, outputs=gr.DataFrame(), title="Personnel Data Table")
interface.launch()
import gradio as gr: Vorstellung der Gradio-Suite.data: Wörterbuch zum Erstellen von Beispieldaten, das drei Spalten enthält: Name, Alter und Beruf.show_dataframe: Definieren Sie eine Funktion, um einen Pandas DataFrame zur Anzeige zurückzugeben.gr.DataFrame(): Erstellen Sie eine DataFrame-Komponente für die Tabellenanzeige in der Gradio-Schnittstelle.interface.launch(): Starten Sie die Gradio-Anwendung.gr.DataFrameNehmen Sie interaktive Änderungen vorWenn Sie möchten, dass Benutzer die Tabelle bearbeiten können, können Sie dies tungr.DataFrameMittlere Einstellungeneditable=True, sodass Benutzer Tabellendaten ändern können:
interface = gr.Interface(fn=show_dataframe, outputs=gr.DataFrame(editable=True), title="Bearbeitbare Personaldatentabelle")
Die gestartete Anwendung zeigt eine bearbeitbare Tabelle an und Benutzer können die Daten direkt auf der Webseite ändern.
Kann verwendet werdenpsutilModul zum Ermitteln der PID des Gradio-Programms. Stellen Sie zunächst sicher, dass Sie die Installation durchgeführt habenpsutil：
pip install psutilDann können Sie den folgenden Code verwenden, um die PID des Gradio-bezogenen Programms zu ermitteln.
psutil importieren
# Suche nach Programmen, die „gradio“ enthalten
für Prozess in psutil.process_iter(['pid', 'name', 'cmdline']):
if 'gradio' in ' '.join(process.info['cmdline']):
print("Gradio-Programm-PID gefunden:",process.info['pid'])Sobald die PID gefunden wurde, können Sie sie verwendenterminate()oderkill()Methode zum Beenden des Programms. Zum Beispiel:
für Prozess in psutil.process_iter(['pid', 'name', 'cmdline']):
if 'gradio' in ' '.join(process.info['cmdline']):
process.kill() # Beenden Sie das Programm zwangsweise
print(f"Abgebrochenes Gradio-Programm PID: {process.info['pid']}")verwendenkill()Die Methode beendet das Programm sofort. Stellen Sie daher sicher, dass im Programm keine wichtigen Vorgänge ausgeführt werden. Dieser Beispielcode beendet alle passenden Gradio-Programme.
Kann verwendet werdenpsutilModul zum Auffinden von Programmen, die auf einem bestimmten Port lauschen. Stellen Sie zunächst sicher, dass Sie die Installation durchgeführt habenpsutil：
pip install psutilAnschließend können Sie den folgenden Code verwenden, um den Monitor zu finden7860Die Programm-PID des Ports.
psutil importieren
#Geben Sie die zu durchsuchende Portnummer an
target_port = 7860
pid_to_kill = Keine
# Suche nach Programmen, die den angegebenen Port überwachen
für conn in psutil.net_connections(kind='inet'):
wenn conn.laddr.port == target_port und conn.status == psutil.CONN_LISTEN:
pid_to_kill = conn.pid
Pause
wenn pid_to_kill:
print("Programm-PID des Überwachungsports 7860 gefunden:", pid_to_kill)
sonst:
print("Kein Programm zum Abhören von Port 7860 gefunden")Sobald die PID gefunden wurde, können Sie sie verwendenpsutil.Processvonkill()Methode zum erzwungenen Beenden des Programms:
wenn pid_to_kill:
Prozess = psutil.Process(pid_to_kill)
process.kill() # Beenden Sie das Programm zwangsweise
print(f"Programm-PID des Überwachungsports 7860 wurde beendet: {pid_to_kill}")
sonst:
print("Programm kann nicht beendet werden, da die PID nicht gefunden wurde")Dieser Code beendet zwangsweise jedes Programm, das den angegebenen Port überwacht. Bitte bestätigen Sie, dass der Port tatsächlich von Gradio verwendet wird, um eine versehentliche Beendigung anderer Dienste zu vermeiden.
Gradio ist in erster Linie für die Erstellung schneller, benutzerfreundlicher Web-Benutzeroberflächen zur Anzeige von Modellen für maschinelles Lernen konzipiert. Es selbst läuft bereits auf einem Webserver, aber sein Hauptzweck besteht darin, eine Mensch-Computer-Interaktionsschnittstelle bereitzustellen und nicht einen herkömmlichen RESTful-API-Endpunkt.
Wenn Sie RESTful API-Funktionalität in Ihrer Gradio-Anwendung haben möchten, ist die am meisten empfohlene Methode die Einbettung der Gradio-Anwendung in ein leistungsfähigeres Web-Framework wie **FastAPI** oder **Flask**. Dadurch können Sie das Hauptframework verwenden, um API-Endpunkte zu definieren, während Sie die Gradio-Benutzeroberfläche auf einem Unterpfad bereitstellen.
FastAPI ist schnell und basiert auf dem Starlette-Framework zusammen mit Gradio, wodurch der Einbettungsprozess sehr reibungslos verläuft.
# Installieren Sie FastAPI, Uvicorn (Server) und Gradio
pip install fastapi uvicorn gradioSie werden Gradio verwenden.to_app()Die Methode konvertiert die Gradio-Schnittstelle in eine ASGI-Anwendung und verwendet dann FastAPIsmountFunktion zum Mounten in der Hauptanwendung.
aus Fastapi FastAPI importieren
aus fastapi.responses JSONResponse importieren
importgradioasgr
# 1. Definieren Sie die Gradio-Anwendungslogik
auf jeden Fall grüßen(Name):
return f"Hallo, {Name}!"
gr_interface = gr.Interface(fn=greet, inputs="text", outputs="text")
# 2. Konvertieren Sie die Gradio-Schnittstelle in eine ASGI-Anwendung
gradio_app = gr_interface.to_app()
# 3. Erstellen Sie die FastAPI-Hauptanwendung
app = FastAPI(
title="Gradio + FastAPI Server",
description="Stellt sowohl API-Endpunkte als auch die Gradio-Benutzeroberfläche bereit"
)
# 4. (API SVR) Definieren Sie Ihre RESTful API-Endpunkte
@app.get("/api/v1/status")
def api_status():
return JSONResponse(content={"status": "API ist betriebsbereit"})
@app.get("/api/v1/model_inference")
def api_inference(data: str):
# Hier können Sie Ihre Modelllogik aufrufen
result = f"Verarbeitete Daten: {data.upper()}"
return JSONResponse(content={"result": result})
# 5. (Gradio SVR) Mounten Sie die Gradio-Anwendung im /gradio-Pfad
# Mit der Funktion mount() können Sie eine andere ASGI-Anwendung in einem angegebenen Pfad mounten
app.mount("/gradio", gradient_app)
# Ausführungsserver (vorausgesetzt, der Dateiname lautet main.py)
# Im Terminal ausführen: uvicorn main:app --host 0.0.0.0 --port 8000 --reloadGradio selbst bietet auch eine experimentelle Funktion, die es Ihnen ermöglicht, die zugrunde liegenden Funktionen der Gradio-Schnittstelle direkt über URL-Parameter aufzurufen, ohne dass ein zusätzliches Web-Framework erforderlich ist. Dabei handelt es sich nicht um eine standardmäßige RESTful-API, sondern sie ermöglicht einen einfachen programmgesteuerten Zugriff.
Die Einbettung von Gradio mithilfe von FastAPI/Flask ist jedoch ein standardmäßigerer und flexiblerer Ansatz, der ein standardisierteres API-Design, eine stärkere Dokumentation und Zertifizierung bietet.
Dies ist die gebräuchlichste Crawler-Kombination, die für Anfänger geeignet ist und zum Parsen statischer Webseiten verwendet wird.
pip install requests beautifulsoup4Anwendungsbeispiel:
import requests
from bs4 import BeautifulSoup
url = "https://example.com"
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")
print(soup.title.string)Ein leistungsstarkes Crawler-Framework, das für große Crawler-Projekte geeignet ist und Multithread- und verteilte Crawler unterstützt.
pip install scrapyAnwendungsbeispiel:
scrapy startproject myprojectErstellen Sie im Projekt ein Crawler-Modul und führen Sie den Crawling-Befehl aus.
Geeignet für dynamisches Web-Crawling, das Benutzervorgänge simulieren muss, z. B. die Verarbeitung von JavaScript-gerenderten Inhalten.
pip install seleniumAnwendungsbeispiel:
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://example.com")
print(driver.title)
driver.quit()Ein weiteres Tool zur Verarbeitung dynamischer Webseiten. Es bietet eine höhere Leistung als Selenium und unterstützt mehrere Browser.
pip install playwright
playwright installAnwendungsbeispiel:
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch()
page = browser.new_page()
page.goto("https://example.com")
print(page.title())
browser.close()Basierend auf der Python-Version von Puppeteer ist es speziell für das Crawlen dynamischer Webseiten konzipiert.
pip install pyppeteerAnwendungsbeispiel:
from pyppeteer import launch
async def main():
browser = await launch()
page = await browser.newPage()
await page.goto("https://example.com")
print(await page.title())
await browser.close()
import asyncio
asyncio.get_event_loop().run_until_complete(main())Effizientes Tool zum Senden von HTTP-Anfragen, das asynchrone Vorgänge unterstützt.
pip install httpxAnwendungsbeispiel:
import httpx
async def fetch():
async with httpx.AsyncClient() as client:
response = await client.get("https://example.com")
print(response.text)
import asyncio
asyncio.run(fetch())To create a simple web scraper in Python, you can use the requests library to get the page content, and BeautifulSoup to parse the HTML.
Here's an example of a basic web scraper:
import requests
from bs4 import BeautifulSoup
# URL to scrape
url = "https://example.com"
# Send a GET request
response = requests.get(url)
response.raise_for_status() # Check for errors
# Parse the HTML content
soup = BeautifulSoup(response.content, "html.parser")
# Extract specific data (e.g., all the headings)
headings = soup.find_all("h1")
# Print the headings
for heading in headings:
print(heading.text)
Note: You may need to install the libraries with the following commands:
pip install requests
pip install beautifulsoup4
Zu extrahierender Text
anderer Text
aus bs4 Import BeautifulSoup
#HTML-Datei
html_content = """
Zu extrahierender Text
anderer Text
„““
# HTML analysieren
Suppe = BeautifulSoup(html_content, 'html.parser')
# Suchen Sie nach bestimmten Tags und Kategorien
span_tag = Suppe.find('span', class_='xxxclass')
#Textwert extrahieren
wenn span_tag:
print(span_tag.text) #Ausgabe: zu extrahierender Text
sonst:
print("Kein passendes Tag gefunden")
# Alle passenden findenEtikett
span_tags = Suppe.find_all('span', class_='xxxclass')
#Extrahieren Sie den Text jedes Etiketts
für Tag in span_tags:
print(tag.text)
span_tag = soup.find('span', {'class': 'xxxclass', 'id': 'specific-id'})
2. **Verwenden Sie reguläre Ausdrücke, um Kategorien abzugleichen**:
import re
span_tag = soup.find('span', class_=re.compile(r'^xxx'))
Selenium ist ein Open-Source-Tool, das hauptsächlich zur Automatisierung von Webbrowser-Vorgängen verwendet wird. Es unterstützt mehrere Browser, darunter Chrome, Firefox, Safari usw., und kann zum Testen von Webanwendungen oder zum Scrapen von Webdaten verwendet werden.
Im Folgenden finden Sie die Schritte zur Installation von Selenium und ein einfaches Beispiel für die Verwendung von Python:
# Selenium installieren
pip Selenium installieren
#Beispielcode
vom Selenium Import Webdriver
von selenium.webdriver.common.by import By
# WebDriver starten
Treiber = webdriver.Chrome()
drivers.get("https://www.example.com")
# Elemente finden und Operationen ausführen
element = drivers.find_element(By.TAG_NAME, „h1“)
print(element.text)
# Browser schließen
Driver.quit()
Stellen Sie sicher, dass Selenium und ChromeDriver installiert sind:
pip install seleniumLaden Sie die entsprechende Version von Chrome herunter und installieren Sie sieChromeDriver。
Der Benutzerordner von Chrome enthält persönliche Daten wie Lesezeichen, Verlauf, Cookies usw. Sie können einen bestimmten Ordner angeben, der zum Starten des Browsers verwendet werden soll.
vom Selenium Import Webdriver
vom Importdienst selenium.webdriver.chrome.service
aus selenium.webdriver.chrome.options Importoptionen
#ChromeDriver-Pfad angeben
chromedriver_path = "/path/to/chromedriver"
#Benutzerordner angeben
user_data_dir = „/Pfad/zu/Ihrem/Benutzer/Daten“
# Chrome-Optionen festlegen
chrome_options = Optionen()
chrome_options.add_argument(f"--user-data-dir={user_data_dir}")
chrome_options.add_argument("--profile-directory=Default") # oder anderer Unterordnername
# Browser starten
service = Service(chromedriver_path)
Driver = webdriver.Chrome(service=service, options=chrome_options)
# Öffnen Sie eine Webseite
drivers.get("https://example.com")
# Programm beenden
Driver.quit()user_data_dirDer Pfad ist ein gültiges und beschreibbares Verzeichnis.chrome://version。Stellen Sie sicher, dass es installiert istseleniumUndpsutil：
pip install selenium psutilDer folgende Code scannt alle laufenden Chrome-Dateien und extrahiert sieuser-data-dirParameter:
import psutil
import re
def get_all_user_data_dirs():
user_data_dirs = set()
for proc in psutil.process_iter(attrs=['pid', 'name', 'cmdline']):
try:
if proc.info['name'] and 'chrome' in proc.info['name'].lower():
cmdline = ' '.join(proc.info['cmdline'])
match = re.search(r'--user-data-dir=([^\s]+)', cmdline)
if match:
user_data_dirs.add(match.group(1))
except (psutil.NoSuchProcess, psutil.AccessDenied):
continue
return list(user_data_dirs)
print(get_all_user_data_dirs())Ziel findenuser_data_dirSchließlich kann es mit Selen verwendet werden:
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
chrome_user_data_dir = "C:\\Users\\YourUser\\AppData\\Local\\Google\\Chrome\\User Data"
options = Options()
options.add_argument(f"--user-data-dir={chrome_user_data_dir}")
service = Service("chromedriver.exe")
driver = webdriver.Chrome(service=service, options=options)
driver.get("https://www.google.com")durchpsutilAnalysieren Sie den laufenden Chrome-Prozess, um alles zu erhaltenuser-data-dir, und verwenden Sie spezifischuser_data_dirStarten Sie den Browser.
Um den Benutzernamen aus dem Chrome-Benutzerdatenverzeichnis abzurufen, müssen Sie auf eine Datei in diesem Verzeichnis zugreifen, normalerweise unter dem folgenden Pfad:
C:\Users\[Username]\AppData\Local\Google\Chrome\User Data\（Windows）/Users/[Username]/Library/Application Support/Google/Chrome/（macOS）/home/[Username]/.config/google-chrome/（Linux）Diese Ordner enthalten viele Dateien, die Sie lesen könnenLocal StateDatei, um grundlegende Informationen über den Benutzer zu erhalten.
Local StateDateiChromLocal StateDie Datei enthält einige grundlegende Benutzereinstellungen, aus denen Sie die Benutzerinformationen abrufen können.
json importieren
Betriebssystem importieren
def get_chrome_user_name(user_data_dir):
local_state_path = os.path.join(user_data_dir, 'Local State')
# Überprüfen Sie, ob die Datei vorhanden ist
wenn nicht os.path.exists(local_state_path):
Rückgabe „Local State-Datei nicht gefunden“
mit open(local_state_path, 'r', binding='utf-8') als Datei:
local_state = json.load(datei)
# Holen Sie sich Benutzerinformationen vom lokalen Staat
user_name = local_state.get('profile', {}).get('name', 'Unknown User')
Benutzername zurückgeben
# Beispiel: Verzeichnispfad für Chrome-Benutzerdaten
user_data_dir = r'C:\Benutzer\IhrBenutzername\AppData\Local\Google\Chrome\Benutzerdaten'
print(get_chrome_user_name(user_data_dir))wenn du liestLocal StateWenn Sie eine Datei in JSON analysieren, können Sie viele Informationen daraus erhalten, wie zum Beispiel:
profile: Enthält die Konfigurationsinformationen des Benutzers, wie Name, Bild usw.last_version: Zeigt die letzte Chrome-Version an.is_logged_in: Zeigt an, ob der Benutzer angemeldet ist.In den meisten Fällen wird der Benutzername gefundenprofileund kann mit der oben genannten Methode extrahiert werden.
Durch ParsenLocal StateSie können den Namen des Chrome-Benutzers ganz einfach aus den JSON-Daten in der Datei ermitteln.
ChromLocal StateDateien speichern viele grundlegende Informationen über Benutzer. Wenn Sie alle Benutzernamen daraus extrahieren möchten, können Sie die Datei lesen und ihren JSON-Inhalt analysieren. Hier sind die Schritte, wie Sie dies erreichen können.
Local StateArchivieren und analysierenSie können das lesenLocal StateDatei und analysiert dann deren JSON-formatierten Inhalt, um alle Benutzerdaten zu extrahieren.
json importieren
Betriebssystem importieren
def get_all_users(user_data_dir):
local_state_path = os.path.join(user_data_dir, 'Local State')
# Überprüfen Sie, ob die Datei vorhanden ist
wenn nicht os.path.exists(local_state_path):
Rückgabe „Local State-Datei nicht gefunden“
mit open(local_state_path, 'r', binding='utf-8') als Datei:
local_state = json.load(datei)
# Holen Sie sich alle Benutzerdaten vom lokalen Staat
Profile = local_state.get('profile', {}).get('info_cache', {})
# Alle Benutzernamen abrufen
user_names = [profile.get('name', 'Unknown User') für Profil in Profiles.values()]
Benutzernamen zurückgeben
# Beispiel: Verzeichnispfad für Chrome-Benutzerdaten
user_data_dir = r'C:\Benutzer\IhrBenutzername\AppData\Local\Google\Chrome\Benutzerdaten'
print(get_all_users(user_data_dir))in ChromeLocal StateIn Dateien werden üblicherweise Benutzerdaten gespeichertprofilerunterinfo_cacheDabei handelt es sich um ein Wörterbuch, in dem das Profil jedes Benutzers durch seinen Konfigurationsnamen gekennzeichnet ist.
Local StateDateistrukturDas Folgende istLocal StateBeispielstruktur im Archiv:
{
"profile": {
"info_cache": {
"profile1": {
"name": "User1",
"avatar": "path/to/avatar1.jpg"
},
"profile2": {
"name": "User2",
"avatar": "path/to/avatar2.jpg"
}
}
}
}
Durch ParsenLocal StateIn der Datei können Sie die Namen aller Benutzer in Chrome abrufen. Dies erleichtert die Auflistung aller Konten.
in ChromeLocal StateDatei, in der die Daten jedes Benutzers enthalten sindinfo_cacheMitte. Von dort können Sie den Benutzernamen und das entsprechende Konfigurationsunterverzeichnis extrahieren.
Local StateArchivieren und analysierenHier erfahren Sie, wie Sie es in Chrome tunLocal StateMethode zum Abrufen der Namen und entsprechenden Unterverzeichnisse aller Benutzer in der Datei.
json importieren
Betriebssystem importieren
def get_users_and_profiles(user_data_dir):
local_state_path = os.path.join(user_data_dir, 'Local State')
# Überprüfen Sie, ob die Datei vorhanden ist
wenn nicht os.path.exists(local_state_path):
Rückgabe „Local State-Datei nicht gefunden“
mit open(local_state_path, 'r', binding='utf-8') als Datei:
local_state = json.load(datei)
# Holen Sie sich alle Benutzerdaten vom lokalen Staat
Profile = local_state.get('profile', {}).get('info_cache', {})
# Alle Benutzernamen und die entsprechenden Unterverzeichnisse abrufen
user_info = {}
für Profile_Key, Profile_Data in Profiles.items():
user_name = profile_data.get('name', 'Unbekannter Benutzer')
Profile_sub_dir = os.path.join(user_data_dir, 'Profile ' + Profile_key)
user_info[user_name] = Profilunterverzeichnis
Geben Sie user_info zurück
# Beispiel: Verzeichnispfad für Chrome-Benutzerdaten
user_data_dir = r'C:\Benutzer\IhrBenutzername\AppData\Local\Google\Chrome\Benutzerdaten'
user_and_profiles = get_users_and_profiles(user_data_dir)
für Benutzername, Profilverzeichnis in „users_and_profiles.items()“:
print(f"Benutzername: {user_name}, Unterverzeichnis: {profile_dir}")existierenLocal StateDatei, in der sich alle Benutzerdaten befindenprofilerunterinfo_cache. Jeder Benutzer verfügt über einen entsprechenden Konfigurationsschlüssel (z. B.profile1, profile2Warten). Jedes konfigurierte Profil enthält den Namen des Benutzers (name) und andere relevante Informationen.
Local StateDateistrukturDas Folgende istLocal StateBeispielstruktur im Archiv:
{
"profile": {
"info_cache": {
"Profile 1": {
"name": "User1",
"avatar": "path/to/avatar1.jpg"
},
"Profile 2": {
"name": "User2",
"avatar": "path/to/avatar2.jpg"
}
}
}
}
ProfileAnfang, gefolgt von einer Zahl (z. B.Profile 1, Profile 2Warten).Durch ParsenLocal StateIn der Datei können Sie die Namen aller Benutzer und der entsprechenden Konfigurationsunterverzeichnisse abrufen. Dadurch können Sie den Speicherort der Konfigurationsdaten jedes Benutzers leicht finden.
Um das Gmail-Konto aus dem Chrome-Benutzerdatenverzeichnis zu erhalten, müssen Sie die relevanten Informationen aus den Chrome-Konfigurationsdaten extrahieren. Dies wird normalerweise durch das Parsen der Benutzerdatendateien von Chrome erreicht, insbesondere der Google-bezogenen Kontodaten.
Die Daten jedes Chrome-Benutzers befinden sich in einem eigenen Ordner, normalerweise inUser Dataunter dem VerzeichnisProfileinnerhalb des Verzeichnisses. Wenn der Nutzer bei einem Google-Konto angemeldet ist, finden sich die entsprechenden Gmail-Kontoinformationen in den Konfigurationsdaten.
Betriebssystem importieren
json importieren
def get_gmail_from_profile(Benutzerdatenverzeichnis, Profilname):
Profile_dir = os.path.join(Benutzerdatenverzeichnis, Profilname)
Accounts_file = os.path.join(profile_dir, 'Web Data')
# Überprüfen Sie, ob die Datei vorhanden ist
wenn nicht os.path.exists(accounts_file):
Rückgabe „Webdatendatei nicht gefunden“
# Versuchen Sie, die Webdatendatei zu lesen
Versuchen Sie:
mit open(accounts_file, 'r',kodierung='utf-8') als Datei:
web_data = json.load(Datei)
# Gmail-Konto aus Daten extrahieren
für Zeile in web_data.get('accounts', []):
wenn 'gmail' in row.get('email', ''):
return row.get('email')
Rückgabe „Kein Gmail-Konto gefunden“
außer Ausnahme als e:
return f"Fehler beim Lesen der Webdatendatei: {e}"
# Beispiel: Verzeichnispfad für Chrome-Benutzerdaten
user_data_dir = r'C:\Benutzer\IhrBenutzername\AppData\Local\Google\Chrome\Benutzerdaten'
# Angenommen, Sie verwenden Profil 1
Profile_name = 'Profil 1'
print(get_gmail_from_profile(user_data_dir, Profilname))Webdatendateien enthalten verschiedene Anmeldedaten in Chrome, darunter Kontonamen, Passwörter und andere zugehörige Informationen. In diesem Beispiel suchen wir nachemailFeld und prüfen Sie, ob es ein Gmail-Postfach enthält.
Das Folgende ist ein Beispiel für eine Teilstruktur einer Webdatendatei:
{
"accounts": [
{
"email": "[email protected]",
"password": "encrypted_password_1"
},
{
"email": "[email protected]",
"password": "encrypted_password_2"
}
]
}
email) kann normalerweise extrahiert werden.Durch Parsen des Chrome-BenutzerprofilsWeb DataMit der Datei können Sie das Gmail-Konto eines Benutzers problemlos abrufen. Wenn der Benutzer bei einem Gmail-Konto angemeldet ist, wird die entsprechende E-Mail in den Daten angezeigt.
Zu den gängigen Web-Automatisierungstools gehören Selenium und Playwright. Diese Tools können Klicks, Texteingaben und andere Benutzeraktionen simulieren.
Verwenden Sie ein Tool wie BeautifulSoup oder Playwright, um alle Hyperlinks auf Ihrer Website abzurufen (<a href>), um eine Liste der zu durchsuchenden Seiten zu erstellen.
Öffnen Sie einen Browser mit Selenium oder Playwright und simulieren Sie Benutzeraktionen wie das Klicken auf Schaltflächen, das Scrollen und sogar das Auslösen dynamischer Inhalte.
Moderne Websites enthalten oft viele dynamisch generierte Inhalte, und Sie können Playwright oder Selenium verwenden, um JavaScript auszuführen, um sicherzustellen, dass die Seite korrekt geladen wird.
Besuchen Sie anhand der gecrawlten Links rekursiv alle Seiten der Website und zeichnen Sie die besuchten Seiten auf, um Duplikate zu vermeiden.
Simulieren Sie beim Durchsuchen jeder Seite gängiges Benutzerverhalten, z. B. das Ausfüllen von Formularen, das Übermitteln von Informationen und das Aufzeichnen der Ergebnisse der Vorgänge.
vom Selenium Import Webdriver
von selenium.webdriver.common.by import By
#Initialisieren Sie den Browser
Treiber = webdriver.Chrome()
# Beginnen Sie mit dem Durchsuchen der Website
drivers.get("https://example.com")
# Schnapp dir alle Links
links = drivers.find_elements(By.TAG_NAME, „a“)
zum Link in Links:
href = link.get_attribute("href")
print(f"Link gefunden: {href}")
# Klick simulieren
wenn Links:
links[0].click()
# Browser schließen
Driver.quit()
Halten Sie sich beim Durchsuchen und Simulieren von Websites bitte an die Nutzungsbedingungen der jeweiligen Website, um eine übermäßige Serverlast oder Gesetzesverstöße zu vermeiden.
vom Selenium Import Webdriver
von selenium.webdriver.common.by import By
aus selenium.webdriver.support.ui WebDriverWait importieren
Von selenium.webdriver.support importieren Sie erwartete_Bedingungen als EC
#WebDriver initialisieren
Treiber = webdriver.Chrome()
#Öffnen Sie die Zielwebsite
drivers.get("https://example.com")
# Warten Sie, bis die Schaltfläche angezeigt wird, und klicken Sie
wait = WebDriverWait(Treiber, 10)
button = wait.until(EC.element_to_be_clickable((By.ID, "button_id")))
button.click()
# Warten Sie, bis andere Elemente geladen sind
text_field = wait.until(EC.visibility_of_element_located((By.NAME, "text_field_name")))
text_field.send_keys("Testdaten")
# Browser schließen
Driver.quit()
Importzeit
vom Selenium Import Webdriver
#WebDriver initialisieren
Treiber = webdriver.Chrome()
#Öffnen Sie die Zielwebsite
drivers.get("https://example.com")
time.sleep(3) # Pause für 3 Sekunden
# Schaltflächenklick simulieren
button = drivers.find_element(By.ID, "button_id")
button.click()
time.sleep(3)
# Browser schließen
Driver.quit()**Hinweis**: „time.sleep“ wird nicht für formale Tests empfohlen, sondern nur für Debugging-Zwecke.vom Selenium Import Webdriver
#WebDriver initialisieren
Treiber = webdriver.Chrome()
#Öffnen Sie die Zielwebsite
drivers.get("https://example.com")
# Nach manueller Bestätigung fortfahren
input("Drücken Sie die Eingabetaste, um mit dem nächsten Schritt fortzufahren ...")
button = drivers.find_element(By.ID, "button_id")
button.click()
# Führen Sie weiterhin andere Tests durch
input("Drücken Sie die Eingabetaste, um mit dem nächsten Schritt fortzufahren ...")
Driver.quit()
Unittest importieren
vom Selenium Import Webdriver
Klasse TestExample(unittest.TestCase):
def setUp(self):
self.driver = webdriver.Chrome()
def test_step_by_step(self):
Driver = self.driver
drivers.get("https://example.com")
input("Überprüfen Sie die Seite, drücken Sie die Eingabetaste, um fortzufahren ...") # Manueller Haltepunkt
button = drivers.find_element(By.ID, "button_id")
button.click()
input("Überprüfen Sie die Operationsergebnisse, drücken Sie die Eingabetaste, um fortzufahren ...") # Manueller Haltepunkt
def TearDown(Selbst):
self.driver.quit()
if __name__ == "__main__":
unittest.main()
vom Selenium Import Webdriver
von selenium.webdriver.common.by import By
# Selenium initialisieren
Treiber = webdriver.Chrome()
drivers.get("URL Ihrer Zielwebseite")
# Suchen Sie nach Text, der mit einer bestimmten Zeile beginnt
target_text = „Ziel-Starttext“
rows = drivers.find_elements(By.CSS_SELECTOR, "table tr")
# Ergebnisse speichern
result_data = []
für Zeile für Zeile:
Zellen = row.find_elements(By.TAG_NAME, "td")
wenn Zellen und Zellen[0].text.startswith(target_text):
# Holen Sie sich die Informationen hinter dem Peer
result_data.append([cell.text für Zelle in Zellen])
Driver.quit()
# Konvertieren Sie das Ergebnis in HTML
html_output = "<h2>Suchergebnisse</h2>\n"
für i, row_data in enumerate(result_data, start=1):
html_output += f"<h3>Zeile {i}</h3>\n<ul>\n"
für Daten in row_data:
html_output += f" <li>{data}</li>\n"
html_output += "</ul>\n"
# Ergebnisse anzeigen
print(html_output)
Suchergebnisse
Zeile 1
- Ziel-Starttext 1
- Sonstige Informationen1
- Sonstige Informationen 2
Zeile 2
- Ziel-Eröffnungstext 2
- Sonstige Informationen1
- Sonstige Informationen 2
startswithMethode zur Bestimmung, ob der Text die Bedingungen erfüllt.<h2>Und<h3>und als ungeordnete Liste<ul>Informationen organisieren.<head>Und<body>: Generieren Sie nur notwendige HTML-Tags für eine einfache Einbettung in andere Seiten.In Selen,find_elements(By.XPATH, xpath)Wird verwendet, um alle Elemente zu finden, die den Kriterien entsprechen, basierend auf einem XPath-Selektor, und eine Liste zurückzugeben. es hängt damit zusammenfind_element(By.XPATH, xpath)Im Gegensatz dazu gibt letzteres nur das erste passende Element zurück.
vom Selenium Import Webdriver
von selenium.webdriver.common.by import By
# Browser starten
Treiber = webdriver.Chrome()
# Webseite öffnen
drivers.get("https://example.com")
# Verwenden Sie XPath, um alle Elemente zu finden, die den Kriterien entsprechen
elements = drivers.find_elements(By.XPATH, "//div[@class='example-class']")
# Durchlaufen Sie die gefundenen Elemente und geben Sie den Inhalt aus
für Element in Elementen:
print(element.text)
# Browser schließen
Driver.quit()| XPath-Ausdruck | beschreiben |
|---|---|
//tagname |
Wählt alle Elemente mit dem angegebenen Tag aus, z//divrepräsentieren alledivElement |
//tagname[@attribute='value'] |
Wählen Sie Elemente basierend auf Attributwerten aus, z. B.//input[@type='text'] |
//tagname[contains(@attribute, 'value')] |
Attribute, die bestimmten Text enthalten, wie z//div[contains(@class, 'header')] |
//tagname[text()='text'] |
Wählen Sie Elemente aus, die genau zum Text passen, z//button[text()='Senden'] |
//tagname[contains(text(), 'text')] |
Wählen Sie Elemente aus, die bestimmten Text enthalten, z//p[contains(text(), 'Welcome')] |
//*[@id='some-id'] |
Wählen Sie ein Element mit einer bestimmten ID aus |
(//tagname)[index] |
Wählen Sie die ausindexpassende Elemente zum Beispiel(//div)[1]Wählen Sie das erste Div aus |
Gehen Sie von der folgenden HTML-Struktur aus:
<div class="product">Produkt A</div>
<div class="product">Produkt B</div>
<div class="product">Produkt C</div>Wir können den folgenden Selenium-Code verwenden, um alles zu bekommenproductKategoriedivElement:
elements = driver.find_elements(By.XPATH, "//div[@class='product']")
for element in elements:
print(element.text)
find_elements()Zurückgegeben wird eine Liste, auch wenn nur ein Element gefunden wird.find_element(),ansonstenfind_elements()。find_elements(By.XPATH, xpath)Es handelt sich um eine leistungsstarke und flexible Suchmethode in Selenium, die zum Auffinden mehrerer Elemente auf einer Webseite verwendet werden kann und sich für Crawler und automatisierte Tests eignet.
In Selen,By.LINK_TEXTUndBy.PARTIAL_LINK_TEXTWird verwendet, um Elemente basierend auf dem Textinhalt eines Hyperlinks zu finden:
By.LINK_TEXT: Genaue Übereinstimmung basierend auf dem vollständigen Linktext.By.PARTIAL_LINK_TEXT: Fuzzy-Matching basierend auf einem Teil des Linktextes durchführen.vom Selenium Import Webdriver
von selenium.webdriver.common.by import By
# Browser starten
Treiber = webdriver.Chrome()
# Webseite öffnen
drivers.get("https://example.com")
# Verwenden Sie LINK_TEXT, um Hyperlinks zu finden
element = drivers.find_element(By.LINK_TEXT, „Vollständiger Linktext“)
print(element.get_attribute("href"))
# Verwenden Sie PARTIAL_LINK_TEXT, um Hyperlinks zu finden
element_partial = drivers.find_element(By.PARTIAL_LINK_TEXT, „Teiltext“)
print(element_partial.get_attribute("href"))
# Browser schließen
Driver.quit()<a href="https://example.com/page1">Vollständiger Linktext</a>
<a href="https://example.com/page2">Klicken Sie hier, um mehr zu erfahren</a>Angenommen, Sie möchten klicken<a>Vollständiger Linktext</a>, Sie können Folgendes verwenden:
drivers.find_element(By.LINK_TEXT, „Vollständiger Linktext“).click()Wenn der Hyperlink „Klicken Sie hier, um mehr zu erfahren“ lautet, wir aber nur „Klicken Sie hier“ kennen, können Sie Folgendes verwenden:
drivers.find_element(By.PARTIAL_LINK_TEXT, „Hier klicken“).click()By.PARTIAL_LINK_TEXT。By.LINK_TEXTfür eine exakte Übereinstimmung.<a>Label-Link.find_elements()gibt eine Liste zurück, whilefind_element()Es wird nur das erste passende Element zurückgegeben.By.LINK_TEXTNützlich, um vollständige Links präzise zu findenBy.PARTIAL_LINK_TEXTFlexibler und kann zum Abgleichen eines Teils des Linktexts verwendet werden.
vom Selenium Import Webdriver
von selenium.webdriver.common.by import By
aus selenium.webdriver.support.ui WebDriverWait importieren
Von selenium.webdriver.support importieren Sie erwartete_Bedingungen als EC
Treiber = webdriver.Chrome()
Versuchen Sie:
elems = WebDriverWait(driver, 10).until(
EC.presence_of_all_elements_located((By.CSS_SELECTOR, ".item"))
)
print("Element gefunden:", len(elems))
außer:
print("Element nicht innerhalb von 10 Sekunden gefunden")elements = drivers.find_elements(By.CSS_SELECTOR, ".item")
wenn nicht Elemente:
print("Element nicht gefunden")
sonst:
print("Anzahl der gefundenen Elemente:", len(elems))# Wechseln Sie zu iframe und suchen Sie erneut
iframe = drivers.find_element(By.TAG_NAME, „iframe“)
Driver.switch_to.frame(iframe)
elements = drivers.find_elements(By.CSS_SELECTOR, ".item")
print("Gefunden:", len(elems))shadow_host = driver.find_element(By.CSS_SELECTOR, "#shadowHost")
shadow_root = driver.execute_script("return arguments[0].shadowRoot", shadow_host)
elem = shadow_root.find_element(By.CSS_SELECTOR, ".target")
def safe_find_elements(driver, by, selector, timeout=10):
Versuchen Sie:
return WebDriverWait(driver, timeout).until(
EC.presence_of_all_elements_located((by, selector))
)
außer:
return [] # Die zurückgegebene leere Liste kann nicht gefunden werden
elements = safe_find_elements(driver, By.CSS_SELECTOR, ".item")
wenn Elemente:
print("Gefunden:", len(elems))
sonst:
print("Element nicht gefunden")vom Selenium Import Webdriver
aus selenium.webdriver.common.alert Import Alert
Treiber = webdriver.Chrome()
drivers.get("URL")
warning = Alert(Treiber)
print(alert.text) # Warnmeldung abrufen
alarm.accept() # Klicken Sie auf OK
Driver.quit()warning = Alert(Treiber)
print(alert.text)
alarm.accept() # Klicken Sie auf OK
# alarm.dismiss() # Zum Abbrechen klickenwarning = Alert(Treiber)
print(alert.text)
Alert.send_keys("Testeingabe") #Inhalt eingeben
alarm.accept() # Klicken Sie auf OKdriver.switch_to.alertWechseln Sie zur Benachrichtigungsbox.try-exceptBehandeln Sie Ausnahmen, um Testfehler zu vermeiden.
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
WebDriverWait(driver, 10).until(EC.alert_is_present())
In Selen können Sie verwendenWebDriverWaitum zu prüfen, ob das Warnfeld vorhanden ist, um Fehler zu vermeiden, die durch das Nichterscheinen des Warnfelds verursacht werden.
vom Selenium Import Webdriver
aus selenium.webdriver.common.alert Import Alert
aus selenium.webdriver.support.ui WebDriverWait importieren
Von selenium.webdriver.support importieren Sie erwartete_Bedingungen als EC
Treiber = webdriver.Chrome()
drivers.get("URL")
Versuchen Sie:
# Warten Sie 5 Sekunden, um zu prüfen, ob ein Warnfeld angezeigt wird
WebDriverWait(driver, 5).until(EC.alert_is_present())
warning = Alert(Treiber)
print("Inhalt der Warnbox:", alarm.text)
alarm.accept() # Klicken Sie auf OK
außer:
print("Kein Warnfeld gefunden")
Driver.quit()WebDriverWaitStellen Sie sicher, dass das Warnfeld angezeigt wird, bevor Sie wechseln, um dies zu vermeidenNoAlertPresentException。try-exceptUm zu verhindern, dass der Test fehlschlägt, weil kein Warnfeld vorhanden ist.verwendenWebDriverWait(driver, 5).until(EC.alert_is_present())Es kann nur von JavaScript generierte Warnfelder erkennen, nicht jedoch Warnfelder auf Chrome-Systemebene wie „Passwörter speichern“, „Website-Benachrichtigungen“ usw.
ChromeOptionsDeaktivieren Sie Warnfelder auf Systemebene.pyautoguioderWin32 APIum Tastatur- oder Mausbedienungen zu simulieren.Sie können Chrome starten, indem SieChromeOptionsum Benachrichtigungen und andere systemweite Popups zu schließen.
vom Selenium Import Webdriver
Optionen = webdriver.ChromeOptions()
options.add_argument("--disable-notifications") # Benachrichtigungen deaktivieren
options.add_argument("--disable-save-password-bubble") # Speichern von Passwortabfragen deaktivieren
Driver = webdriver.Chrome(options=options)
drivers.get("URL")Wenn das Warnfeld angezeigt wird, können Sie es verwendenpyautoguium Tastenbetätigungen wie das Drücken zu simulierenEnteroderEscschließen.
importpyautogui
Importzeit
time.sleep(3) # Warten Sie, bis das Warnfeld angezeigt wird
pyautogui.press("enter") # Simulieren Sie das Drücken der EingabetasteWenn Sie sich in einer Windows-Umgebung befinden, können Sie Folgendes verwendenpygetwindowUndpywinautoum Popups auf Systemebene zu erkennen und zu schließen.
Importiere Pygetwindow als GW
importpywinauto
windows = gw.getWindowsWithTitle("Google Chrome") # Holen Sie sich das Chrome-Fenster
für Win in Windows:
if „System Alert“ in win.title.lower(): # Überprüfen Sie, ob der Titel „System Alert“ enthält.
win.close() # Fenster schließenChromeOptionsWarnboxen zu verhindern.pyautoguioderWin32 APIum Tastatur- oder Fensterbedienungen zu simulieren.Shadow DOM ist Teil von Web Components und wird zur Kapselung von HTML, CSS und JavaScript verwendet, sodass die internen Implementierungsdetails von Komponenten die Außenwelt nicht beeinträchtigen.
Einfach ausgedrückt handelt es sich um eine DOM-Struktur, die den „Bereich isoliert“.
---<benutzerdefiniertes-element>
#shadow-root (offen)
<button>Klicken Sie auf mich</button>
</custom-element>buttonEs existiert tatsächlich im Schatten-DOM und kann nicht mit herkömmlichen Methoden verwendet werdendocument.querySelector("button")auftauchen.
element.shadowRootelement.shadowRootGibt null zurück, nicht zugänglichconst shadowHost = document.querySelector('#host');
const shadowRoot = shadowHost.attachShadow({ mode: 'open' });
shadowRoot.innerHTML = '<p>Hello from Shadow DOM</p>';
// im Schatten-DOM
<div><slot name="title">Standardtitel</slot></div>
// externe Verwendung
<benutzerdefiniertes-element>
<span slots="title">Benutzerdefinierter Titel</span>
</custom-element>js = """
const host = document.querySelector('custom-element');
const shadow = host.shadowRoot;
return shadow.querySelector('button');
"""
button = driver.execute_script(js)
button.click()
shadowRootSuchen Sie später erneutDer Tor-Browser besteht im Wesentlichen aus Firefox ESR plus Tor-Netzwerkeinstellungen und erweiterten Datenschutzeinstellungen. Selenium kann die Tor-Browser-GUI nicht direkt „steuern“, kann es aberFirefox + Tor SOCKS ProxySo erzielen Sie den gleichen Anonymitätseffekt wie der Tor-Browser.
Stellen Sie zunächst sicher, dass Tor auf dem lokalen Rechner läuft. Der Standard-SOCKS-Proxy ist:
127.0.0.1:9050
Wenn Sie den Tor-Browser verwenden, ist es nach dem Start normalerweise so:
127.0.0.1:9150
from selenium import webdriver
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.firefox.service import Service
options = Options()
options.set_preference("network.proxy.type", 1)
options.set_preference("network.proxy.socks", "127.0.0.1")
options.set_preference("network.proxy.socks_port", 9150)
options.set_preference("network.proxy.socks_remote_dns", True)
service = Service("geckodriver.exe")
driver = webdriver.Firefox(service=service, options=options)
driver.get("https://check.torproject.org")
Geben Sie die folgende URL ein und die Seite zeigt, dass die Verwendung von Tor Erfolg bedeutet:
https://check.torproject.org
Wenn Sie den im Tor-Browser integrierten Firefox verwenden möchten:
options.binary_location = r"C:\Tor Browser\Browser\firefox.exe"
from selenium import webdriver
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.firefox.service import Service
options = Options()
options.binary_location = r"C:\Tor Browser\Browser\firefox.exe"
options.set_preference("network.proxy.type", 1)
options.set_preference("network.proxy.socks", "127.0.0.1")
options.set_preference("network.proxy.socks_port", 9150)
options.set_preference("network.proxy.socks_remote_dns", True)
service = Service("geckodriver.exe")
driver = webdriver.Firefox(service=service, options=options)
driver.get("https://check.torproject.org")
Um E-Mails aus Thunderbird zu extrahieren, können Sie die IMAP-Protokollbibliothek von Python verwenden, z.imapliboder eine Bibliothek eines Drittanbietersimapclient. Stellen Sie zunächst sicher, dass dies der Fall ist
Thunderbird hat das IMAP-Protokoll aktiviert und ermöglicht die Verbindung externer Anwendungen.
Verwenden Sie pip, um verwandte Bibliotheken zu installieren:
pip install imapclient pyzmail36
Verwenden Sie den folgenden Code, um eine Verbindung zum E-Mail-Server herzustellen und wichtige E-Mails zu extrahieren:
imapclient importieren
aus Pyzmail PyzMessage importieren
# Mailserver und Anmeldeinformationen einrichten
IMAP_SERVER = 'imap.example.com' # Ersetzen Sie es durch Ihre IMAP-Serveradresse
EMAIL = '[email protected]'
PASSWORD = 'Ihr_Passwort'
# Stellen Sie eine Verbindung zum IMAP-Server her
mit imapclient.IMAPClient(IMAP_SERVER) als Client:
client.login(E-MAIL, PASSWORT)
client.select_folder('INBOX')
# Nach als wichtig markierten Nachrichten suchen
Nachrichten = client.search(['FLAGGED'])
für UID in Nachrichten:
raw_message = client.fetch([uid], ['BODY[]'])[uid][b'BODY[]']
message = PyzMessage.factory(raw_message)
# E-Mail-Informationen anzeigen
print(f"Betreff: {message.get_subject()}")
print(f"Von: {message.get_address('from')}")
print(f"Datum: {message.get_decoded_header('date')}")Führen Sie den obigen Code aus, um zu sehen, ob Sie als wichtig markierte E-Mails erfolgreich extrahieren können. Wenn Sie Verbindungsprobleme haben, können Sie Ihre Servereinstellungen überprüfen oder eine detailliertere Fehlerbehebung auf der IMAP-Protokollebene durchführen.
Auf diese Weise können Sie mit Python erfolgreich wichtige E-Mails aus Thunderbird extrahieren.
Installieren Sie PyAutoGUI mithilfe der folgenden Anweisungen:
pip install pyautoguiPyAutoGUI ist ein Automatisierungstool, das die Simulation von Maus- und Tastaturoperationen ermöglicht und sich für automatisierte GUI-Tests oder sich wiederholende Arbeiten eignet.
Steuern Sie die Mausposition und Aktionen:
importpyautogui
# Bildschirmauflösung abrufen
screen_width, screen_height = pyautogui.size()
print(f"Bildschirmauflösung: {screen_width}x{screen_height}")
# Bewegen Sie die Maus zu den angegebenen Koordinaten
pyautogui.moveTo(100, 100, Dauer=1)
# Bewegen Sie die Maus von der aktuellen Position
pyautogui.move(50, 50, Dauer=1)
# Mausklick simulieren
pyautogui.click(200, 200)
# Rechtsklick mit der Maus simulieren
pyautogui.rightClick()
# Simulieren Sie den Ziehvorgang
pyautogui.dragTo(400, 400, Dauer=1)Tastatureingabe simulieren:
importpyautogui
# Text eingeben
pyautogui.write("Hallo, PyAutoGUI!", Intervall=0,1)
# Simulieren Sie das Drücken einer bestimmten Taste
pyautogui.press("enter")
# Mehrere Tasten gleichzeitig drücken
pyautogui.hotkey("ctrl", "c") # Text kopierenMachen Sie einen Screenshot oder suchen Sie ein bestimmtes Bild:
importpyautogui
# Erfassen Sie den gesamten Bildschirm
Screenshot = pyautogui.screenshot()
screenshot.save("screenshot.png")
# Suchen Sie das Bild auf dem Bildschirm
location = pyautogui.locateOnScreen("image.png")
wenn Standort:
print(f"Bildspeicherort: {location}")
sonst:
print("Bild nicht gefunden")Um zu verhindern, dass das Programm auf unbestimmte Zeit ausgeführt wird, können Sie Folgendes verwenden:pyautogui.FAILSAFE：
pyautogui.FAILSAFE = True # Standard ist True
# Bewegen Sie die Maus in die obere linke Ecke des Bildschirms (0, 0), um das Programm sofort zu stoppenWenn Surfshark VPN keine Befehlszeilentools wie zsurfshark-cli), müssen Sie GUI-Automatisierungstools verwenden (z. Bpyautogui) simuliert den manuellen Betrieb.
pyautoguiModul (verfügbar überpip install pyautoguiInstallieren).durchpyautoguiAutomatisieren Sie den Klick auf eine Schaltfläche in der grafischen Oberfläche von Surfshark, um eine Verbindung zu einem VPN herzustellen oder zu trennen.
Im folgenden Beispiel wird davon ausgegangen, dass Surfshark VPN eine feste Tastenposition und -verwendung hatpyautoguiZu tun:
importpyautogui
Importzeit
def connect_vpn():
# Stellen Sie sicher, dass Surfshark eingeschaltet ist
print("Versuchen Sie, eine Verbindung zu VPN herzustellen ...")
# Simulieren Sie das Klicken auf die Schaltfläche „Verbinden“ und passen Sie die Koordinaten entsprechend dem tatsächlichen Standort an
pyautogui.click(x=500, y=300) # Durch die Position der Schaltfläche „Verbinden“ ersetzen
time.sleep(5) # Warten Sie, bis die Verbindung hergestellt ist
print("VPN verbunden")
defconnect_vpn():
# Stellen Sie sicher, dass Surfshark eingeschaltet ist
print("Versuchen Sie, die VPN-Verbindung zu trennen...")
# Simulieren Sie das Klicken auf die Schaltfläche „Trennen“ und passen Sie die Koordinaten entsprechend der tatsächlichen Position an
pyautogui.click(x=500, y=350) # Durch die Position der Schaltfläche „Trennen“ ersetzen
time.sleep(5) # Warten Sie, bis die Trennung abgeschlossen ist
print("VPN getrennt")
# Test
connect_vpn()
trennen_vpn()
xUndyKoordinaten.subprocessÖffnen Sie die Anwendung z.B.subprocess.run("start surfshark.exe", shell=True)。Wenn die Koordinatenmethode instabil ist, können Sie die Bilderkennung verwenden (z. Bpyautogui.locateOnScreen()), um die Tastenposition zu finden und die Flexibilität zu erhöhen.
Kivy ist ein Open-Source-Python-Framework für die schnelle Entwicklung von Multi-Touch-Anwendungen. Es wurde im Hinblick auf plattformübergreifende Unterstützung entwickelt und ermöglicht Entwicklern die Arbeit unter Windows, macOS, Linux, iOS und Android Warten Sie, bis derselbe Code auf mehreren Plattformen ausgeführt wird. Kivy eignet sich besonders für die Erstellung von GUI-Anwendungen für Mobiltelefone, Tablets und Desktop-Geräte und verfügt über eine gute Multi-Touch-Unterstützung.
Kivy-Anwendungen bestehen aus mehreren Widgets, die durch Code oder Kivys proprietäre KV-Sprachdateien angeordnet werden können. Unten sehen Sie ein einfaches Anwendungsbeispiel, das eine Schaltfläche anzeigt, deren Farbe sich ändert, wenn darauf geklickt wird.
von kivy.app Import-App
aus kivy.uix.button import Button
Klasse MyApp(App):
def build(self):
Return Button(text='Hallo, Kivy!',
background_color=(0, 1, 0, 1)) # Grüne Schaltfläche
if __name__ == '__main__':
MyApp().run()Kivy kann über pip installiert werden:
pip install kivyKivy eignet sich für eine Vielzahl von Anwendungsszenarien, unter anderem:
Kivy ist ein Python-Framework zum Erstellen plattformübergreifender Anwendungen, das jedoch normalerweise auf einem lokalen Gerät ausgeführt wird. Um Ihre Kivy-Anwendung aus der Ferne anzuzeigen, können Sie die folgenden Optionen in Betracht ziehen:
Sie können VNC (Virtual Network Computing) oder andere Remote-Desktop-Tools (wie RDP, TeamViewer usw.) verwenden, um Kivy-Anwendungen fernzusteuern und anzuzeigen.
Für diejenigen, die Linux verwenden, können Sie die X11-Weiterleitung verwenden, um remote eine grafische Oberfläche anzuzeigen:
ssh -X username@remote_hostSie können Flask oder andere Web-Frameworks verwenden, um Teile Ihrer Kivy-Anwendung Remotebenutzern zugänglich zu machen und sie über einen Webbrowser anzuzeigen:
Wenn Sie Ihre Kivy-App in einer Containerumgebung ausführen möchten, können Sie sie mit Docker und VNC einrichten:
This error indicates that the tickmarker module from Kivy's Garden is not installed. To fix this issue, follow the steps below:
pip install kivy-gardengarden install tickmarkerOnce you've done these steps, try running your Kivy application again.
Rio UI ist ein Benutzeroberflächen-Framework mit Python als Kern, das es Entwicklern ermöglicht, interaktive Anwendungen auf einfache und intuitive Weise zu schreiben. Es basiert auf der Python-Programmierlogik und präsentiert die Benutzeroberfläche durch moderne Front-End-Technologie.
pip install rio-ui
import rio
app = rio.App()
@app.page("/")
def index():
return rio.Text("Hello, Rio UI with Python!")
if __name__ == "__main__":
app.run()
email: [email protected]
