Socket-Manipulation mit Python

Das Steckdosen Sie sind die Schnittstelle, die es uns ermöglicht, zwei oder mehr Computer über ein Netzwerk zu kommunizieren. Dadurch können wir verschiedene Arten von Anwendungen erstellen, die uns helfen, Daten über das Internet zu übertragen und so Ergebnisse zu sehen, die wir sonst in Echtzeit nicht hätten.
Eine der gebräuchlichsten Möglichkeiten, Sockets zu implementieren, ist das Protokoll TCPDies trägt dazu bei, dass mit Unterstützung des Betriebssystems die Übertragung über das Internet normal und problemlos abläuft.
Da wir ein wenig über das Grundkonzept von Sockets wissen, werden wir zunächst ihre Eigenschaften manipulieren, eine davon ist die Wartezeit.
WartezeitDas Wartezeit Es ermöglicht uns, die Zeitdauer festzulegen, die der Socket auf das Empfangen oder Senden von Daten aufmerksam sein kann. Dies ist sehr wichtig, da wir bei einer Blockierung der Anwendung während dieser Wartezeit das Risiko eingehen können, ein ganzes System zu verlangsamen . Aus diesem Grund müssen wir die vorgegebene Wartezeit kennen und auch selbst festlegen können.
Um dies zu erreichen, können wir einige Methoden verwenden, die für diesen Zweck in der Standardbibliothek vorhanden sind Steckdose von Python.
gettimeout ()Die erste Methode ist gettimeout () und wie der Name schon sagt, bietet es uns die anfängliche Wartezeit des Sockets an, die wir als Parameter übergeben.
settimeout ()Die zweite Methode ist settimeout () und seine Funktionalität besteht darin, eine Zeitüberschreitung für den fraglichen Socket festzulegen, die in Millisekunden ausgedrückt wird.
Wir werden jetzt ein kleines Programm erstellen, das es uns ermöglicht, das Gelernte in die Tat umzusetzen, dazu erstellen wir zunächst ein Objekt vom Typ socket, das als unser Testsubjekt dient, dafür ü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, geben wir seine Wartezeit aus, die null sein muss, da es sich um ein neues Objekt handelt, dann mit der Methode settimeout () Wir werden eine neue Wartezeit festlegen und schließlich die Informationen ausdrucken, um zu bestätigen, dass alles so funktioniert hat, wie es sollte.
Um all dies zu erreichen, müssen wir sicherstellen, dass wir Python in unserem System installiert, in seiner Version 2.7, und haben einen Texteditor, um die Dateien mit den Programmen erstellen zu können, obwohl wir die Übung auch auf der Konsole machen können, aber es ist etwas unangenehmer und nicht hartnäckig, was bedeutet, dass wir unsere Arbeit verlieren würden. Schauen wir uns den Quellcode für dieses Beispiel an:

 #! / usr / bin / env python import socket def timeout_socket (): s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) print "Anfangs-Timeout ist:% s"% s.gettimeout () s. settimeout (100 ) print "Das neue Timeout ist:% s"% s.gettimeout () if __name__ == '__main__': time_out_socket () 

Wir werden dies in einer neuen Datei namens . speichern socketTimeWait.py und wir werden es in der Konsole ausführen, das Ergebnis sollte ungefähr wie folgt aussehen:

Das Puffer Dies ist ein weiterer Aspekt, den wir bei der Arbeit mit Sockets berücksichtigen müssen, da diese Komponente die Menge an Daten anzeigt, die wir derzeit übertragen können, um mehr Puffer Je größer die Datenmenge ist, bedeutet jedoch auch einen höheren Ressourcenverbrauch und eine längere Wartezeit bei der Übertragung derselben. Ansonsten a unterer Puffer Es steht für mehr Geschwindigkeit, obwohl es die zu übertragende Datenmenge begrenzt, deshalb ist es eine Fähigkeit, die wir beherrschen müssen.
Setsockopt ()Um uns zu helfen, den Puffer der Bibliothek zu manipulieren Steckdose von Python bietet uns die Methode Setsockopt(), die wir auf eine Instanz der Socket-Klasse anwenden müssen. Wenn wir die Größe des Puffers ändern wollen, müssen wir natürlich zuerst die ursprüngliche Größe des Socket-Puffers kennen, dafür haben wir auch die Methode getockopt () und es wird auf die gleiche Weise wie die oben beschriebene Methode verwendet.
Wir werden ein kleines Programm erstellen, um zu demonstrieren, was wir zuvor erklärt haben, in dem Code, den wir zuerst sehen werden Erstellen Sie ein Paar von Konstanten die wir in unserem Programm verwenden und definiert werden zu 4096 Dies ist ein Wert für die Größe der Puffer, die wir einrichten werden.
Dann erstellen wir eine Instanz der Socket-Klasse, um sofort nach den Anfangsgrößen des Puffers zu fragen, und geben sie dann auf dem Bildschirm aus.
Schließlich verwenden wir die Methode Setsockopt () Um die gewünschte Größe des Puffers über die zu Beginn des Programms definierten Konstanten einzustellen, erhält diese Methode 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 werden es in einer Datei namens . speichern size_buffer.py:

 #! / usr / bin / env python import socket TAM_BUFFER_SEND = 4096 TAM_BUFFER_RECEPCION = 4096 def Manipulation_buffer (): sock = socket.socket (socket.AF_INET, socket.SOCK_STREAM) # Hole die Größe des Sendepuffers des Sockets sizeBuock.getso = (socket.SOL_SOCKET, socket.SO_SNDBUF) print "Puffergröße [Before]:% d"% Puffergröße sock.setsockopt (socket.SOL_TCP, socket.TCP_NODELAY, 1) sock.setsockopt (socket.SOL_SOCKET, socket.SO_SNock.UFFER_ setsockopt (socket.SOL_SOCKET, socket.SO_RCVBUF, SIZE_BUFFER_RECEPCION) buffersize = sock.getsockopt (socket.SOL_SOCKET, socket.SO_SNDBUF) print "Puffergröße [Nach]:% d"% Manipulation_buffer_size = '__buffer_size = '__buffer_Größe =' __ () 

Sobald wir unser Programm geschrieben haben, führen wir es in der Konsole aus und sehen, dass wir die Werte des Puffers vor und nach der Änderung seiner Größe erhalten.

Wie bei allen Arten von Programmen sind wir bei der Arbeit mit Sockets nicht davon ausgenommen, dass einige Fehler auftreten. Das Problem, das wir vermeiden müssen, ist, dass diese Fehler uns überraschen, da unsere Anwendung sonst unvorhersehbar funktionieren kann.
Aus diesem Grund müssen wir lernen, mit Fehlern umzugehen. Auf diese Weise stirbt unser Programm nicht ab, sondern benachrichtigt uns, wenn eine unerwartete Situation eintritt, sondern benachrichtigt uns, dass etwas passiert ist, damit wir Datenbeschädigungen oder ähnliche Situationen vermeiden, die die Stabilität unseres Programms beeinträchtigen.
Wie geht man damit um?Das erreichen wir mit Blöcken versuchen - außer die es uns ermöglichen, Situationen zu bewerten, die im Allgemeinen Daten beinhalten, die außerhalb unserer Kontrolle liegen, und so können wir in Szenarien entsprechend den erhaltenen Antworten agieren. Wenn wir in den Abschnitt fallen außer des Blocks können wir die error-Eigenschaft unserer Instanz verwenden und damit ausgeben, was passiert ist und so wissen, was der Fehler war.
Im folgenden Programm werden wir testen, was wir während der Erklärung definiert haben. Zuerst erstellen wir einen Block, der uns kontrolliert, ob die Socket-Erstellung einen Fehler hatte oder nicht, damit können wir einen guten Start unseres Codes sicherstellen.
Dann werden wir die Verbindung unserer Anwendung zu einem Remote-Host über einen bestimmten Port auswerten und mit der Fehlerbehandlung eine benutzerdefinierte 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 namens . speichern müssen error_socket.py und dann führen wir es in der Konsole aus:

 #! /usr/bin/env python import sys import socket host = 'http: //python.orgt' port = '06' def error_handling (): try: 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) try: s.connect ((host, port)) außer socket.gaierror, e: print "Error in 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 Bibliothek genutzt haben sys um die Methode anzuwenden Ausfahrt () und schließen Sie das Programm nach einem Fehler. Wir stellen auch fest, dass der Host falsch ist, damit wir den Fehler erzwingen und somit 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, damit wir die wirklichen Details dessen erhalten, was passiert ist.
MerkenHier müssen wir besonders aufpassen mit den Vertiefung des Codes erinnere dich daran Python Indem wir keine geschweiften Klammern verwenden, hängen Semikolons auch zum Definieren von Blockschließungen ausschließlich von den von uns verwendeten Leerzeichen oder Tabulatoren ab. Wenn wir es also nicht richtig machen, sehen wir Syntaxfehler.
Es ist sehr wichtig, dass wir die Dokumentation der Python-Socket-Bibliothek damit Sie mehr und bessere Möglichkeiten finden, Ihre Ressourcen zu nutzen.
Damit beenden wir dieses Tutorial, wir haben erkannt wie Python verfügt über sehr leicht verständliche Tools, die uns Zugang zur Welt der SteckdosenDamit können wir damit beginnen, Anwendungen zu programmieren, die Netzwerke verwenden, um eine Echtzeitverarbeitung durchzuführen, wie zum Beispiel das Abrufen von Informationen von anderen Computern im Netzwerk oder sogar aus dem Internet.Hat dir dieses Tutorial gefallen und geholfen?Sie können den Autor belohnen, indem Sie diesen Knopf drücken, um ihm einen positiven Punkt zu geben