Explication détaillée du module socket en python

La signification anglaise originale de Socket est « trou » ou « socket ». En tant que mécanisme de communication de processus de BSD UNIX, il est également communément appelé « socket », qui est utilisé pour décrire les adresses IP et les ports. Il s'agit du handle d'une chaîne de communication et peut être utilisé pour implémenter la communication entre différentes machines virtuelles ou différents ordinateurs. .

Deux programmes sur le réseau échangent des données via une connexion de communication bidirectionnelle. Une extrémité de cette connexion est appelée une prise.

Au moins une paire de numéros de port (socket) est requise pour établir une connexion de communication réseau. Socket est essentiellement une interface de programmation (API), qui encapsule TCP/IP. TCP/IP fournit également une interface que les programmeurs peuvent utiliser pour le développement de réseaux. Il s'agit de l'interface de programmation Socket ; HTTP est un moyen d'encapsuler ou d'afficher. données. Forme spécifique ; Socket est le moteur, offrant la capacité de communication réseau.

Parlons du socket de Python.

Module 1.socket

Utilisez la fonction socket.socket() pour créer un socket. La syntaxe est la suivante :

socket.socket(socket_family,socket_type,protocol=0)

socket_family peut être les paramètres suivants :

socket.AF_INET IPv4 (par défaut)

socket.AF_INET6 IPv6

socket.AF_UNIX ne peut être utilisé que pour la communication inter-processus dans un seul système Unix

socket_type peut être les paramètres suivants :

socket.SOCK_STREAM streaming socket, pour TCP (par défaut)

socket.SOCK_DGRAM Datagram socket, pour UDP

socket.SOCK_RAW raw socket, le socket ordinaire ne peut pas gérer les paquets réseau tels que ICMP et IGMP text, et SOCK_RAW le peut ; deuxièmement, SOCK_RAW peut également gérer des messages IPv4 spéciaux ; de plus, en utilisant des sockets bruts, l'en-tête IP peut être construit par l'utilisateur via l'option de socket IP_HDRINCL ;

Socket.SOCK_RDM est une forme fiable d'UDP, qui garantit la livraison des datagrammes mais ne garantit pas la commande. SOCK_RAM est utilisé pour fournir un accès de bas niveau au protocole d'origine et est utilisé lorsque certaines opérations spéciales doivent être effectuées, telles que l'envoi de messages ICMP. SOCK_RAM est généralement limité aux programmes exécutés par des utilisateurs expérimentés ou des administrateurs.

socket.SOCK_SEQPACKET Service de paquets continu fiable

paramètre de protocole :

0 (par défaut) Le protocole lié à la famille d'adresses spécifique S'il est 0, le système A. le protocole approprié sera automatiquement sélectionné en fonction du format d'adresse et du type de socket

2. Méthodes intégrées de l'objet Socket

Fonctions de socket côté serveur

s. Liez l'adresse (adresse IP, port) au socket. Les paramètres doivent être au format de tuples : s.bind(('127.0.0.1',8009))

s.listen(. 5) Commencez à écouter, 5 est le nombre maximum de connexions en attente

s.accept() Accepter passivement les connexions client, bloquer et attendre les connexions

Fonction de socket client

s.connect()　Connectez-vous au serveur, les paramètres doivent être au format tuple : s.connect(('127,0.0.1',8009))

Fonction socket à usage public

s.recv(1024) Recevoir des données TCP, 1024 est la taille d'une réception de données

s.send(bytes) Envoyer des données TCP, le format des données d'envoi de python3 doit être au format octets

s.sendall()　Envoyez complètement les données et la boucle interne appelle send

s.close()　Fermez la socket

Exemple 1. Implémentation simple du programme socket

Terminal du serveur

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
import socket
import time
IP_PORT = ('127.0.0.1',8009)
BUF_SIZE = 1024
 
tcp_server = socket.socket()
tcp_server.bind(IP_PORT)
tcp_server.listen(5)
 
while True:
    print("waiting for connection...")
    conn,addr = tcp_server.accept()
    print("...connected from:",addr)
    while True:
        data = tcp_server.recv(BUF_SIZE)
        if not data:break
        tcp_server.send('[%s] %s'%(time.ctime(),data))
 
tcp_server.close()

Explication du code ci-dessus :

Lignes 1~4

La première ligne est la ligne d'informations de démarrage Unix, puis la le module time et le module socket sont importés

Lignes 5~10

IP_PORT déclare l'adresse IP et le port comme variable globale, indiquant que la fonction bind() est liée à cette adresse, définit le taille du tampon à 1 Ko, et la fonction Listen() indique le nombre maximum de connexions autorisées à entrer en même temps, et les suivantes seront rejetées

11~ Allez à la dernière ligne

Après être entré dans la boucle du serveur, attendez passivement l'arrivée de la connexion. Lorsqu'il y a une connexion, entrez dans la boucle de conversation et attendez que le client envoie des données. Si le message est vide, cela signifie que le client est sorti, il sortira de la boucle et attendra l'arrivée de la prochaine connexion. Après avoir reçu le message client, ajoutez un horodatage devant le message et revenez. La dernière ligne ne sera pas exécutée car la boucle ne se terminera pas donc le serveur n'exécutera pas close(). Juste un rappel de ne pas oublier d'appeler la fonction close().

Côté client

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
import socket
 
HOST = '127.0.0.1'
PORT = 8009
BUF_SIZE = 1024
ADDR = (HOST,PORT)
 
client = socket.socket()
client.connect(ADDR)
 
while True:
    data = input(">>> ")
    if not data:break
    client.send(bytes(data,encoding='utf-8'))
    recv_data = client.recv(BUF_SIZE)
    if not recv_data:break
    print(recv_data.decode())
     
client.close()

Ligne 5~11

Les variables HOST et PORT représentent l'adresse IP et le numéro de port du serveur. La démonstration étant sur le même serveur, les adresses IP sont toutes 127.0.0.1. Si elle est exécutée sur d'autres serveurs, les modifications correspondantes doivent être apportées. Le numéro de port doit être exactement le même que celui du serveur, sinon la communication ne sera pas possible. La taille du tampon est toujours de 1 Ko.

Le socket client est créé à la ligne 10 puis se connecte au serveur

Lignes 13~21

Le client boucle également à l'infini, et la boucle du client est dans ce qui suit 2 Quittez une fois l'une des conditions remplie : 1. L'entrée utilisateur est vide ou le message de réponse côté serveur est vide. Sinon, le client enverra la chaîne saisie par l'utilisateur au serveur pour traitement, puis recevra la chaîne avec horodatage renvoyée par le serveur d'affichage.

Exécutez le programme client et le programme serveur

Ce qui suit est l'entrée et la sortie du client

[root@pythontab]# python client.py 
>>> hello python
[Thu Sep 15 22:29:12 2016] b'hello python'

Ce qui suit est la sortie du serveur

[root@pythontab]# python server.py 
waiting for connection...
...connected from: ('127.0.0.1', 55378)

3.module socketserver

socketserver est un module de haut niveau dans la bibliothèque standard. Utilisé pour simplifier la grande quantité de code passe-partout requis pour implémenter les clients et les serveurs réseau. Certaines classes pouvant être utilisées ont été implémentées dans le module.

Exemple 1 : utilisez socketserver pour obtenir la même fonction que l'exemple socket() ci-dessus

服务端程序代码

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
import socketserver
import time
 
HOST = '127.0.0.1'
PORT = 8009
ADDR = (HOST,PORT)
BUF_SIZE = 1024
 
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            print("...connected from:",self.client_address)
            data = self.request.recv(BUF_SIZE)
            if not data:break
            self.request.send(bytes("%s %s"%(time.ctime(),data)))
 
server = socketserver.ThreadingTCPServer(ADDR,Myserver)
print("waiting for connection...")
server.serve_forever()

11~17行

主要的工作在这里。从socketserver的BaseRequestHandler类中派生出一个子类，并重写handle()函数。

在有客户端发进来的消息的时候，handle()函数就会被调用。

19~21行

代码的最后一部分用给定的IP地址和端口加上自定义处理请求的类(Myserver)。然后进入等待客户端请求与处理客户端请求的无限循环中。

客户端程序代码

import socket
HOST = '127.0.0.1'
PORT = 8009
ADDR = (HOST,PORT)
BUF_SIZE = 1024
 
client = socket.socket()
client.connect(ADDR)
 
while True:
    data = input(">>> ")
    if not data:continue
    client.send(bytes(data,encoding='utf-8'))
    recv_data = client.recv(BUF_SIZE)
    if not recv_data:break
    print(recv_data.decode())
 
client.close()

执行服务端和客户端代码　　

下面是客户端输出

[root@pythontab]# python socketclient.py 
>>> hello python
Thu Sep 15 23:53:31 2016 b'hello python'
>>> hello pythontab
Thu Sep 15 23:53:49 2016 b'hello pythontab'

下面是服务端输出

[root@pythontab]# python socketserver.py 
waiting for connection...
...connected from: ('127.0.0.1', 55385)
...connected from: ('127.0.0.1', 55385)
...connected from: ('127.0.0.1', 55385)
...connected from: ('127.0.0.1', 55385)

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!