Penjelasan terperinci dan panduan praktikal pengaturcaraan Soket Python

Dalam Internet hari ini, protokol Socket ialah salah satu asas yang paling penting. Artikel ini merangkumi semua bidang bekerja dengan pengaturcaraan Socket dalam Python.

Mengapa menggunakan Soket

Soket ialah pelbagai protokol komunikasi yang membentuk rangkaian hari ini Protokol ini membolehkan penghantaran maklumat antara dua program atau peranti yang berbeza. menjadi mungkin. Sebagai contoh, apabila kami membuka pelayar, kami sebagai pelanggan membuat sambungan ke pelayan untuk memindahkan maklumat.

Sebelum mendalami prinsip komunikasi ini, mari kita jelaskan dahulu apa itu Soket.

Apakah itu Soket

Secara umumnya, Soket ialah protokol aplikasi dalaman yang dibina untuk menghantar dan menerima data. Satu rangkaian akan mempunyai dua Soket, satu untuk setiap peranti atau program komunikasi, Soket ini adalah gabungan alamat IP dan port. Bergantung pada nombor port yang digunakan, satu peranti boleh mempunyai nombor "n" Soket, dan port yang berbeza boleh digunakan untuk jenis protokol yang berbeza.

Rajah berikut menunjukkan beberapa nombor port biasa dan maklumat protokol yang berkaitan:

Protokol	Nombor port	Perpustakaan Python	Mohon
HTTP	80	httplib, urllib, permintaan	Halaman web, tapak web
FTP	20	ftplib	Pemindahan Fail
NNTP	119	nttplib	Pemindahan Berita
SMTP	25	smtplib	Hantar E-mel
Telnet	23	telnetlib	baris arahan
POP3	110	poplib	Terima e-mel
Gopher	70	gopherlib	Pemindahan Dokumen

Sekarang kita telah memahami konsep Soket, mari kita lihat modul Socket Python

Cara melaksanakan pengaturcaraan Socket dalam Python

Untuk melaksanakan pengaturcaraan Socket dalam Python, anda perlu Import modul soket.

Beberapa kaedah penting modul ini adalah seperti berikut:

方法	描述
socket.socket()	用于创建 socket（服务器端和客户端都需要创建）
socket.accept()	用于接受连接。它返回一对值（conn，address），其中conn是用于发送或接收数据的新 socket 对象，address是连接另一端的 socket 地址
socket.bind()	用于绑定到指定为参数的地址
socket.close()	用于关闭 socket
socket.connect()	用于连接到指定为参数的远程地址
socket.listen()	使服务器能够接受连接

Penerangan

socket.accept()

digunakan untuk menerima sambungan. Ia mengembalikan sepasang nilai (sambung, alamat), dengan sambung ialah objek soket baharu yang digunakan untuk menghantar atau menerima data dan alamat ialah alamat soket di hujung sambungan yang satu lagi

digunakan untuk mengikat ke alamat yang ditentukan sebagai parameter

td>

socket.listen()

Dayakan pelayan untuk Terima sambungan

Sekarang kita memahami kepentingan modul soket, mari lihat cara membina pelayan dan klien dalam Python.

Apakah pelayan itu?

Pelayan adalah sama ada program, komputer atau peranti yang digunakan khusus untuk mengurus sumber rangkaian. Pelayan boleh berada pada peranti atau komputer yang sama, disambungkan secara setempat ke peranti dan komputer lain, atau bahkan dari jauh. Terdapat pelbagai jenis pelayan seperti pelayan pangkalan data, pelayan web, pelayan cetak, dll.

Pelayan biasanya menggunakan socket.socket(), socket.bind(), socket.listen(), dsb. untuk mewujudkan sambungan dan mengikat kepada pelanggan Sekarang mari kita menulis program untuk mencipta pelayan.

import socket
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((socket.gethostname(),1234))
#port number can be anything between 0-65535(we usually specify non-previleged ports which are > 1023)
s.listen(5)
 
while True:
clt,adr=s.accept()
print(f"Connection to {adr}established")
 #f string is literal string prefixed with f which 
 #contains python expressions inside braces
clt.send(bytes("Socket Programming in Python","utf-8 ")) #to send info to clientsocket

Syarat pertama yang perlu untuk mencipta soket ialah mengimport modul yang berkaitan. Kemudian gunakan kaedah socket.socket() untuk mencipta soket sisi pelayan.

AF_INET merujuk kepada alamat dari Internet, yang memerlukan pasangan (hos, port), di mana hos boleh menjadi URL tapak web tertentu atau alamat, Nombor port ialah integer. SOCK_STREAM digunakan untuk mencipta protokol TCP. Kaedah

bind() menerima dua parameter sebagai tupel (hos, port). Perlu diingatkan di sini bahawa lebih baik menggunakan nombor port 4 digit, kerana nombor port yang lebih rendah biasanya diduduki atau dikhaskan oleh sistem. Kaedah listen() membenarkan pelayan menerima sambungan, dan 5 ialah baris gilir untuk berbilang sambungan yang diterima pada masa yang sama. Nilai minimum yang boleh ditentukan di sini ialah 0, dan jika tiada parameter dinyatakan, parameter lalai yang sesuai digunakan.

Gelung while membenarkan selama-lamanya menerima sambungan, clt dan adr ialah objek dan alamat klien, pernyataan cetakan hanya mencetak alamat dan nombor port soket klien, dan akhirnya, clt.send digunakan untuk hantar bait Hantar data ke unit.

Sekarang pelayan kami telah disediakan, mari beralih kepada pelanggan.

Apakah itu klien

Klien ialah komputer atau perisian yang menerima maklumat atau perkhidmatan daripada pelayan. Dalam model pelanggan-pelayan, pelanggan meminta perkhidmatan daripada pelayan. Contoh terbaik ialah pelayar web seperti Google Chrome, Firefox, dll. Pelayar web ini meminta pelayan web untuk menyediakan halaman web dan perkhidmatan yang diperlukan berdasarkan arahan pengguna. Contoh lain termasuk permainan dalam talian, sembang dalam talian, dsb.

Sekarang, mari lihat cara menulis program klien dalam bahasa pengaturcaraan Python:

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"))

Mula-mula masih mengimport modul soket, dan kemudian buat soket seperti semasa membuat pelayan. Kemudian untuk membuat sambungan antara klien dan pelayan, anda perlu menggunakan kaedah connect() dengan menentukan (hos, port).

Nota: gethostname diperlukan apabila klien dan pelayan berada pada komputer yang sama. (LAN–localip/WAN–publicip)

Di sini, pelanggan ingin menerima beberapa maklumat daripada pelayan, untuk ini kita perlu menggunakan kaedah recv()​, maklumat itu disimpan dalam yang lain mesej berubah-ubah. Adalah penting untuk ambil perhatian bahawa maklumat yang dipindahkan adalah dalam bait, dan dalam klien program di atas, maksimum 1024 bait (saiz penimbal) boleh diterima dalam satu pemindahan. Ini boleh ditentukan sebagai sebarang nombor bergantung pada jumlah maklumat yang dipindahkan.

Akhir sekali, nyahkod dan mencetak mesej yang dihantar.

Sekarang kita memahami cara mencipta program pelayan-pelanggan, mari lihat bagaimana ia perlu dilaksanakan.

Interaksi Pelayan Pelanggan

Untuk melaksanakan program ini, anda perlu membuka program arahan, pergi ke folder tempat program klien dan pelayan dicipta, dan taip:

py server.py #这里，server.py 是服务器的文件名

Tidak Pelayan mula berjalan tanpa diduga

Untuk melaksanakan klien, anda perlu membuka tetingkap cmd lain dan taip:

pyclient.py

Mari kita kurangkan saiz penimbal kepada 7 dan lihat rupa program yang sama

Seperti yang ditunjukkan dalam rajah, selepas memindahkan 7 bait, Sambungan ditamatkan.

Sebenarnya ini adalah masalah kerana kami belum menerima maklumat lengkap, tetapi sambungan telah ditutup awal. Biar kami selesaikan masalah ini.

Berbilang komunikasi

Untuk meneruskan sambungan sebelum klien menerima mesej lengkap, kami boleh menggunakan gelung sementara

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

Selepas pengubahsuaian ini, setiap penghantaran akan menjadi 7 bait untuk menerima mesej lengkap.

Tetapi ini membawa masalah lain, sambungan tidak pernah terputus, anda tidak tahu bila ia akan ditamatkan. Juga, bagaimana jika kita sebenarnya tidak tahu berapa besar mesej atau maklumat yang pelanggan akan terima daripada pelayan. Dalam kes ini, kita perlu terus menambah baik kod

complete_info=''
while True:
msg = s.recv(7)
if len(msg)<=0:
break
complete_info += msg.decode("utf-8")
print(complete_info)

Di bahagian pelayan, gunakan kaedah close() seperti berikut:

clt.close()

Output adalah seperti berikut:

程序会检查信息的大小，并将其打印到一次两个字节的缓冲区中，然后在完成连接后关闭连接。

传输 Python 对象

目前为止我们仅仅掌握了传递字符串的方法，但是，Python 中的 Socket 编程也允许我们传输 Python 对象。这些对象可以是集合、元组、字典等。要实现这一点，需要用到 Python 的 pickle 模块。

Python pickle模块

当我们实际序列化或反序列化 Python 中的对象时，就会使用到 Python pickle 模块。让我们看一个小例子

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

Output:

b’x80x03]qx00(Kx01Kx02Xx03x00x00x00abcqx01e.’

在上面的程序中，mylist​是使用pickle模块的dumps()​函数序列化的。还要注意，输出以b开头，表示它已转换为字节。在 socket 编程中，可以实现此模块以在客户端和服务器之间传输 python 对象。

如何使用 pickle 模块传输 Python 对象

当我们将 pickle 与 socket 一起使用时，完全可以通过网络传输任何内容。

先来看看服务端代码

Server-Side:

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)
while True:
clt , adr = s.accept()
print(f"Connection to {adr}established")
 
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)

这里，m​是一个字典，它基本上是一个需要从服务器发送到客户端的 Python 对象。这是通过首先使用dumps()序列化对象，然后将其转换为字节来完成的。

现在，让我们记下客户端：

Client-Side:

import socket
import pickle
a=10
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((socket.gethostname(), 2133))
 
while True:
complete_info = b''
rec_msg = True
while True:
mymsg = s.recv(10)
 if rec_msg:
print(f"The length of message = {mymsg[:a]}")
x = int (mymsg[:a ] )
rec_msg = False
complete_info += mymsg
if len(complete_info)-a == x:
print("Recieved the complete info")
print(complete_info[a:])
m = pickle.loads(complete_info[a:])
print(m)
rec_msg = True
complete_info = b''
print(complete_info)

第一个while循环将帮助我们跟踪完整的消息（complete_info）以及正在使用缓冲区接收的消息（rec_msg）。

然后，在接收消息时，我们所做的就是打印每一位消息，并将其放在大小为10的缓冲区中接收。此大小可以是任何大小，具体取决于个人选择。

然后如果收到的消息等于完整消息，我们只会将消息打印为收到的完整信息，然后使用loads()反序列化消息。

输出如下：

​ ​

Atas ialah kandungan terperinci Penjelasan terperinci dan panduan praktikal pengaturcaraan Soket Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!