Qu'est-ce que la programmation Socket en Python et comment la maîtriser?

Découvrez ce qu'est la programmation de socket en Python ainsi que les communications client-serveur ainsi que le transfert d'objets Python à l'aide de pickle et de sockets.

Internet est indéniablement devenu «l’âme de l’existence» et son activité est caractérisée par des «connexions» ou des «réseaux». Ces réseaux sont rendus possibles grâce à l'un des principes fondamentaux les plus cruciaux de Prises. Cet article couvre tous les domaines traitant de la programmation de socket en Python. Les prises vous aident à établir ces connexions, tandis que , sans aucun doute, le rend facile.



Jetons un coup d'œil à tous les sujets abordés dans cet article:



Pourquoi utiliser des sockets?
Que sont les sockets en Python?
Comment réaliser la programmation de socket en Python
Qu'est-ce qu'un serveur?
Qu'est-ce qu'un client?
Client-serveur Echo
Communications multiples
Transférer des objets Python



Pourquoi utiliser des sockets?

Les sockets sont l'épine dorsale du réseau. Ils permettent le transfert d'informations entre deux programmes ou appareils différents. Par exemple, lorsque vous ouvrez votre navigateur, vous créez en tant que client une connexion au serveur pour le transfert d'informations.

Avant de plonger plus profondément dans cette communication, voyons d'abord ce que sont exactement ces prises.

Que sont les sockets?

En termes généraux, les sockets sont des points de terminaison internes conçus pour l'envoi et la réception de données. Un seul réseau aura deux prises, une pour chaque appareil ou programme communicant. Ces sockets sont une combinaison d'une adresse IP et d'un port. Un seul appareil peut avoir un nombre «n» de sockets en fonction du numéro de port utilisé. Différents ports sont disponibles pour différents types de protocoles. Jetez un œil à l'image suivante pour en savoir plus sur certains des numéros de port communs et les protocoles associés:




ports communs-SocketProgramminginPython-Edureka

Maintenant que vous connaissez le concept des sockets, jetons maintenant un œil au module Socket de Python:

Comment réaliser la programmation de socket en Python:

Pour réaliser la programmation de socket en Python, vous devrez importer le prise module ou . Ce module comprend les méthodes intégrées nécessaires pour créer des sockets et les aider à s'associer les unes aux autres.

Certaines des méthodes importantes sont les suivantes:

MéthodesLa description

socket.socket ()

utilisé pour créer des sockets (requis à la fois sur le serveur et sur les extrémités client pour créer des sockets)

socket.accept ()

comment inverser un nombre
utilisé pour accepter une connexion. Il renvoie une paire de valeurs (conn, adresse) où conn est un nouvel objet socket pour envoyer ou recevoir des données et address est l'adresse du socket présent à 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 marquer la prise comme fermée

socket.connect ()

utilisé pour se connecter à une adresse distante spécifiée comme paramètre

socket.listen ()

permet au serveur d'accepter les connexions

Maintenant que vous avez compris l’importance du module socket, voyons comment il peut servir à créer des serveurs et des clients pour la programmation de socket dans .

Qu'est-ce qu'un serveur?

Un serveur est un programme, un ordinateur ou un périphérique dédié à la gestion des ressources réseau. Les serveurs peuvent être sur le même appareil ou ordinateur ou connectés 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 réseau, les serveurs d'impression, etc.

Les serveurs utilisent généralement des méthodes telles que socket.socket (), socket.bind (), socket.listen (), etc. pour établir une connexion et se lier aux clients. Écrivons maintenant un programme pour créer un serveur. Prenons l'exemple suivant:

EXEMPLE:

import socket s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) s.bind ((socket.gethostname (), 1234)) #port number peut être n'importe quoi entre 0-65535 (nous spécifions généralement les ports non prédéfinis qui sont > 1023) s.listen (5) while True: clt, adr = s.accept () print (f'Connexion à {adr} établie ') #f chaîne est une chaîne littérale préfixée par f qui # contient des expressions python entre accolades clt .send (bytes ('Socket Programming in Python', 'utf-8')) #pour envoyer des informations à clientsocket

Comme vous pouvez le voir, la première nécessité pour créer un socket est d'importer le module socket. Ensuite, la méthode socket.socket () est utilisée pour créer un socket côté serveur.

REMARQUE:

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

La méthode bind () accepte deux paramètres comme un tuple (hôte, port). Cependant, il est préférable d’utiliser des numéros de port à 4 chiffres car les numéros inférieurs sont généralement occupés. La méthode listen () permet au serveur d'accepter les connexions. Ici, 5 est la file d'attente pour plusieurs connexions qui se produisent simultanément. La valeur minimale qui peut être spécifiée ici est 0 (si vous donnez une valeur inférieure, elle est remplacée par 0). Dans le cas où aucun paramètre n'est spécifié, il prend un paramètre approprié par défaut.

La permet d'accepter les connexions pour toujours. «Clt» et «adr» sont l’objet et l’adresse du client. L'instruction print imprime simplement l'adresse et le numéro de port du socket client. Enfin, clt.send est utilisé pour envoyer les données en octets.

Maintenant que notre serveur est prêt, 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 du serveur. Dans un module client-serveur, les clients demandent des services aux serveurs. Le meilleur exemple est un navigateur Web tel que Google Chrome, Firefox, etc. Ces navigateurs Web demandent des serveurs Web pour les pages Web et les services requis selon les instructions de l'utilisateur. D'autres exemples incluent les jeux en ligne, les chats en ligne, etc.

Voyons maintenant comment coder le programme côté client dans :

EXEMPLE:

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

La première étape consiste à importer le module de socket, puis à créer une socket comme vous l'avez fait lors de la création d'un serveur. Ensuite, pour créer une connexion entre le client-serveur, vous devrez utiliser la méthode connect () en spécifiant (hôte, port).


REMARQUE: gethostname est 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 et pour cela, vous devez utiliser la méthode recv () et les informations sont stockées dans une autre variable msg. Gardez simplement à l'esprit que les informations transmises seront en octets et que le client du programme ci-dessus peut recevoir jusqu'à 1024 octets (taille de la mémoire tampon) en un seul transfert. Il peut être spécifié à n'importe quel montant en fonction de la quantité d'informations transférées.

Enfin, le message en cours de transfert doit être décodé et imprimé.

Maintenant que vous savez comment créer des programmes client-serveur, passons à la manière dont ils doivent être exécutés.

fonction de tri c ++

Client-Serveur Echo:

Pour exécuter ces programmes, ouvrez votre invite de commande, accédez au dossier où vous avez créé votre programme client et serveur, puis tapez:

py server.py (ici, server.py est le nom de fichier du serveur, vous pouvez également utiliser py -3.7 server.py)

Une fois que cela est fait, le serveur démarre. Pour exécuter le client, ouvrez une autre fenêtre cmd et tapez:

py client.py (ici, client.py est le nom de fichier du client)

SORTIE (SERVEUR):

(CLIENT)

Essayons le même programme en réduisant la taille de la mémoire tampon à 7 et voyons quel résultat nous obtenons:

PRODUCTION:

Comme vous pouvez le voir, la connexion est interrompue après le transfert de 7 octets. Mais c'est un problème car vous n'avez pas reçu les informations complètes et la connexion est fermée. Continuons à résoudre ce problème.

Communications multiples:

Pour que la connexion se poursuive jusqu'à ce que le client reçoive les informations complètes, vous pouvez utiliser la boucle while:

EXEMPLE:

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

Une fois que vous faites cela, le message complet sera reçu en 7 octets par transfert.

Mais cette fois, comme vous pouvez le voir, la connexion n’est pas interrompue et vous ne savez jamais quand cela va se produire. Et pour ajouter à cela, que se passe-t-il si vous ne savez pas quelle est la taille du message ou des informations que le client recevra du serveur. Dans de tels cas, vous pouvez en fait utiliser le bit de code suivant côté client:

EXEMPLE:

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 suit:

clt.close ()

La sortie de ceci sera comme indiqué dans l'image ci-dessous:

PRODUCTION:



Tout ce que fait le bloc de code ci-dessus est de vérifier la taille des informations et de les imprimer dans une mémoire tampon de deux octets à la fois et de fermer la connexion une fois celle-ci terminée.

Transfert d'objets Python:

Jusque là, vous venez d'acquérir le talent de transférer des cordes. Mais, la programmation de socket dans Python vous permet également de transférer des objets Python. Ces objets peuvent être n'importe quoi comme des ensembles, des tuples, des dictionnaires, etc. Pour ce faire, vous devrez importer le module pickle de Python.

Module pickle Python:

Le module pickle Python entre en scène lorsque vous sérialisez ou désérialisez des objets en python. Prenons un petit exemple,

EXEMPLE:

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

PRODUCTION: b’x80x03] qx00 (Kx01Kx02Xx03x00x00x00abcqx01e. »

Comme vous pouvez le voir, dans le programme ci-dessus, «mylist» est sérialisé en utilisant la fonction dumps () du module pickle. Notez également que la sortie commence par un «b», ce qui signifie qu’elle est convertie en octets. Dans la programmation de socket, vous pouvez implémenter ce module pour transférer objets python entre les clients et les serveurs.

Comment utiliser le module pickle pour transférer des structures d'objets python?

Lorsque vous utilisez pickle avec des sockets, vous pouvez absolument tout transférer via le réseau. Écrivons les équivalents côté serveur et côté client pour transférer une liste du serveur vers le client:

Du côté serveur:

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'Connexion à {adr} établie ') m = {1:' Client ', 2:' Serveur '} mymsg = pickle.dumps (m) #le msg que nous voulons imprimer plus tard mymsg = {len (mymsg): {a}} 'utf-8') + mymsg clt.send (mymsg)

Ici, m est un dictionnaire qui est fondamentalement un qui doit être envoyé du serveur au client. Cela se fait en sérialisant d'abord l'objet à l'aide de dumps (), puis en le convertissant en octets.
Maintenant, notons la contrepartie côté client:

Côté client:

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 tandis que True: mymsg = s.recv (10) si rec_msg: print (f'La longueur du message = {mymsg [: a]} ') x = int (mymsg [: a]) rec_msg = False complete_info + = mymsg si len (complete_info) -a == x: print ('A reçu les informations complètes') print (complete_info [a:]) m = pickle.loads (complete_info [a:]) print (m) rec_msg = True complete_info = b '' print (complete_info )

La première boucle while nous aidera à garder une trace du message complet (complete_info) ainsi que du message qui est reçu (rec_msg) en utilisant le tampon. le message en définissant rec_
Ensuite, pendant que le message est reçu, tout ce que je fais est d'en imprimer chaque bit, d'être reçu dans un tampon de taille 10. Cette taille peut être n'importe quoi selon votre choix personnel.

Ensuite, si le message reçu est égal au message complet, j'imprime simplement le message en tant qu'informations complètes reçues, après quoi j'ai désérialisé le message à l'aide de charges ().

La sortie vers le programme ci-dessus est la suivante:

Cela nous amène à la fin de cet article sur la programmation de socket en Python. J'espère que vous avez bien compris tous les concepts.

Assurez-vous de pratiquer autant que possible et inversez votre expérience.

Vous avez une question pour nous? Veuillez le mentionner dans la section commentaires de ce blog «Programmation de socket en Python» et nous vous répondrons dans les plus brefs délais.

Pour obtenir des connaissances approfondies sur Python ainsi que sur ses différentes applications, vous pouvez vous inscrire en direct avec assistance 24/7 et accès à vie.