Ano ang Socket Programming sa Python at kung paano ito makabisado?

Ang Internet ay hindi maikakaila na naging 'Soul of Existence' at ang aktibidad nito ay nailalarawan sa pamamagitan ng 'Mga Koneksyon' o 'Mga Network'. Ang mga network na ito ay ginawang posible gamit ang isa sa pinakamahalagang batayan ng Sockets. Saklaw ng artikulong ito ang lahat ng mga lugar na nakikipag-usap sa Socket Programming sa Python. Tinutulungan ka ng mga socket na gawin ang mga koneksyon na ito, habang , walang alinlangan, ginagawang madali.

Tingnan natin nang mabilis ang lahat ng mga paksang sakop sa artikulong ito:

Bakit gumagamit ng Sockets?
Ano ang mga Sockets sa Python?
Paano makamit ang Socket Programming sa Python
Ano ang isang server?
Ano ang kliyente?
Echo Client-Server
Maramihang Mga Komunikasyon
Paglilipat ng Mga Bagay sa Python

• Module ng pag-atsara ng sawa
• Paano maglipat ng mga python na bagay gamit ang module ng atsara

Bakit gumagamit ng Sockets?

Ang mga socket ay ang gulugod ng networking. Ginagawa nilang posible ang paglipat ng impormasyon sa pagitan ng dalawang magkakaibang mga programa o aparato. Halimbawa, kapag binuksan mo ang iyong browser, ikaw bilang isang kliyente ay lumilikha ng isang koneksyon sa server para sa paglipat ng impormasyon.

Bago sumisid nang mas malalim sa komunikasyon na ito, alamin muna natin kung ano talaga ang mga socket na ito.

Ano ang mga Sockets?

Sa mga pangkalahatang tuntunin, ang mga socket ay panloob na mga endpoint na itinayo para sa pagpapadala at pagtanggap ng data. Ang isang solong network ay magkakaroon ng dalawang sockets, isa para sa bawat aparato o programa na nakikipag-usap. Ang mga socket na ito ay isang kumbinasyon ng isang IP address at isang Port. Ang isang solong aparato ay maaaring magkaroon ng ‘n’ bilang ng mga socket batay sa bilang ng port na ginagamit. Magagamit ang iba't ibang mga port para sa iba't ibang mga uri ng mga protokol. Tingnan ang sumusunod na imahe para sa higit pa tungkol sa ilan sa mga karaniwang numero ng port at mga kaugnay na protokol:

Ngayon na malinaw ka tungkol sa konsepto ng mga socket, tingnan natin ngayon ang module ng Socket ng Python:

Paano makamit ang Socket Programming sa Python:

Upang makamit ang Socket Programming sa Python, kakailanganin mong i-import ang socket modyul o . Ang modyul na ito ay binubuo ng mga built-in na pamamaraan na kinakailangan para sa paglikha ng mga socket at tulungan silang maiugnay sa bawat isa.

Ang ilan sa mga mahahalagang pamamaraan ay ang mga sumusunod:

Ngayon na naintindihan mo ang kahalagahan ng socket module, magpatuloy tayo upang makita kung paano ito maghatid upang lumikha ng mga server at kliyente para sa Socket Programming sa .

Ano ang isang Server?

Ang isang server ay alinman sa isang programa, isang computer, o isang aparato na nakatuon sa pamamahala ng mga mapagkukunan ng network. Ang mga server ay maaaring nasa parehong aparato o computer o lokal na konektado sa iba pang mga aparato at computer o kahit na remote. Mayroong iba't ibang mga uri ng mga server tulad ng mga database server, network server, print server, atbp.

Ang mga server ay karaniwang gumagamit ng mga pamamaraan tulad ng socket.socket (), socket.bind (), socket.listen (), atbp upang maitaguyod ang isang koneksyon at magbigkis sa mga kliyente. Sumulat tayo ngayon ng isang programa upang lumikha ng isang server. Isaalang-alang ang sumusunod na halimbawa:

HALIMBAWA:

import socket s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) s.bind ((socket.gethostname (), 1234)) Ang numero ng #port ay maaaring maging anuman sa pagitan ng 0-65535 (karaniwang tinukoy namin ang mga hindi pa ginawang port na > 1023) s.listen (5) habang True: clt, adr = s.accept () print (f'Connection to {adr} itinatag ') #f string ay literal na string na paunang binubuo ng f na naglalaman ng mga expression ng sawa sa loob ng braces clt .send (bytes ('Socket Programming in Python', 'utf-8')) #pagpadala ng impormasyon sa clientsocket

Tulad ng nakikita mo, ang unang pangangailangan upang lumikha ng isang socket ay ang pag-import ng socket module. Pagkatapos nito ay ginagamit ang paraan ng socket.socket () upang lumikha ng isang server-side socket.

TANDAAN:

Ang AF_INET ay tumutukoy sa Address mula sa Internet at nangangailangan ito ng isang pares ng (host, port) kung saan ang host ay maaaring isang URL ng ilang partikular na website o ang address nito at ang numero ng port ay isang integer. Ginagamit ang SOCK_STREAM upang lumikha ng Mga Protokol ng TCP.

Ang paraan ng bind () ay tumatanggap ng dalawang mga parameter bilang isang tuple (host, port). Gayunpaman, mas mahusay na gumamit ng mga 4 na digit na numero ng port dahil ang mga mas mababa ay karaniwang sinasakop. Pinapayagan ng pamamaraang makinig () ang server na tumanggap ng mga koneksyon. Dito, 5 ang pila para sa maraming koneksyon na sabay na nagmumula. Ang minimum na halagang maaaring matukoy dito ay 0 (Kung magbibigay ka ng isang mas mababang halaga, binago ito sa 0). Kung sakaling walang natukoy na parameter, tumatagal ito ng isang naaangkop na default.

Nag-uuri ang c ++

Ang Pinapayagan ang pagtanggap ng mga koneksyon magpakailanman. Ang 'clt' at 'adr' ang object at address ng client. Ang print statement ay naka-print lamang sa address at sa port number ng client socket. Sa wakas, ginagamit ang clt.send upang maipadala ang data sa mga byte.

Ngayong handa na ang aming server, magpatuloy tayo patungo sa kliyente.

Ano ang isang Client?

Ang isang kliyente ay alinman sa isang computer o software na tumatanggap ng impormasyon o mga serbisyo mula sa server. Sa isang module ng client-server, humihiling ang mga kliyente para sa mga serbisyo mula sa mga server. Ang pinakamahusay na halimbawa ay isang web browser tulad ng Google Chrome, Firefox, atbp. Ang mga web browser na ito ay humihiling ng mga web server para sa kinakailangang mga web page at serbisyo tulad ng itinuro ng gumagamit. Ang iba pang mga halimbawa ay kasama ang mga online game, online chat, atbp.

Tingnan natin ngayon kung paano i-code ang program na panig ng kliyente :

HALIMBAWA:

import socket s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) s.connect ((socket.gethostname (), 2346)) msg ​​= s.recv (1024) print (msg.decode ('utf-8') )

Ang unang hakbang ay i-import ang socket module at pagkatapos ay lumikha ng isang socket tulad ng ginawa mo habang lumilikha ng isang server. Pagkatapos, upang lumikha ng isang koneksyon sa pagitan ng client-server kakailanganin mong gamitin ang paraan ng pagkonekta () sa pamamagitan ng pagtukoy (host, port).

TANDAAN: Ginagamit ang gethostname kapag nasa parehong computer ang client at server. (LAN - localip / WAN - publicip)

Dito, nais ng kliyente na makatanggap ng ilang impormasyon mula sa server at para dito, kailangan mong gamitin ang recv () na pamamaraan at ang impormasyon ay nakaimbak sa isa pang variable na msg. Tandaan lamang na ang ipinapasa na impormasyon ay magiging sa mga byte at sa kliyente sa program sa itaas ay maaaring makatanggap ng hanggang 1024 bytes (laki ng buffer) sa isang solong paglilipat. Maaari itong tukuyin sa anumang halaga depende sa dami ng impormasyong inililipat.

Panghuli, ang mensahe na inililipat ay dapat na naka-decode at naka-print.

Ngayong alam mo na kung paano lumikha ng mga programa ng client-server, magpatuloy tayo upang makita kung paano nila kailangang maisagawa.

Echo Client-Server:

Upang maipatupad ang mga programang ito, buksan ang iyong prompt ng utos, pumunta sa folder kung saan mo nilikha ang iyong client at server program at pagkatapos ay i-type

py server.py (dito, ang server.py ay ang filename ng server, maaari mo ring gamitin ang py -3.7 server.py)

Kapag tapos na ito, nagsisimulang tumakbo ang server. Upang maipatupad ang kliyente, buksan ang isa pang cmd window, at i-type:

py client.py (narito, ang client.py ay ang filename ng client)

OUTPUT (SERVER):

(CLIENT)

Subukan natin ang parehong programa sa pamamagitan ng pagbawas sa laki ng buffer sa 7 at tingnan kung anong makukuha nating output:

OUTPUT:

halimbawa ng isang klase java

Tulad ng nakikita mo, ang koneksyon ay natapos pagkatapos maglipat ng 7 bytes. Ngunit ito ay isang isyu dahil hindi mo natanggap ang kumpletong impormasyon at ang koneksyon ay sarado. Magpatuloy tayo upang malutas ang isyung ito.

Maramihang Mga Komunikasyon:

Upang magpatuloy ang koneksyon hanggang sa matanggap ng kliyente ang kumpletong impormasyon, maaari mong magamit ang loop habang:

HALIMBAWA:

import socket s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) s.connect ((socket.gethostname (), 2346)) habang True: msg = s.recv (7) print (msg.decode ('utf- 8 '))

Kapag ginawa mo ito, ang kumpletong mensahe ay matatanggap sa 7 bytes bawat paglipat.

Ngunit sa oras na ito, tulad ng nakikita mo, ang koneksyon ay hindi winakasan at hindi mo alam kung kailan ito mangyayari. At upang maidagdag dito, paano kung hindi mo talaga alam kung gaano kalaki ang mensahe o impormasyon na matatanggap ng kliyente mula sa server. Sa mga ganitong kaso, maaari mong gamitin ang sumusunod na piraso ng code sa panig ng kliyente:

HALIMBAWA:

complete_info = 'habang Totoo: msg = s.recv (7) kung len (msg)<=0: break complete_info += msg.decode('utf-8') print(complete_info) 

Sa panig ng server gamitin ang malapit () na pamamaraan tulad ng sumusunod:

clt.close ()

Ang output nito ay ipapakita sa imahe sa ibaba:

OUTPUT:



Ang lahat ng ginagawa sa itaas na bloke ng code ay, suriin ang laki ng impormasyon at i-print ito sa isang buffer ng dalawang byte nang paisa-isa kasama ang pagsara ng koneksyon matapos itong makumpleto.

Paglilipat ng Mga Bagay sa Python:

Hanggang dito mo lang nakuha ang talento ng paglilipat ng mga string. Ngunit, Socket Programming sa Sawa Pinapayagan ka ring ilipat ang mga bagay ng Python din. Ang mga bagay na ito ay maaaring maging anumang kagaya ng mga set, tuple, dictionaries, atbp. Upang makamit ito, kakailanganin mong i-import ang pickle module ng Python.

Modul ng pickle ng Python:

Ang module ng pickle ng Python ay nagmula sa larawan kapag talagang nagsaseryal o nag-de-serialize ng mga bagay sa sawa. Tingnan natin ang isang maliit na halimbawa,

HALIMBAWA:

i-import ang pickle mylist = [1,2, 'abc'] mymsg = pickle.dumps (mylist) print (mymsg)

OUTPUT: b’x80x03] qx00 (Kx01Kx02Xx03x00x00x00abcqx01e. ’

Tulad ng nakikita mo, sa program sa itaas, ang 'mylist' ay naka-serialize gamit ang pag-andar ng dumps () ng module ng pickle. Gumawa din ng tala na ang output ay nagsisimula sa isang 'b', nangangahulugang na-convert ito sa mga byte. Sa socket programming, maaari mong ipatupad ang module na ito upang ilipat mga bagay sa sawa sa pagitan ng mga kliyente at server.

Paano magagamit ang pickle module upang ilipat ang mga istraktura ng object ng python?

Kapag gumamit ka ng atsara kasama ang mga socket, maaari mong ganap na ilipat ang anumang bagay sa pamamagitan ng network. Isulat natin ang panig ng server at mga katapat ng panig ng kliyente upang ilipat ang isang listahan mula sa server patungo sa kliyente:

Sa panig ng server:

import socket import pickle a = 10 s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) s.bind ((socket.gethostname (), 2133)) #binding tuple s.listen (5) habang True: clt, adr = s.accept () print (f'Connection to {adr} itinatag ') m = {1:' Client ', 2:' Server '} mymsg = pickle.dumps (m) #the msg we want to print later mymsg = {len (mymsg): {a}} 'utf-8') + mymsg clt.send (mymsg)

Dito, ang m ay isang diksyonaryo na karaniwang a na kailangang maipadala mula sa server sa client. Ginagawa ito sa pamamagitan ng unang serializing ng bagay gamit ang dumps () at pagkatapos ay i-convert ito sa mga byte.
Ngayon ay isulat natin ang katapat ng panig ng kliyente:

Panig ng kliyente:

import socket import pickle a = 10 s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) s.connect ((socket.gethostname (), 2133)) habang True: complete_info = b 'rec_msg = True habang True: mymsg = s.recv (10) kung rec_msg: print (f'The haba ng mensahe = {mymsg [: a]} ') x = int (mymsg [: a]) rec_msg = Maling complete_info + = mymsg kung len (complete_info) -a == x: print ('Natanggap ang kumpletong impormasyon') pag-print (complete_info [a:]) m = pickle.loads (complete_info [a:]) print (m) rec_msg = True complete_info = b 'print (complete_info )

Ang unang habang loop ay makakatulong sa amin na subaybayan ang kumpletong mensahe (complete_info) pati na rin ang mensahe na natatanggap (rec_msg) gamit ang buffer. ang mensahe sa pamamagitan ng pagtatakda ng rec_
Pagkatapos, habang natatanggap ang mensahe, ang ginagawa ko lang ay ang pag-print ng bawat bahagi nito, na natatanggap sa isang buffer ng laki 10. Ang laki na ito ay maaaring maging anumang depende sa iyong personal na pagpipilian.

Pagkatapos, kung ang natanggap na mensahe ay katumbas ng kumpletong mensahe, inililimbag ko lang ang mensahe bilang natanggap na kumpletong impormasyon kasunod nito na na-de-serial ko ang mensahe gamit ang mga pag-load ().

Ang output sa nabanggit na programa ay ang mga sumusunod:

Dinadala tayo nito sa pagtatapos ng artikulong ito sa Socket Programming sa Python. Inaasahan kong naunawaan mo nang malinaw ang lahat ng mga konsepto.

May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na 'Socket Programming in Python' na ito at babalikan ka namin sa lalong madaling panahon.

Upang makakuha ng malalim na kaalaman sa Python kasama ang iba't ibang mga application nito, maaari kang magpatala nang live na may 24/7 na suporta at habambuhay na pag-access.