Innholdsfortegnelse
De stikkontakter De er grensesnittet som lar oss kommunisere to eller flere datamaskiner gjennom et nettverk. Takket være dette kan vi lage forskjellige typer applikasjoner som hjelper oss å overføre data over Internett og dermed se resultater som vi ellers ikke ville ha i sanntid.En av de vanligste måtene å implementere stikkontakter er gjennom protokollen TCPDette hjelper at med støtte fra operativsystemet er overføringen via Internett normal og uten problemer.
Siden vi vet litt om det grunnleggende konseptet om hva stikkontakter er, skal vi begynne med å manipulere deres egenskaper, en av dem er ventetiden.
VentetidDe ventetid Det lar oss fastslå hvor lang tid kontakten kan være oppmerksom på å motta eller sende data, dette er veldig viktig siden hvis det er en blokkering av applikasjonen mens denne tiden venter, kan vi risikere å bremse et helt system . Det er derfor vi trenger å kunne vite hva den forhåndsbestemte ventetiden er, og også å kunne etablere en selv for vår bekvemmelighet.
For å oppnå dette kan vi bruke et par metoder som finnes for dette formålet i standardbiblioteket stikkontakt av Python.
gettimeout ()Den første metoden er gettimeout () og som navnet indikerer, tilbyr den oss den første ventetiden til kontakten som vi sender som parameter.
settimeout ()Den andre metoden er settimeout () og funksjonaliteten er å etablere en timeout for den aktuelle kontakten uttrykt i millisekunder.
Vi skal nå lage et lite program som lar oss sette i verk det vi har lært, for dette skal vi først lage et objekt av stikkontaktstype som vil tjene som vårt testperson, for dette vil vi passere familien og stikkontakten til konstruktøren, og med det kan vi bruke metodene.
For å se endringene når vi har opprettet kontakten, vil vi skrive ut ventetiden som må være null fordi det er et nytt objekt, deretter med metoden settimeout () Vi etablerer en ny ventetid, og til slutt skriver vi ut informasjonen og bekrefter dermed at alt har fungert som det skal.
For å oppnå alt dette må vi sørge for at vi har det Python installert i vårt system, i sin versjon 2.7, og ha en tekstredigerer for å kunne lage filene med programmene, selv om vi også kan gjøre øvelsen på konsollen, men det er litt mer ubehagelig og det er ikke vedvarende, noe som betyr at vi ville miste arbeidet vårt. La oss se på kildekoden for dette eksemplet:
#! / 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. settimeout (100 ) print "Den nye tidsavbruddet er:% s"% s.gettimeout () if __name__ == '__main__': time_out_socket ()
Vi kommer til å lagre dette i en ny fil som heter socketTimeWait.py og vi vil utføre det i konsoll, skal resultatet være noe som ligner på følgende:
setsockopt ()For å hjelpe oss med å manipulere bufferen, biblioteket stikkontakt av Python tilbyr oss metoden setsockopt(), som vi må bruke på en forekomst av socket -klassen. Hvis vi vil endre størrelsen på bufferen, må vi sikkert først kjenne den opprinnelige størrelsen på socketbufferen, for dette har vi også metoden getockopt () og den brukes omtrent på samme måte som metoden vi beskrev ovenfor.
Vi skal lage et lite program for å demonstrere det vi har forklart tidligere, i koden som vi vil se vi først går til lage et par konstanter som vi vil bruke i vårt program og vil bli definert til 4096 som er en verdi for størrelsen på bufferne som vi vil etablere.
Deretter lager vi en forekomst av socket -klassen, for umiddelbart å be om de opprinnelige størrelsene på bufferen, så skriver vi dem ut på skjermen.
Til slutt vil vi bruke metoden setsockopt () For å angi ønsket størrelse på bufferen ved hjelp av konstantene definert i begynnelsen av programmet, mottar denne metoden tre parametere, nivået, navnet og til slutt verdien for bufferen.
La oss se koden som hjelper oss å spesifisere det vi har forklart, vi skal lagre 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) # Få størrelsen på sokkelens sendebufferstørrelse.gufferopt = s (socket.SOL_SOCKET, socket.SO_SNDBUF) print "Buffer Size [Before]:% d"% Buffer size 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) print "Buffer size [After]:% d"% manipulate_buffer_size =_ __bize__ize__ize__ize = '__ ()
Når vi har skrevet programmet vårt, fortsetter vi med å utføre det i konsollen, og vi vil se at vi får tak i bufferens verdier før og etter endring av størrelsen.
Det er derfor vi må lære å håndtere feil, på denne måten hvis en uventet situasjon oppstår, dør ikke vårt program, men varsler oss om at noe har skjedd, med dette vil vi unngå datakorrupsjon eller lignende situasjoner som påvirker stabiliteten i vårt program.
Hvordan håndtere det?Vi oppnår dette ved hjelp av blokker prøv - unntatt som lar oss evaluere situasjoner, generelt som involverer data utenfor vår kontroll, og med dette kan vi handle i scenarier i henhold til svarene vi får. Hvis vi faller inn i seksjonen unntatt av blokken kan vi bruke feilegenskapen til forekomsten vår og med den skrive ut hva som har skjedd og dermed vite hva feilen var.
I det følgende programmet skal vi teste det vi har definert under forklaringen. Først og fremst skal vi opprette en blokk som styrer oss om stikkontakten har hatt en feil eller ikke, med dette kan vi sikre en god start på koden.
Deretter skal vi evaluere tilkoblingen av applikasjonen vår til en ekstern vert gjennom en bestemt port, og med feilhåndtering kan vi definere en tilpasset melding. Til slutt ringer vi til vår funksjon, og med den vil vi utføre de beskrevne handlingene.
La oss se følgende kode som vi må lagre i en fil som heter errors_socket.py og så kjører vi det i konsollen:
#! / usr / bin / env python import sys import socket host = 'http: //python.orgt' port = '06' def error_handling (): prøv: s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) unntatt socket.error, e: print "Det oppstod en feil under opprettelsen av kontakten:% s"% e sys.exit (1) prøv: s.connect ((host, port)) unntatt socket.gaierror, e: print "Feil i tilkoblingsadresse:% s "% e sys.exit (1) unntatt socket.error, e: print" Tilkoblingsfeil:% s "% e sys.exit (1) hvis __name__ == '__main__': error_handling ()
Her ser vi at vi har brukt biblioteket sys for å bruke metoden exit () og lukk programmet etter at det oppstår en feil. Vi merker også at verten er feil dette er slik at vi kan tvinge feilen og dermed se meldingen på skjermen. Til slutt merker vi at vi bruker variabelen e for å fange socket -feilen, med dette kan vi få den virkelige detaljene om hva som skjedde.
HuskeHer må vi være spesielt forsiktige med innrykk av koden husk det Python Ved ikke å bruke seler, er semikolon også for å definere blokkeringer utelukkende avhengig av mellomrommene eller fanene vi bruker, så hvis vi ikke gjør det riktig, vil vi se syntaksfeil.
Det er veldig viktig at vi leser dokumentasjonen til Python socket -bibliotek slik at du kan finne flere og bedre måter å dra nytte av ressursene dine.
Med dette fullfører vi denne opplæringen, vi har innsett hvordan Python har veldig lettfattelige verktøy som gir oss tilgang til verden av stikkontakterMed dette kan vi begynne å programmere applikasjoner som bruker nettverk til å utføre sanntidsbehandling, for eksempel å hente informasjon fra andre maskiner på nettverket eller til og med fra Internett.Likte og hjalp du denne opplæringen?Du kan belønne forfatteren ved å trykke på denne knappen for å gi ham et positivt poeng
