Sockets är gränssnittet som gör att vi kan kommunicera två eller flera datorer via ett nätverk. Tack vare detta kan vi skapa olika typer av applikationer som hjälper oss att överföra data över Internet och därmed se resultat som vi annars inte skulle ha i realtid.
Ett av de vanligaste sätten att implementera uttagen är genom TCP- protokollet, detta hjälper till att med stöd från operativsystemet är överföringen via Internet normal och utan problem.
Manipulera uttagstid
Eftersom vi vet lite om det grundläggande konceptet om vad som är uttag, låt oss börja med att manipulera dess egenskaper, en av dem är väntetiden.
Väntetid
Väntetiden tillåter oss att fastställa hur lång tid uttaget kan vara uppmärksam på att ta emot eller skicka data, detta är mycket viktigt eftersom om det finns en blockering av applikationen medan denna väntetid kan vi drabbas av risken att bromsa en helhet systemet. Det är därför vi behöver veta vad den förutbestämda väntetiden är och även kunna ställa in en för vår bekvämlighet.
För att uppnå detta kan vi använda ett par metoder som finns för det ändamålet i Python- socketbiblioteket .
gettimeout ()
Den första metoden är gettimeout () och som namnet antyder ger det oss den initiala socket-timeout som vi passerar som en parameter.
settimeout ()
Den andra metoden är settimeout () och dess funktionalitet är att ställa in en timeout för det aktuella uttaget uttryckt i millisekunder.
Ställa in tidsgränsen
Vi kommer nu att skapa ett litet program som gör det möjligt för oss att genomföra vad vi har lärt oss, för detta kommer vi först att skapa ett objekt av sockeltypen som kommer att fungera som vårt testämne, för detta kommer vi att vidarebefordra familjen och typen av socket till byggaren och med detta kan vi tillämpa metoderna.
För att se förändringarna när vi har skapat vårt uttag kommer vi att skriva ut dess timeout som måste vara noll eftersom det är ett nytt objekt, sedan med metoden settimeout () sätter vi en ny timeout och slutligen kommer vi att skriva ut informationen, så Vi kommer att bekräfta att allt har fungerat som det ska.
För att uppnå allt detta måste vi se till att Python är installerat i vårt system, i sin version 2.7, och har en textredigerare för att kunna skapa filerna med programmen, även om vi också kan göra övningen i konsolen, men det är lite mer obekvämt och inte ihållande, vilket innebär att vi skulle förlora vårt jobb. Låt oss titta på källkoden för detta exempel:
#! / usr / bin / env python import socket def socket_timeout (): s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) skriva ut "Den första timeouten är:% s"% s.gettimeout () s. settimeout (100) print "Den nya timeout är:% s"% s.gettimeout () om __name__ == '__main__': wait_socket_time ()
Vi sparar detta i en ny fil som heter socketTiempoEspera.py och kör den i konsolen, resultatet ska vara något liknande följande:
Manipulera buffertstorleken på ett uttag
Bufferten är en annan av de saker som vi måste ta hänsyn till när vi arbetar med uttag, eftersom den här komponenten är den som kommer att indikera mängden data som vi kan överföra just nu, ju större mängd buffert desto större datamängd, Detta innebär emellertid också mer resursförbrukning och en längre väntetid för deras överföring. Annars representerar en lägre buffert mer hastighet även om den begränsar mängden data som ska överföras, varför det är en färdighet som vi måste behärska.
setsockopt ()
För att hjälpa oss att manipulera bufferten erbjuder Python-socketbiblioteket metoden setsockopt (), som vi måste tillämpa på en instans av socketklassen. Om vi vill ändra storleken på bufferten måste vi först veta den ursprungliga storleken på sockelbufferten, för detta har vi också metoden getockopt () och den används mycket på samma sätt som metoden som beskrivs ovan.
Ställer in buffertstorlek
Vi kommer att skapa ett litet program för att visa vad vi har förklarat ovan, i den kod som vi ser kommer vi först att skapa ett par konstanter som vi kommer att använda i vårt program och kommer att definieras vid 4096 vad som är ett värde för buffertstorleken Vi kommer att etablera.
Sedan gör vi en instans av sockelklassen för att omedelbart begära de initiala buffertstorlekarna och sedan skriva ut dem på skärmen.
Slutligen kommer vi att använda metoden setsockopt () för att fastställa buffertens storlek med hjälp av de konstanter som definierats i början av programmet, denna metod får tre parametrar, nivån, namnet och slutligen värdet för bufferten.
Låt oss titta på koden som hjälper oss att specificera vad vi har förklarat, låt oss spara den i en fil som heter tamano_buffer.py :
#! / usr / bin / env python import socket TAM_BUFFER_ENVIO = 4096 TAM_BUFFER_RECEPCION = 4096 def manipulate_buffer (): socka = socket.socket (socket.AF_INET, socket.SOCK_STREAM) # Få storleken på sockelns sockbufferstorlekBuf (socket.SOL_SOCKET, socket.SO_SNDBUF) print "Size Buffer [Före]:% d"% size Buffer sock.setsockopt (socket.SOL_TCP, socket.TCP_NODELAY, 1) sock.setsockopt (socket.SOL_SOCKET, socket.SO_SNDBUFF, TAMBAM) sock.setsockopt (socket.SOL_SOCKET, socket.SO_RCVBUF, TAM_BUFFER_RECEPCION) ()
När vi har skrivit vårt program kommer vi att fortsätta att köra det i konsolen och vi ser att vi får värdena på bufferten före och efter ändring av dess storlek.
Felhantering
Liksom för alla typer av program, när vi arbetar med uttag är vi inte undantagna från att stöta på några fel, problemet som vi bör undvika är att dessa fel överraskar oss, eftersom om vi gör det kan vår applikation fungera oförutsägbart.
Det är därför vi måste lära oss att hantera fel, på detta sätt om en oväntad situation uppstår vårt program inte dör men det säger att något har hänt, med detta kommer vi att förhindra datakorruption eller liknande situationer som påverkar stabiliteten i vår program.
Hur hanterar du det?$config[ads_text6] not found
Vi uppnår detta med försök - utom block som gör det möjligt för oss att utvärdera situationer, i allmänhet involverar data utanför vår kontroll och med detta kan vi agera i scenarier enligt de svar vi får. Om vi faller in i undantagsavsnittet i blocket kan vi använda felegenskapen i vår instans och därmed skriva ut vad som har hänt och därmed veta vad felet var.
$config[ads_text5] not foundAtt skapa ett program som hanterar fel
I nästa program testar vi vad vi har definierat under förklaringen. Först kommer vi att skapa ett block som styr oss om skapandet av uttaget har haft ett fel eller inte, med detta kan vi säkerställa en god start på vår kod.
Då utvärderar vi anslutningen till vår applikation till en fjärrvärd genom en viss port och med felhantering kan vi definiera ett personligt meddelande. Slutligen ringer vi till vår funktion och med den kommer vi att utföra de beskrivna åtgärderna.
Låt oss se följande kod som vi måste lagra i en fil som heter fel_socket.py och sedan kör vi den i konsolen:
#! / usr / bin / env python import sys import socket host = 'http: //python.orgt' port = '06' def error_handling (): prova: s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) utom socket.error, e: print "Det uppstod ett fel vid skapandet av socket:% s"% e sys.exit (1) försök: s.connect ((värd, port)) utom socket.gaierror, e: print "Fel vid anslutningsadressen:% s "% e sys.exit (1) förutom socket.error, e: print" Anslutningsfel:% s "% e sys.exit (1) om __name__ == '__main__': error_handling ()
Här ser vi att vi har använt sys- biblioteket för att kunna använda metoden exit () och stänga programmet efter att ett fel inträffat. Vi märkte också att värden är felaktig, så att vi kan tvinga felet och se meddelandet på skärmen. Slutligen noterar vi att vi använder variabeln e för att fånga uttagsfelet, med detta kan vi få den verkliga detaljerna om vad som hände.
minns
Här måste vi vara särskilt försiktiga med indragningen av koden, kom ihåg att Python inte använder nycklar, även semikolon för att definiera stängning av block beror uteslutande på de utrymmen eller flikarna som vi använder, så om vi inte gör det korrekt ser vi syntaxfel .
Det är mycket viktigt att vi läser dokumentationen för Python-socketbiblioteket för att hitta fler och bättre sätt att dra nytta av dess resurser.
Med detta avslutar vi denna tutorial, vi har insett hur Python har väldigt enkla verktyg att förstå som ger oss tillgång till sockelvärlden, med detta kan vi börja programmera applikationer som använder nätverk för att göra realtidsbearbetning, till exempel att få information från andra maskiner i nätverket eller till och med från Internet.
Artikel