Programmation Websocket en Python

Avec le développement rapide d'Internet, le protocole Websocket est également largement utilisé comme nouveau protocole de communication. En tant que langage de programmation courant, Python possède de nombreuses excellentes bibliothèques Websocket, telles que Tornado et WebSocket-Server, qui offrent un bon support aux développeurs.

Cet article présentera le protocole Websocket et sa différence avec le protocole HTTP, ainsi que les étapes et méthodes de mise en œuvre du développement d'applications Websocket à l'aide de Python.

1. Introduction au protocole Websocket

Le protocole Websocket est un protocole de communication full-duplex qui s'exécute au-dessus du protocole TCP. Ce protocole fournit une connexion persistante, permettant une transmission de données bidirectionnelle en temps réel entre le client et le serveur, et peut être utilisé dans les communications en temps réel, les jeux en ligne et d'autres scénarios.

Les caractéristiques du protocole Websocket sont les suivantes :

(1) Toute transmission de données est basée sur la trame (Frame).

(2) Le protocole Websocket utilise le protocole HTTP lors de la phase de handshake.

(3) Le protocole Websocket fournit deux types de trames : les trames de données et les trames de contrôle. Les trames de données sont utilisées pour transmettre des messages et les trames de contrôle sont utilisées pour maintenir l'état de la connexion.

(4) Le protocole Websocket fournit un mécanisme de battement de cœur pour maintenir la stabilité de la connexion.

(5) Le protocole Websocket peut communiquer via SSL/TLS crypté et des méthodes non cryptées.

2. La différence entre le protocole Websocket et le protocole HTTP

Le protocole Websocket et le protocole HTTP sont tous deux des protocoles de couche application, mais il existe les principales différences suivantes entre eux :

(1) Websocket est une connexion persistante et HTTP est une connexion persistante. connexion courte.

(2) Le protocole Websocket utilise le protocole HTTP pour la communication pendant la phase de prise de contact, mais la phase de prise de contact Websocket ne doit être effectuée qu'une seule fois, puis la communication de données en temps réel peut être effectuée.

(3) Le protocole Websocket utilise des trames binaires et des trames de texte pour la transmission de données, tandis que le protocole HTTP ne peut transmettre que des données texte.

(4) Le protocole Websocket peut effectuer une transmission de données bidirectionnelle, tandis que le protocole HTTP ne peut effectuer qu'une transmission de données unidirectionnelle.

3. Python implémente les applications Websocket

Il existe de nombreuses bibliothèques Websocket en Python, parmi lesquelles Tornado et WebSocket-Server sont les plus couramment utilisées. Cet article prendra WebSocket-Server comme exemple pour présenter comment utiliser Python pour implémenter des applications Websocket.

1. Installer la bibliothèque WebSocket-Server

Entrez la commande suivante sur la ligne de commande pour installer la bibliothèque WebSocket-Server :

pip install websocket-server

2. Écrire le code du serveur

Pour implémenter un serveur Websocket en Python, vous devez d'abord créez un objet WebsocketServer. Surchargez ensuite plusieurs de ses méthodes d'événement, telles que on_open(), on_message(), on_close(), etc., pour effectuer des opérations telles que la connexion de données, la réception de données et la fermeture de connexion.

Le code spécifique est le suivant :

from websocket_server import WebsocketServer

# 客户端连接时触发
def new_client(client, server):
    print("New client connected and was given id %d" % client["id"])
    server.send_message_to_all("Hey all, a new client has joined us")

# 接收到客户端消息时触发
def message_received(client, server, message):
    print("Client(%d) said: %s" % (client["id"], message))
    server.send_message_to_all("Client(%d) said: %s" % (client["id"], message))

# 客户端关闭连接时触发
def client_left(client, server):
    print("Client(%d) disconnected" % client["id"])

# 建立 WebSocketServer 对象，监听 9001 端口
server = WebsocketServer(9001)
server.set_fn_new_client(new_client)
server.set_fn_message_received(message_received)
server.set_fn_client_left(client_left)

# 启动服务器
server.run_forever()

3. Exécutez le serveur Websocket

Entrez la commande suivante dans la ligne de commande pour démarrer le serveur WebSocket :

python server.py

4. Écrivez le code client

Pour implémenter le client Websocket en Python, vous devez établir un objet WebSocketClient, puis appeler plusieurs de ses méthodes, telles que connect(), send(), close(), etc., pour terminer les opérations de connexion, d'envoi de données et de fermeture.

Le code spécifique est le suivant :

from websocket import create_connection

# 建立 WebSocket 连接
ws = create_connection("ws://localhost:9001/")

# 发送消息
ws.send("Hello, world!")

# 接收消息
result = ws.recv()
print("Received '%s'" % result)

# 关闭 WebSocket 连接
ws.close()

Ce qui précède sont les étapes et les méthodes de mise en œuvre de la programmation Websocket en Python. De cette manière, des applications telles que la communication en temps réel et les jeux en ligne peuvent être réalisées. Bien entendu, en plus de la bibliothèque WebSocket-Server, il existe d'autres bibliothèques Websocket parmi lesquelles choisir, et les développeurs peuvent les choisir et les essayer en fonction de leurs propres besoins.

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!