Innehållsförteckning
De uttag De ä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 uttag är genom protokollet TCPDetta hjälper att med stöd av operativsystemet är överföringen via Internet normal och utan problem.
Eftersom vi vet lite om grundkonceptet för vad socklar är, ska vi börja med att manipulera deras egenskaper, en av dem är väntetiden.
VäntetidDe väntetid Det gör att vi kan fastställa hur lång tid som uttaget kan vara uppmärksamt på att ta emot eller skicka data, detta är mycket viktigt eftersom om det finns en blockering av applikationen medan den här tiden väntar kan vi riskera att bromsa ett helt system . Det är därför vi är i behov av att kunna veta vad den förutbestämda väntetiden är och också att kunna etablera en själv för vår bekvämlighet.
För att uppnå detta kan vi använda ett par metoder som finns för detta ändamål inom standardbiblioteket uttag av Pytonorm.
gettimeout ()Den första metoden är gettimeout () och som namnet indikerar, erbjuder den oss den ursprungliga väntetiden för uttaget som vi skickar som parameter.
settimeout ()Den andra metoden är settimeout () och dess funktion är att fastställa en timeout för det aktuella uttaget uttryckt i millisekunder.
Vi ska nu skapa ett litet program som gör att vi kan omsätta det vi har lärt oss, för detta kommer vi först att skapa ett objekt av uttaget som kommer att fungera som vårt testämne, för detta kommer vi att passera familjen och sockeltypen till konstruktören och med det kan vi tillämpa metoderna.
För att se ändringarna när vi har skapat vårt uttag kommer vi att skriva ut dess väntetid som måste vara noll eftersom det är ett nytt objekt, sedan med metoden settimeout () Vi kommer att upprätta en ny väntetid och slutligen kommer vi att skriva ut informationen och därmed bekräfta att allt har fungerat som det ska.
För att uppnå allt detta måste vi se till att vi har det Pytonorm installerat i vårt system, i dess version 2.7, och ha en textredigerare för att kunna skapa filerna med programmen, även om vi också kan göra övningen på konsolen, men det är lite mer obekvämt och det är inte ihållande, vilket innebär att vi skulle förlora vårt arbete. Låt oss titta på källkoden för detta exempel:
#! / usr / bin / env python import socket def timeout_socket (): s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) print "Initial timeout is:% s"% s.gettimeout () s. setimeout (100 ) print "Den nya timeout är:% s"% s.gettimeout () om __name__ == '__main__': time_out_socket ()
Vi kommer att spara detta i en ny fil som heter socketTimeWait.py och vi kommer att köra det i konsolen, resultatet ska vara något liknande följande:
setsockopt ()För att hjälpa oss att manipulera bufferten biblioteket uttag av Pytonorm erbjuder oss 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å socketbufferten, för detta har vi också metoden getsockopt () och det används på ungefär samma sätt som metoden vi beskrev ovan.
Vi kommer att skapa ett litet program för att demonstrera vad vi har förklarat tidigare, i koden som vi kommer att se kommer vi först att gå till skapa ett par konstanter som vi kommer att använda i vårt program och kommer att definieras till 4096 vilket är ett värde för storleken på buffertarna som vi kommer att upprätta.
Sedan gör vi en instans av socketklassen, för att omedelbart be om buffertens initialstorlekar, sedan skriver vi ut dem på skärmen.
Slutligen kommer vi att använda metoden setsockopt () För att ställa in önskad storlek på bufferten med hjälp av de konstanter som definierades i början av programmet, tar denna metod emot tre parametrar, nivån, namnet och slutligen värdet för bufferten.
Låt oss se koden som hjälper oss att specificera vad vi har förklarat, vi kommer att spara den i en fil som heter size_buffer.py:
#! / usr / bin / env python import socket TAM_BUFFER_SEND = 4096 TAM_BUFFER_RECEPCION = 4096 def manipulate_buffer (): sock = socket.socket (socket.AF_INET, socket.SOCK_STREAM) # Skaffa storleken på uttaget sänd buffert storlekBufferopt = sock (socket.SOL_SOCKET, socket.SO_SNDBUF) skriv ut "buffertstorlek [före]:% d"% buffertstorlek sock.setsockopt (socket.SOL_TCP, socket.TCP_NODELAY, 1) sock.setsockopt (socket.SOL_SOCKET, socket.SO_SNDBUFFER_ sock. setsockopt (socket.SOL_SOCKET, socket.SO_RCVBUF, SIZE_BUFFER_RECEPCION) buffersize = sock.getsockopt (socket.SOL_SOCKET, socket.SO_SNDBUF) skriv ut "Buffertstorlek [Efter]:% d"% manipulate_buffer_size =_ __bize__ize__ize__biz_size__ize__biz_size__ize__ize = '__ ()
När vi har skrivit vårt program fortsätter vi att köra det i konsolen och vi kommer att se att vi får värdena för bufferten före och efter att ha ändrat dess storlek.
Det är därför vi måste lära oss att hantera fel, på detta sätt om en oväntad situation inträffar dör vårt program inte men meddelar oss att något har hänt, med detta kommer vi att undvika datakorruption eller liknande situationer som påverkar stabiliteten i vårt program.
Hur hanteras det?Vi uppnår detta med hjälp av block försök - utom som gör att vi kan utvärdera situationer, generellt som 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 avsnittet bortsett från i blocket kan vi använda felegenskapen för vår instans och med den skriva ut vad som har hänt och därmed veta vad felet var.
I följande program ska vi testa vad vi har definierat under förklaringen. Först och främst ska vi skapa ett block som styr oss om skapandet av sockeln har haft ett fel eller inte, med detta kan vi säkerställa en bra start av vår kod.
Sedan kommer vi att utvärdera anslutningen av vår applikation till en fjärrvärd via en viss port och med felhantering kan vi definiera ett anpassat meddelande. Slutligen uppmanar 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 errors_socket.py och sedan kör vi det i konsolen:
#! / 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) utom socket.error, e: print "Det uppstod ett fel när socket skapades:% s"% e sys.exit (1) försök: s.connect ((host, port)) förutom socket.gaierror, e: print "Fel i anslutningsadress:% s "% e sys.exit (1) utom socket.error, e: print" Anslutningsfel:% s "% e sys.exit (1) om __name__ == '__main__': error_handling ()
Här ser vi att vi har använt biblioteket sys för att använda metoden utgång () och stäng programmet efter att ett fel uppstår. Vi noterar också att värden är felaktig detta är så att vi kan tvinga fram felet och därmed se meddelandet på skärmen. Slutligen noterar vi att vi använder variabeln e för att fånga sockelfelet, med detta kan vi få den verkliga detaljen av vad som hände.
Kom ihågHär måste vi vara särskilt försiktiga med indrag av koden kom ihåg det Pytonorm Genom att inte använda hängslen beror semikolon också för att definiera blockstängningar enbart på de mellanslag eller flikar som vi använder, så om vi inte gör det korrekt ser vi syntaxfel.
Det är mycket viktigt att vi läser dokumentationen till Python socket -bibliotek så att du kan hitta fler och bättre sätt att dra nytta av dina resurser.
Med detta avslutar vi denna handledning, vi har insett hur Pytonorm har mycket lättöverskådliga verktyg som ger oss tillgång till världen av uttagMed detta kan vi börja programmera applikationer som använder nätverk för att utföra bearbetning i realtid, till exempel att hämta information från andra maskiner i nätverket eller till och med från Internet.Gillade du och hjälpte denna handledning?Du kan belöna författaren genom att trycka på den här knappen för att ge honom en positiv poäng
