Bibliotheks- und Erweiterungs-FAQ¶
Allgemeine Bibliotheksfragen¶
Wie finde ich ein Modul oder eine Anwendung zur Ausführung von Aufgabe X?¶
Prüfen Sie in der Bibliotheksreferenz, ob ein relevantes Standardmodul vorhanden ist. (Irgendwann werden Sie wissen, was sich in der Standardbibliothek befindet, und diesen Schritt überspringen können.)
Suchen Sie für Pakete von Drittanbietern im Python Package Index oder versuchen Sie es mit Google oder einer anderen Web-Suchmaschine. Die Suche nach "Python" plus ein oder zwei Schlüsselwörtern für Ihr Interessengebiet wird normalerweise etwas Nützliches finden.
Wo ist die Quelldatei für math.py (socket.py, regex.py usw.)?¶
Wenn Sie keine Quelldatei für ein Modul finden können, handelt es sich möglicherweise um ein integriertes oder dynamisch geladenes Modul, das in C, C++ oder einer anderen kompilierten Sprache implementiert ist. In diesem Fall haben Sie möglicherweise nicht die Quelldatei oder es handelt sich um etwas wie mathmodule.c, irgendwo in einem C-Quellcodeverzeichnis (nicht im Python-Pfad).
Es gibt (mindestens) drei Arten von Modulen in Python:
Module, die in Python (.py) geschrieben sind;
Module, die in C geschrieben und dynamisch geladen werden (.dll, .pyd, .so, .sl usw.);
Module, die in C geschrieben und mit dem Interpreter verknüpft sind; um eine Liste davon zu erhalten, geben Sie ein
import sys print(sys.builtin_module_names)
Wie mache ich ein Python-Skript unter Unix ausführbar?¶
Sie müssen zwei Dinge tun: Der Modus der Skriptdatei muss ausführbar sein und die erste Zeile muss mit #! beginnen, gefolgt vom Pfad des Python-Interpreters.
Das Erste geschieht durch Ausführen von chmod +x scriptfile oder vielleicht chmod 755 scriptfile.
Das Zweite kann auf verschiedene Weise erfolgen. Der einfachste Weg ist, Folgendes zu schreiben:
#!/usr/local/bin/python
als allererste Zeile Ihrer Datei, wobei der Pfadname verwendet wird, wo der Python-Interpreter auf Ihrer Plattform installiert ist.
Wenn das Skript unabhängig davon sein soll, wo sich der Python-Interpreter befindet, können Sie das Programm env verwenden. Fast alle Unix-Varianten unterstützen Folgendes, vorausgesetzt, der Python-Interpreter befindet sich in einem Verzeichnis auf dem PATH des Benutzers.
#!/usr/bin/env python
Tun Sie dies *nicht* für CGI-Skripte. Die Variable PATH für CGI-Skripte ist oft sehr minimal, daher müssen Sie den tatsächlichen absoluten Pfadnamen des Interpreters verwenden.
Gelegentlich ist die Umgebung eines Benutzers so voll, dass das Programm /usr/bin/env fehlschlägt; oder es gibt gar kein env-Programm. In diesem Fall können Sie den folgenden Trick versuchen (von Alex Rezinsky)
#! /bin/sh
""":"
exec python $0 ${1+"$@"}
"""
Der geringe Nachteil ist, dass dies die __doc__-Zeichenkette des Skripts definiert. Sie können dies jedoch korrigieren, indem Sie hinzufügen
__doc__ = """...Whatever..."""
Gibt es ein curses/termcap-Paket für Python?¶
Für Unix-Varianten: Die Standard-Python-Quelldistribution enthält ein curses-Modul im Unterverzeichnis Modules, obwohl es nicht standardmäßig kompiliert wird. (Beachten Sie, dass dies in der Windows-Distribution nicht verfügbar ist – es gibt kein curses-Modul für Windows.)
Das Modul curses unterstützt grundlegende curses-Funktionen sowie viele zusätzliche Funktionen von ncurses und SYSV curses wie Farben, Unterstützung für alternative Zeichensätze, Pads und Mausunterstützung. Das bedeutet, dass das Modul nicht mit Betriebssystemen kompatibel ist, die nur BSD curses haben, aber es scheint keine derzeit gewarteten Betriebssysteme zu geben, die in diese Kategorie fallen.
Gibt es in Python ein Äquivalent zu C's onexit()?¶
Das Modul atexit bietet eine Registrierungsfunktion, die ähnlich wie C's onexit() ist.
Warum funktionieren meine Signal-Handler nicht?¶
Das häufigste Problem ist, dass der Signal-Handler mit der falschen Argumentenliste deklariert ist. Er wird aufgerufen als
handler(signum, frame)
daher sollte er mit zwei Parametern deklariert werden
def handler(signum, frame):
...
Häufige Aufgaben¶
Wie teste ich ein Python-Programm oder eine Python-Komponente?¶
Python wird mit zwei Testframeworks geliefert. Das Modul doctest findet Beispiele in den Docstrings eines Moduls und führt sie aus, wobei die Ausgabe mit der in der Docstring angegebenen erwarteten Ausgabe verglichen wird.
Das Modul unittest ist ein schickeres Testframework, das nach dem Vorbild von Java- und Smalltalk-Testframeworks gestaltet ist.
Um das Testen zu erleichtern, sollten Sie ein gutes modulare Design in Ihrem Programm verwenden. Ihr Programm sollte fast die gesamte Funktionalität in Funktionen oder Klassenmethoden kapseln – und dies hat manchmal den überraschenden und erfreulichen Effekt, dass das Programm schneller läuft (da Zugriffe auf lokale Variablen schneller sind als Zugriffe auf globale). Darüber hinaus sollte das Programm die Abhängigkeit von mutierbaren globalen Variablen vermeiden, da dies das Testen erheblich erschwert.
Die "globale Hauptlogik" Ihres Programms kann so einfach sein wie
if __name__ == "__main__":
main_logic()
am Ende des Hauptmoduls Ihres Programms.
Sobald Ihr Programm als handhabbare Sammlung von Funktions- und Verhaltensweisen von Klassen organisiert ist, sollten Sie Testfunktionen schreiben, die die Verhaltensweisen ausführen. Eine Test-Suite, die eine Sequenz von Tests automatisiert, kann jedem Modul zugeordnet werden. Das klingt nach viel Arbeit, aber da Python so kurz und flexibel ist, ist es überraschend einfach. Sie können das Codieren viel angenehmer und unterhaltsamer gestalten, indem Sie Ihre Testfunktionen parallel zum "Produktionscode" schreiben, da dies das Finden von Fehlern und sogar Designfehlern erleichtert.
"Support-Module", die nicht als Hauptmodul eines Programms gedacht sind, können einen Selbsttest des Moduls enthalten.
if __name__ == "__main__":
self_test()
Selbst Programme, die mit komplexen externen Schnittstellen interagieren, können getestet werden, wenn die externen Schnittstellen nicht verfügbar sind, indem "gefälschte" Schnittstellen verwendet werden, die in Python implementiert sind.
Wie erstelle ich Dokumentation aus Docstrings?¶
Das Modul pydoc kann HTML aus den Docstrings in Ihrem Python-Quellcode erstellen. Eine Alternative zur Erstellung von API-Dokumentation ausschließlich aus Docstrings ist epydoc. Sphinx kann auch Docstring-Inhalte einbeziehen.
Wie empfange ich einzelne Tastendrücke?¶
Für Unix-Varianten gibt es mehrere Lösungen. Dies lässt sich mit curses einfach bewerkstelligen, aber curses ist ein ziemlich großes Modul zum Erlernen.
Threads¶
Wie programmiere ich mit Threads?¶
Verwenden Sie unbedingt das Modul threading und nicht das Modul _thread. Das Modul threading baut praktische Abstraktionen auf den von _thread bereitgestellten Niedrigstufen-Primitiven auf.
Keiner meiner Threads scheint zu laufen: Warum?¶
Sobald der Hauptthread beendet ist, werden alle Threads beendet. Ihr Hauptthread läuft zu schnell und gibt den Threads keine Zeit, Arbeit zu verrichten.
Eine einfache Lösung ist, am Ende des Programms einen Sleep hinzuzufügen, der lang genug ist, damit alle Threads fertig werden.
import threading, time
def thread_task(name, n):
for i in range(n):
print(name, i)
for i in range(10):
T = threading.Thread(target=thread_task, args=(str(i), i))
T.start()
time.sleep(10) # <---------------------------!
Aber jetzt (auf vielen Plattformen) laufen die Threads nicht parallel, sondern scheinen sequenziell, nacheinander zu laufen! Der Grund ist, dass der Betriebssystem-Thread-Scheduler keinen neuen Thread startet, bis der vorherige Thread blockiert ist.
Eine einfache Lösung ist, einen winzigen Sleep am Anfang der run-Funktion hinzuzufügen.
def thread_task(name, n):
time.sleep(0.001) # <--------------------!
for i in range(n):
print(name, i)
for i in range(10):
T = threading.Thread(target=thread_task, args=(str(i), i))
T.start()
time.sleep(10)
Anstatt zu versuchen, einen guten Verzögerungswert für time.sleep() zu erraten, ist es besser, eine Art Semaphor-Mechanismus zu verwenden. Eine Idee ist, das Modul queue zu verwenden, um ein Queue-Objekt zu erstellen, jeden Thread ein Token in die Queue einfügen zu lassen, wenn er fertig ist, und den Hauptthread so viele Tokens aus der Queue lesen zu lassen, wie es Threads gibt.
Wie verteile ich Arbeit auf eine Gruppe von Worker-Threads?¶
Der einfachste Weg ist die Verwendung des Moduls concurrent.futures, insbesondere der Klasse ThreadPoolExecutor.
Oder, wenn Sie eine feine Kontrolle über den Dispatching-Algorithmus wünschen, können Sie Ihre eigene Logik manuell schreiben. Verwenden Sie das Modul queue, um eine Queue mit einer Liste von Jobs zu erstellen. Die Klasse Queue verwaltet eine Liste von Objekten und verfügt über eine Methode .put(obj), die Elemente zur Queue hinzufügt, und eine Methode .get(), um sie zurückzugeben. Die Klasse kümmert sich um die Sperren, die erforderlich sind, um sicherzustellen, dass jeder Job genau einmal ausgegeben wird.
Hier ist ein triviales Beispiel
import threading, queue, time
# The worker thread gets jobs off the queue. When the queue is empty, it
# assumes there will be no more work and exits.
# (Realistically workers will run until terminated.)
def worker():
print('Running worker')
time.sleep(0.1)
while True:
try:
arg = q.get(block=False)
except queue.Empty:
print('Worker', threading.current_thread(), end=' ')
print('queue empty')
break
else:
print('Worker', threading.current_thread(), end=' ')
print('running with argument', arg)
time.sleep(0.5)
# Create queue
q = queue.Queue()
# Start a pool of 5 workers
for i in range(5):
t = threading.Thread(target=worker, name='worker %i' % (i+1))
t.start()
# Begin adding work to the queue
for i in range(50):
q.put(i)
# Give threads time to run
print('Main thread sleeping')
time.sleep(5)
Bei der Ausführung erzeugt dies die folgende Ausgabe
Running worker
Running worker
Running worker
Running worker
Running worker
Main thread sleeping
Worker <Thread(worker 1, started 130283832797456)> running with argument 0
Worker <Thread(worker 2, started 130283824404752)> running with argument 1
Worker <Thread(worker 3, started 130283816012048)> running with argument 2
Worker <Thread(worker 4, started 130283807619344)> running with argument 3
Worker <Thread(worker 5, started 130283799226640)> running with argument 4
Worker <Thread(worker 1, started 130283832797456)> running with argument 5
...
Konsultieren Sie die Dokumentation des Moduls für weitere Details; die Klasse Queue bietet eine funktionsreiche Schnittstelle.
Welche Art von globaler Wertmutation ist Thread-sicher?¶
Ein globaler Interpreter-Lock (GIL) wird intern verwendet, um sicherzustellen, dass nur ein Thread gleichzeitig in der Python-VM läuft. Im Allgemeinen bietet Python die Möglichkeit, zwischen Threads nur zwischen Bytecode-Instruktionen zu wechseln; wie oft gewechselt wird, kann über sys.setswitchinterval() eingestellt werden. Jede Bytecode-Instruktion und damit der gesamte C-Implementierungscode, der von jeder Instruktion erreicht wird, ist daher aus Sicht eines Python-Programms atomar.
Theoretisch erfordert eine exakte Abrechnung ein exaktes Verständnis der PVM-Bytecode-Implementierung. In der Praxis bedeutet dies, dass Operationen auf gemeinsamen Variablen von integrierten Datentypen (Integers, Listen, Dictionaries usw.), die "atomar aussehen", auch wirklich atomar sind.
Zum Beispiel sind die folgenden Operationen alle atomar (L, L1, L2 sind Listen, D, D1, D2 sind Dictionaries, x, y sind Objekte, i, j sind ganze Zahlen)
L.append(x)
L1.extend(L2)
x = L[i]
x = L.pop()
L1[i:j] = L2
L.sort()
x = y
x.field = y
D[x] = y
D1.update(D2)
D.keys()
Diese sind es nicht.
i = i+1
L.append(L[-1])
L[i] = L[j]
D[x] = D[x] + 1
Operationen, die andere Objekte ersetzen, können die __del__()-Methode dieser anderen Objekte aufrufen, wenn ihre Referenzanzahl Null erreicht, und das kann die Dinge beeinflussen. Dies gilt insbesondere für die Massenaktualisierungen von Dictionaries und Listen. Im Zweifelsfall verwenden Sie eine Mutex!
Können wir den Global Interpreter Lock nicht abschaffen?¶
Der globale Interpreter-Lock (GIL) wird oft als Hindernis für die Bereitstellung von Python auf leistungsstarken Mehrprozessor-Servermaschinen angesehen, da ein Multithread-Python-Programm aufgrund der Vorgabe, dass (fast) jeder Python-Code nur ausgeführt werden kann, während der GIL gehalten wird, effektiv nur eine CPU nutzt.
Mit der Genehmigung von PEP 703 sind die Arbeiten zur Entfernung des GIL aus der CPython-Implementierung von Python im Gange. Zunächst wird er als optionales Compiler-Flag beim Erstellen des Interpreters implementiert, und so werden separate Builds mit und ohne GIL verfügbar sein. Langfristig hofft man, sich auf einen einzigen Build zu einigen, sobald die Leistungsauswirkungen der Entfernung des GIL vollständig verstanden sind. Python 3.13 wird voraussichtlich die erste Veröffentlichung sein, die diese Arbeiten enthält, obwohl sie in dieser Veröffentlichung möglicherweise noch nicht vollständig funktionsfähig ist.
Die aktuellen Arbeiten zur Entfernung des GIL basieren auf einem Fork von Python 3.9 mit entferntem GIL von Sam Gross. Zuvor, in den Tagen von Python 1.5, implementierte Greg Stein ein umfassendes Patch-Set (die "free threading"-Patches), das den GIL entfernte und durch feingranulare Sperren ersetzte. Adam Olsen führte ein ähnliches Experiment in seinem Projekt python-safethread durch. Leider zeigten beide dieser früheren Experimente einen starken Rückgang der Single-Thread-Leistung (mindestens 30 % langsamer), aufgrund der Menge an feingranularer Sperrung, die erforderlich war, um die Entfernung des GIL zu kompensieren. Der Python 3.9-Fork ist der erste Versuch, den GIL mit akzeptablen Leistungsauswirkungen zu entfernen.
Die Präsenz des GIL in aktuellen Python-Versionen bedeutet nicht, dass Sie Python auf Multi-CPU-Maschinen nicht gut nutzen können! Sie müssen nur kreativ sein, um die Arbeit zwischen mehreren *Prozessen* anstatt mehreren *Threads* aufzuteilen. Die Klasse ProcessPoolExecutor im neuen Modul concurrent.futures bietet eine einfache Möglichkeit dazu; das Modul multiprocessing bietet eine niedrigstufigere API, falls Sie mehr Kontrolle über die Verteilung von Aufgaben wünschen.
Die gezielte Verwendung von C-Erweiterungen hilft ebenfalls; wenn Sie eine C-Erweiterung zur Ausführung einer zeitaufwendigen Aufgabe verwenden, kann die Erweiterung den GIL freigeben, während der Ausführungs-Thread im C-Code läuft, und anderen Threads die Arbeit ermöglichen. Einige Standardmodule wie zlib und hashlib tun dies bereits.
Ein alternativer Ansatz zur Reduzierung der Auswirkungen des GIL ist die Umwandlung des GIL in ein sperren des per-Interpreter-Zustands statt eines wirklich globalen. Dies wurde erstmals in Python 3.12 implementiert und ist in der C-API verfügbar. Eine Python-Schnittstelle dazu wird für Python 3.13 erwartet. Die Hauptbeschränkung ist derzeit wahrscheinlich 3rd-Party-Erweiterungsmodule, da diese für die Verwendbarkeit mit mehreren Interpretern geschrieben werden müssen, sodass viele ältere Erweiterungsmodule nicht verwendbar sein werden.
Ein- und Ausgabe¶
Wie lösche ich eine Datei? (Und andere Fragen zu Dateien…)¶
Verwenden Sie os.remove(filename) oder os.unlink(filename); für die Dokumentation siehe das Modul os. Die beiden Funktionen sind identisch; unlink() ist einfach der Name des Unix-Systemaufrufs für diese Funktion.
Zum Entfernen eines Verzeichnisses verwenden Sie os.rmdir(); zum Erstellen eines Verzeichnisses verwenden Sie os.mkdir(). os.makedirs(path) erstellt alle übergeordneten Verzeichnisse in path, die nicht existieren. os.removedirs(path) entfernt übergeordnete Verzeichnisse, solange sie leer sind; wenn Sie einen gesamten Verzeichnisbaum und seinen Inhalt löschen möchten, verwenden Sie shutil.rmtree().
Zum Umbenennen einer Datei verwenden Sie os.rename(old_path, new_path).
Zum Kürzen einer Datei öffnen Sie sie mit f = open(filename, "rb+") und verwenden f.truncate(offset); offset ist standardmäßig die aktuelle Suchposition. Es gibt auch os.ftruncate(fd, offset) für Dateien, die mit os.open() geöffnet wurden, wobei fd der Dateideskriptor (eine kleine Ganzzahl) ist.
Das Modul shutil enthält auch eine Reihe von Funktionen zur Bearbeitung von Dateien, darunter copyfile(), copytree() und rmtree().
Wie kopiere ich eine Datei?¶
Das Modul shutil enthält eine Funktion copyfile(). Beachten Sie, dass auf Windows NTFS-Volumes keine alternativen Datenströme und auf macOS HFS+-Volumes keine Ressourcen-Forks kopiert werden, obwohl beide jetzt selten verwendet werden. Es kopiert auch keine Dateiberechtigungen und Metadaten, obwohl die Verwendung von shutil.copy2() stattdessen die meisten (wenn auch nicht alle) davon beibehält.
Wie lese (oder schreibe) ich Binärdaten?¶
Für das Lesen oder Schreiben komplexer Binärdatenformate ist es am besten, das Modul struct zu verwenden. Es ermöglicht Ihnen, eine Zeichenkette mit Binärdaten (normalerweise Zahlen) zu nehmen und sie in Python-Objekte zu konvertieren; und umgekehrt.
Zum Beispiel liest der folgende Code zwei 2-Byte-Integer und einen 4-Byte-Integer im Big-Endian-Format aus einer Datei
import struct
with open(filename, "rb") as f:
s = f.read(8)
x, y, z = struct.unpack(">hhl", s)
Das ">" in der Formatzeichenkette erzwingt Big-Endian-Daten; der Buchstabe "h" liest einen "short integer" (2 Bytes) und "l" liest einen "long integer" (4 Bytes) aus der Zeichenkette.
Für Daten, die regelmäßiger sind (z. B. eine homogene Liste von Integers oder Floats), können Sie auch das Modul array verwenden.
Hinweis
Um Binärdaten zu lesen und zu schreiben, ist es zwingend erforderlich, die Datei im Binärmodus zu öffnen (hier durch Übergabe von "rb" an open()). Wenn Sie stattdessen "r" verwenden (Standard), wird die Datei im Textmodus geöffnet und f.read() gibt str-Objekte anstelle von bytes-Objekten zurück.
Ich kann os.read() nicht auf einer mit os.popen() erstellten Pipe verwenden; warum?¶
os.read() ist eine Low-Level-Funktion, die einen Dateideskriptor entgegennimmt, eine kleine Ganzzahl, die die geöffnete Datei repräsentiert. os.popen() erstellt ein High-Level-Datei-Objekt, denselben Typ, der von der integrierten Funktion open() zurückgegeben wird. Um also n Bytes aus einer Pipe p zu lesen, die mit os.popen() erstellt wurde, müssen Sie p.read(n) verwenden.
Wie greife ich auf den seriellen (RS232) Port zu?¶
Für Win32, OSX, Linux, BSD, Jython, IronPython
Für Unix siehe einen Usenet-Post von Mitch Chapman
Warum schließt sys.stdout (stdin, stderr) sie nicht wirklich?¶
Python Dateiobjekte sind eine Abstraktionsebene auf niedriger Ebene auf C-Dateideskriptoren.
Für die meisten Dateiobjekte, die Sie in Python über die eingebaute Funktion open() erstellen, markiert f.close() das Python-Dateiobjekt als geschlossen aus Sicht von Python und veranlasst auch, den zugrunde liegenden C-Dateideskriptor zu schließen. Dies geschieht auch automatisch im Destruktor von f, wenn f zu einem Müll wird.
Aber stdin, stdout und stderr werden von Python speziell behandelt, da ihnen auch von C ein besonderer Status eingeräumt wird. Das Ausführen von sys.stdout.close() markiert das Dateiobjekt auf Python-Ebene als geschlossen, schließt aber den zugehörigen C-Dateideskriptor *nicht*.
Um den zugrunde liegenden C-Dateideskriptor für eines dieser drei zu schließen, sollten Sie sich zunächst sicher sein, dass Sie dies wirklich tun möchten (z.B. könnten Sie Erweiterungsmodule verwirren, die versuchen, I/O durchzuführen). Wenn ja, verwenden Sie os.close()
os.close(stdin.fileno())
os.close(stdout.fileno())
os.close(stderr.fileno())
Oder Sie können die numerischen Konstanten 0, 1 und 2 verwenden.
Netzwerk-/Internetprogrammierung¶
Welche WWW-Tools gibt es für Python?¶
Siehe die Kapitel mit den Titeln Internetprotokolle und Unterstützung und Internetdatenverarbeitung im Handbuch der Bibliothek. Python verfügt über viele Module, die Ihnen beim Erstellen von serverseitigen und clientseitigen Websystemen helfen.
Eine Zusammenfassung der verfügbaren Frameworks wird von Paul Boddie unter https://wiki.python.org/moin/WebProgramming gepflegt.
Welches Modul sollte ich zur Hilfe bei der Generierung von HTML verwenden?¶
Eine Sammlung nützlicher Links finden Sie auf der Web Programming Wiki-Seite.
Wie versende ich E-Mails von einem Python-Skript?¶
Verwenden Sie das Standardbibliothekmodul smtplib.
Hier ist ein sehr einfacher interaktiver E-Mail-Sender, der es verwendet. Diese Methode funktioniert auf jedem Host, der einen SMTP-Listener unterstützt.
import sys, smtplib
fromaddr = input("From: ")
toaddrs = input("To: ").split(',')
print("Enter message, end with ^D:")
msg = ''
while True:
line = sys.stdin.readline()
if not line:
break
msg += line
# The actual mail send
server = smtplib.SMTP('localhost')
server.sendmail(fromaddr, toaddrs, msg)
server.quit()
Eine reine Unix-Alternative verwendet sendmail. Der Speicherort des sendmail-Programms variiert je nach System; manchmal ist es /usr/lib/sendmail, manchmal /usr/sbin/sendmail. Die Manpage von sendmail hilft Ihnen weiter. Hier ist ein Beispielcode
import os
SENDMAIL = "/usr/sbin/sendmail" # sendmail location
p = os.popen("%s -t -i" % SENDMAIL, "w")
p.write("To: receiver@example.com\n")
p.write("Subject: test\n")
p.write("\n") # blank line separating headers from body
p.write("Some text\n")
p.write("some more text\n")
sts = p.close()
if sts != 0:
print("Sendmail exit status", sts)
Wie vermeide ich Blockierung in der connect()-Methode eines Sockets?¶
Das Modul select wird üblicherweise verwendet, um bei asynchroner I/O auf Sockets zu helfen.
Um zu verhindern, dass die TCP-Verbindung blockiert, können Sie den Socket in den Nicht-Blockierungsmodus versetzen. Dann erhalten Sie beim Aufruf von connect() entweder eine sofortige Verbindung (unwahrscheinlich) oder eine Ausnahme, die die Fehlernummer als .errno enthält. errno.EINPROGRESS zeigt an, dass die Verbindung läuft, aber noch nicht abgeschlossen ist. Verschiedene Betriebssysteme geben unterschiedliche Werte zurück, daher müssen Sie prüfen, was auf Ihrem System zurückgegeben wird.
Sie können die Methode connect_ex() verwenden, um eine Ausnahme zu vermeiden. Sie gibt einfach den errno-Wert zurück. Um abzufragen, können Sie connect_ex() später erneut aufrufen – 0 oder errno.EISCONN zeigen an, dass Sie verbunden sind – oder Sie können diesen Socket an select.select() übergeben, um zu prüfen, ob er schreibbar ist.
Datenbanken¶
Gibt es Schnittstellen zu Datenbankpaketen in Python?¶
Ja.
Schnittstellen zu festplattengestützten Hashes wie DBM und GDBM sind ebenfalls in der Standard-Python-Installation enthalten. Es gibt auch das Modul sqlite3, das eine leichtgewichtige festplattengestützte relationale Datenbank bereitstellt.
Unterstützung für die meisten relationalen Datenbanken ist verfügbar. Details finden Sie auf der Datenbankprogrammierung Wiki-Seite.
Wie implementiert man persistente Objekte in Python?¶
Das Modul der pickle-Bibliothek löst dies auf sehr allgemeine Weise (obwohl Sie immer noch keine Dinge wie offene Dateien, Sockets oder Fenster speichern können), und das Modul der shelve-Bibliothek verwendet pickle und (g)dbm, um persistente Abbildungen zu erstellen, die beliebige Python-Objekte enthalten.
Mathematik und Numerik¶
Wie generiere ich Zufallszahlen in Python?¶
Das Standardmodul random implementiert einen Zufallszahlengenerator. Die Verwendung ist einfach
import random
random.random()
Dies gibt eine zufällige Gleitkommazahl im Bereich [0, 1) zurück.
Es gibt auch viele andere spezialisierte Generatoren in diesem Modul, wie zum Beispiel
randrange(a, b)wählt eine Ganzzahl im Bereich [a, b).uniform(a, b)wählt eine Gleitkommazahl im Bereich [a, b).normalvariate(mean, sdev)erzeugt eine Stichprobe der Normal (Gaußschen) Verteilung.
Einige High-Level-Funktionen arbeiten direkt mit Sequenzen, wie z.B.
choice(S)wählt ein zufälliges Element aus einer gegebenen Sequenz.shuffle(L)mischt eine Liste an Ort und Stelle, d.h. permutiert sie zufällig.
Es gibt auch eine Klasse Random, die Sie instanziieren können, um unabhängige, mehrfache Zufallszahlengeneratoren zu erstellen.