Sockets sind die Schnittstelle, über die zwei oder mehr Computer über ein Netzwerk miteinander kommunizieren können. Dank dessen können wir verschiedene Arten von Anwendungen erstellen, die uns bei der Datenübertragung über das Internet helfen und so Ergebnisse erzielen, die wir sonst in Echtzeit nicht hätten.

Eine der gebräuchlichsten Methoden zur Implementierung von Sockets ist das TCP- Protokoll. Dies unterstützt die normale und reibungslose Übertragung des Betriebssystems über das Internet.

Ändern Sie das Socket-Timeout

Da wir ein wenig über das Grundkonzept von Sockets Bescheid wissen, werden wir zunächst seine Eigenschaften manipulieren. Eine davon ist die Wartezeit.

Wartezeit

Die Wartezeit gibt an , wie lange der Socket auf den Empfang oder das Senden von Daten achten kann. Dies ist sehr wichtig, da bei einer Blockierung der Anwendung während dieser Wartezeit die Gefahr einer vollständigen Verlangsamung besteht System Aus diesem Grund müssen wir in der Lage sein, die voreingestellte Wartezeit zu kennen und auch selbst eine Wartezeit einzurichten.

Um dies zu erreichen, können wir einige Methoden verwenden, die zu diesem Zweck in der Standard- Python- Socket- Bibliothek vorhanden sind.

gettimeout ()

Die erste Methode ist gettimeout () und gibt uns, wie der Name schon sagt, die anfängliche Wartezeit des Sockets an, die wir als Parameter übergeben.

Settimeout ()

Die zweite Methode ist settimeout (), und ihre Funktionalität besteht darin, ein Zeitlimit für den betreffenden Socket in Millisekunden festzulegen .

Festlegen der Wartezeit

Wir werden jetzt ein kleines Programm erstellen, mit dem wir das Gelernte in die Tat umsetzen können. Dazu erstellen wir zunächst ein Objekt vom Socket-Typ, das als Testobjekt dient. Dazu übergeben wir die Familie und den Socket-Typ auf den Konstruktor und damit können wir die Methoden anwenden.

Um die Änderungen zu sehen, nachdem wir unseren Socket erstellt haben, drucken wir die Wartezeit, die null sein muss, da es sich um ein neues Objekt handelt. Dann setzen wir mit der settimeout () -Methode eine neue Wartezeit und drucken schließlich auch die Informationen Wir werden bestätigen, dass alles so funktioniert hat, wie es sollte.

Um all dies zu erreichen, müssen wir sicherstellen, dass Python auf unserem System in der Version 2.7 installiert ist und über einen Texteditor verfügen, mit dem die Dateien mit den Programmen erstellt werden können. Wir können die Übung jedoch auch in der Konsole ausführen unangenehm und es ist nicht dauerhaft, was bedeutet, dass wir unseren Job verlieren würden. Sehen wir uns den Quellcode dieses Beispiels an:

 #! / usr / bin / env Python Import-Socket def time_wait_socket (): s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) print "Die anfängliche Wartezeit ist:% s"% s.gettimeout () am einstellungsende (100) print "Die neue Wartezeit ist:% s"% s.gettimeout () if __name__ == '__main__': time_wait_socket ()

Dies wird in einer neuen Datei namens socketTimeWeb.py gespeichert und in der Konsole ausgeführt. Das Ergebnis sollte ungefähr so aussehen :

Ändern Sie die Größe eines Socket-Puffers

Der Puffer ist eines der Dinge, die wir bei der Arbeit mit Sockets berücksichtigen müssen, da diese Komponente die Datenmenge angibt, die wir momentan übertragen können. Je größer die Puffermenge, desto größer die Datenmenge. Dies bedeutet jedoch auch einen höheren Ressourcenverbrauch und eine längere Wartezeit bei der Übertragung. Andernfalls bedeutet ein niedrigerer Puffer eine höhere Geschwindigkeit, obwohl die zu übertragende Datenmenge begrenzt ist. Aus diesem Grund müssen wir diese Fähigkeit beherrschen.

setsockopt ()

Um uns bei der Bearbeitung des Puffers zu helfen, bietet die Python- Socket- Bibliothek die Methode setsockopt () an, die wir auf eine Instanz der Socket-Klasse anwenden müssen. Wenn wir die Größe des Puffers ändern wollen, müssen wir zuerst die ursprüngliche Größe des Socket-Puffers kennen, dazu haben wir auch die getsockopt () -Methode und sie wird auf sehr ähnliche Weise wie die oben beschriebene Methode verwendet.

Einstellen der Puffergröße

Wir werden ein kleines Programm erstellen, um zu demonstrieren, was wir oben erklärt haben. In dem Code, den wir sehen werden, werden wir zuerst ein Paar Konstanten erstellen , die wir in unserem Programm verwenden werden, und sie werden auf 4096 definiert, was ein Wert für die Größe der Puffer ist dass wir etablieren werden

Dann erstellen wir eine Instanz der Socket-Klasse, um sofort nach den Anfangsgrößen des Puffers zu fragen, und drucken sie dann auf dem Bildschirm.

Schließlich verwenden wir die Methode setsockopt () , um die gewünschte Größe des Puffers anhand der zu Beginn des Programms definierten Konstanten zu ermitteln. Diese Methode empfängt drei Parameter, die Ebene, den Namen und schließlich den Wert für den Puffer.

Sehen wir uns den Code an, der uns hilft, das zu spezifizieren, was wir erklärt haben. Wir speichern ihn in einer Datei mit dem Namen tamano_buffer.py :

 #! / usr / bin / env Python Import-Socket TAM_BUFFER_ENVIO = 4096 TAM_BUFFER_RECEPTION = 4096 def manipulate_buffer (): sock = socket.socket (socket.AF_INET, socket.SOCK_STREAM) # Liefert die Größe des Sendepuffers des Sockets sizeBuffer = sock.getsockopt (socket.SOL_SOCKET, socket.SO_SNDBUF) print "Puffergröße [Vorher]:% d"% sizeBuffer sock.setsockopt (socket.SOL_TCP, socket.TCP_NODELAY, 1) sock.setsockopt (socket.SOL_SOCKET, socket.SO_SNDBUF, TAM_BUFFER_ENVIO) sock.setsockopt (socket.SOL_SOCKET, socket.SO_RCVBUF, TAM_BUFFER_RECEPTION) sizeBuffer = sock.getsockopt (socket.SOL_SOCKET, socket.SO_SNDBUF) print "Buffer Size [After]:% d"% sizeBuffer if __name__ == '__main__': manipulate_buffer ()

Sobald wir unser Programm geschrieben haben, werden wir es in der Konsole ausführen und sehen, dass wir die Werte des Puffers erhalten, bevor und nachdem wir seine Größe geändert haben.

Fehlerbehandlung

Wie bei allen Arten von Programmen müssen wir auch bei der Arbeit mit Sockets vermeiden, dass diese Fehler uns überraschen, da unsere Anwendung in diesem Fall möglicherweise unvorhersehbar funktioniert.

Aus diesem Grund müssen wir lernen, mit Fehlern umzugehen. Wenn eine unerwartete Situation eintritt, stirbt unser Programm nicht ab, wenn wir benachrichtigt werden, dass etwas passiert ist, und verhindert so die Beschädigung von Daten oder ähnlichen Situationen, die sich auf die Stabilität unseres Systems auswirken programmieren.

Wie geht man damit um?

Dies erreichen wir durch die Verwendung von try – except – Blöcken, mit denen wir Situationen auswerten können, bei denen es sich in der Regel um Daten handelt, die außerhalb unserer Kontrolle liegen, und mit denen wir in Szenarien entsprechend den erhaltenen Antworten handeln können. Wenn wir in den Except- Abschnitt des Blocks fallen, können wir die error-Eigenschaft unserer Instanz verwenden und damit drucken, was passiert ist, und wissen, was der Fehler war.

Erstellen eines Programms, das Fehler behandelt

Im folgenden Programm werden wir testen, was wir während der Erklärung definiert haben. Zuerst werden wir einen Block erstellen, der uns kontrolliert, ob beim Erstellen des Sockets ein Fehler aufgetreten ist oder nicht. Auf diese Weise können wir einen guten Start unseres Codes sicherstellen.

Anschließend werden wir die Verbindung unserer Anwendung mit einem Remote-Host über einen bestimmten Port auswerten und mit der Behandlung von Fehlern eine personalisierte Nachricht definieren. Schließlich rufen wir unsere Funktion auf und führen damit die beschriebenen Aktionen aus.

Sehen wir uns den folgenden Code an, den wir in einer Datei mit dem Namen error_socket.py speichern und dann in der Konsole ausführen sollten:

 #! / usr / bin / env Python Import sys Import-Socket host = 'http: //python.orgt' port = '06' def error_handle (): versuche: s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) außer socket.error, e: print "Beim Erstellen des Sockets ist ein Fehler aufgetreten:% s"% e sys.exit (1) versuche: an connect ((host, port)) außer socket.gaierror, e: print "Fehler in der Verbindungsadresse:% s"% e sys.exit (1) außer socket.error, e: print "Verbindungsfehler:% s"% e sys.exit (1) if __name__ == '__main__': error_handling ()

Hier sehen wir, dass wir die sys- Bibliothek verwendet haben, um die exit () -Methode zu verwenden und das Programm zu schließen, nachdem ein Fehler aufgetreten ist. Wir haben auch festgestellt, dass der Host nicht korrekt ist, damit wir den Fehler erzwingen und die Meldung auf dem Bildschirm sehen können. Schließlich stellen wir fest, dass wir die Variable e verwenden, um den Socket-Fehler zu erfassen. Auf diese Weise können wir die wirklichen Details dessen abrufen, was passiert ist.

Erinnere dich

Hierbei müssen wir besonders auf die Einrückung des Codes achten. Beachten Sie, dass Python keine Schlüssel verwendet. Auch Semikolons zum Definieren des Schließens von Blöcken hängen ausschließlich von den Leerzeichen oder Tabulatoren ab, die wir verwenden. Wenn wir dies nicht korrekt ausführen, werden Syntaxfehler angezeigt .

Es ist sehr wichtig, dass wir die Dokumentation der Python-Socket-Bibliothek lesen, um mehr und bessere Möglichkeiten zu finden, ihre Ressourcen zu nutzen.

Mit dem Abschluss dieses Tutorials haben wir festgestellt, dass Python über sehr einfache Tools verfügt, die uns den Zugriff auf die Welt der Sockets ermöglichen . Mit diesen Tools können wir Anwendungen programmieren, die die Netzwerke für die Echtzeitverarbeitung verwenden, z Informationen von anderen Computern im Netzwerk oder sogar aus dem Internet.

Sockets mit Python manipulieren