Explication détaillée et guide pratique de la programmation Python Socket

Dans l’Internet d’aujourd’hui, le protocole Socket est l’un des fondements les plus importants. Cet article couvre tous les domaines de travail avec la programmation Socket en Python.

Pourquoi utiliser les Sockets

Les Sockets sont les différents protocoles de communication qui composent les réseaux actuels. Ces protocoles permettent de transférer des informations entre deux programmes ou appareils différents. Par exemple, lorsque nous ouvrons un navigateur, nous, en tant que clients, créons une connexion au serveur pour transférer des informations.

Avant d'aborder ce principe de communication, clarifions d'abord ce que sont les Sockets.

Que sont les Sockets

De manière générale, les Sockets sont des protocoles d'application internes conçus pour envoyer et recevoir des données. Un seul réseau aura deux Sockets, un pour chaque périphérique ou programme communicant, ces Sockets sont une combinaison d'adresse IP et de port. En fonction du numéro de port utilisé, un seul périphérique peut avoir un nombre « n » de sockets, et différents ports peuvent être utilisés pour différents types de protocoles.

L'image ci-dessous montre quelques numéros de port courants et les informations de protocole associées :

Protocole	Numéro de port	Bibliothèque Python	Applications
HTTP	80	httplib, urllib, requêtes	web, site web
FTP	20	ftplib	Transfert de fichiers
NNTP 119	smtplib	Envoyer un mail	Telnet
23	telnetlib	Ligne de commande	POP3
110	poplib	Recevoir du courrier	Gopher
70	gopherlib	Transfert de documents

Maintenant que nous avons compris le concept de Sockets, jetons un coup d'œil au module Socket de Python

Comment implémenter la programmation Socket en Python

Pour implémenter la programmation Socket en Python, vous devez importer le module socket.

Certaines méthodes importantes de ce module sont les suivantes :

Used pour se connecter à l'adresse distante spécifiée en tant que paramètre Sable le serveur pour accepter les connexions

Méthode	Description
socket.socket()	est utilisé pour créer socket (server Le client et le client doivent être créés)
socket.accept()	est utilisé pour accepter les connexions. Il renvoie une paire de valeurs (conn, adresse), où conn est le nouvel objet socket utilisé pour envoyer ou recevoir des données et adresse est l'adresse du socket à l'autre extrémité de la connexion
socket.bind ()	Utilisé pour se lier à l'adresse spécifiée en paramètre
socket.close()	Utilisé pour fermer le socket
socket .connect( )
	socket.Listen ()

🎜🎜🎜🎜

Maintenant que nous comprenons l'importance du module socket, voyons comment créer des serveurs et des clients en Python.

Qu'est-ce qu'un serveur

Un serveur est soit un programme, un ordinateur ou un appareil spécifiquement utilisé pour gérer les ressources réseau. Le serveur peut se trouver sur le même appareil ou ordinateur, connecté localement à d'autres appareils et ordinateurs, ou même à distance. Il existe différents types de serveurs tels que les serveurs de bases de données, les serveurs Web, les serveurs d'impression, etc.

Les serveurs utilisent généralement socket.socket(), socket.bind(), socket.listen(), etc. pour établir des connexions et se lier aux clients. Écrivons maintenant un programme pour créer un serveur.

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

La première condition nécessaire pour créer un socket est d'importer les modules concernés. Utilisez ensuite la méthode socket.socket() pour créer un socket côté serveur.

AF_INET fait référence à l'adresse d'Internet, il nécessite une paire (hôte, port), où l'hôte peut être l'URL d'un site Web spécifique ou son adresse, et le numéro de port est un entier. SOCK_STREAM est utilisé pour créer le protocole TCP. La méthode

bind()​ accepte deux paramètres sous forme de tuple (hôte, port). Il convient de noter ici qu'il est préférable d'utiliser un numéro de port à 4 chiffres, car les numéros de port inférieurs sont généralement occupés ou réservés par le système. La méthode Listen() permet au serveur d'accepter les connexions, et 5 est une file d'attente pour plusieurs connexions acceptées en même temps. La valeur minimale pouvant être spécifiée ici est 0, et si aucun paramètre n'est spécifié, les paramètres appropriés par défaut sont utilisés.

La boucle while permet d'accepter les connexions pour toujours, clt et adr sont les objets et adresses client, l'instruction print imprime simplement l'adresse et le numéro de port du socket client, et enfin, clt.send est utilisé pour envoyer des données en octets .

Maintenant que notre serveur est configuré, passons au client.

Qu'est-ce qu'un client

Un client est un ordinateur ou un logiciel qui reçoit des informations ou des services d'un serveur. Dans le modèle client-serveur, le client demande des services au serveur. Les meilleurs exemples sont les navigateurs Web tels que Google Chrome, Firefox, etc. Ces navigateurs Web demandent au serveur Web de fournir les pages Web et les services requis en fonction des instructions de l'utilisateur. D'autres exemples incluent les jeux en ligne, le chat en ligne, etc.

Voyons maintenant comment écrire un programme client en langage de programmation 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"))

Importez d'abord toujours le module socket, puis créez le socket comme vous l'avez fait lors de la création du serveur. Ensuite, pour créer une connexion entre le client et le serveur, vous devez utiliser la méthode connect() en spécifiant (hôte, port).

Remarque : gethostname doit être utilisé lorsque le client et le serveur sont sur le même ordinateur. (LAN–localip/WAN–publicip)

Ici, le client souhaite recevoir des informations du serveur, pour cela nous devons utiliser la méthode recv()​, les informations sont stockées dans une autre variable msg. Il est important de noter que les informations transférées seront en octets et que dans le client du programme ci-dessus, un maximum de 1 024 octets (taille du tampon) peuvent être reçus en un seul transfert. Cela peut être spécifié sous n'importe quel nombre en fonction de la quantité d'informations transférées.

Enfin, décodez et imprimez le message en cours de transmission.

Maintenant que nous comprenons comment créer des programmes client-serveur, voyons comment ils doivent être exécutés.

Interaction client-serveur

Pour exécuter ces programmes, vous devez ouvrir le programme de commande, entrer dans le dossier dans lequel les programmes client et serveur ont été créés, puis taper :

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

Comme prévu, le serveur commence à fonctionner

Pour exécuter le client, vous devez ouvrir une autre fenêtre cmd et taper :

pyclient.py

Réduisons la taille du tampon à 7 et voyons à quoi ressemblera le même programme

Comme le montre l'image, transférez 7 octets plus tard, la connexion est terminée.

En fait, c'est un problème car nous n'avons pas encore reçu les informations complètes, mais la connexion a été fermée plus tôt. Résolvons ce problème.

Communications multiples

Afin de poursuivre la connexion jusqu'à ce que le client ait reçu le message complet, nous pouvons utiliser une boucle while

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

Après une telle modification, chaque transmission recevra le message complet en 7 octets.

Mais cela soulève un autre problème, la connexion ne se termine jamais, on ne sait jamais quand elle se terminera. De plus, que se passe-t-il si nous ne savons pas réellement quelle est la taille du message ou des informations que le client recevra du serveur. Dans ce cas, nous devons continuer à améliorer le code

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

Côté serveur, utilisez la méthode close() comme indiqué ci-dessous :

clt.close()

Le résultat est le suivant :

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

传输 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()反序列化消息。

输出如下：

​ ​

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!