python实现的websocket代码

合集下载

网络连接代码大全

网络连接代码大全网络连接是现代社会中不可或缺的一部分，它使得人们可以方便地进行在线交流、获取信息以及进行各种网络活动。

要实现网络连接，代码编程是必不可少的环节。

本文将为读者提供一个网络连接代码大全，包括常见的网络连接方式和对应的代码实现。

一、TCP/IP连接TCP/IP是互联网通信的基础协议，可以通过TCP/IP协议进行网络连接。

以下是一些常见的TCP/IP连接代码实现：1. 使用Java实现TCP/IP连接：```javaimport .Socket;import java.io.InputStream;import java.io.OutputStream;public class TCPClient {public static void main(String[] args) {try {Socket socket = new Socket("服务器地址", 端口号);OutputStream out = socket.getOutputStream();InputStream in = socket.getInputStream();// 发送数据out.write("Hello, Server!".getBytes());out.flush();// 接收数据byte[] buffer = new byte[1024];int length = in.read(buffer);System.out.println(new String(buffer, 0, length)); // 关闭连接socket.close();} catch (Exception e) {e.printStackTrace();}}}```2. 使用Python实现TCP/IP连接：```pythonimport socketdef tcp_client():try:client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(("服务器地址", 端口号))# 发送数据client.send("Hello, Server!".encode())# 接收数据data = client.recv(1024)print(data.decode())# 关闭连接client.close()except Exception as e:print(str(e))if __name__ == "__main__":tcp_client()}```二、HTTP连接HTTP连接是在TCP/IP协议的基础上实现的一种应用层网络协议。

pyqt5 websocket 用法

一、什么是PyQt5 WebsocketPyQt5是一个用于创建GUI应用程序的Python库，而Websocket 是一种在Web浏览器和服务器之间进行全双工通信的协议。

PyQt5 Websocket是指在PyQt5的基础上使用Websocket协议进行通信，实现实时数据传输和交互式通信。

二、PyQt5 Websocket的优势1. 实时性：使用PyQt5 Websocket可以实现实时数据传输，能够满足一些需要即时更新数据的应用场景，如股票行情、实时聊天等。

2. 跨评台性：PyQt5可以在多个操作系统上运行，结合Websocket 可以实现跨评台的实时通信功能。

3. 可扩展性：PyQt5本身提供了丰富的GUI组件，结合Websocket 可以实现更丰富的交互式应用。

三、PyQt5 Websocket的用法1. 安装PyQt5库和websocket库首先需要在Python环境中安装PyQt5库和websocket库，可以使用pip命令进行安装：```pythonpip install PyQt5pip install websocket-client```2. 创建GUI应用程序使用PyQt5创建一个GUI应用程序，可以使用Qt Designer进行界面设计，然后使用PyQt5的相关类进行代码编写。

在界面中添加一个按钮或其他交互组件，用于触发Websocket连接。

3. 连接Websocket服务器在应用程序中使用websocket库连接Websocket服务器，可以使用服务器的URL进行连接：```pythonimport websocketws = websocket.create_connection("ws://example/websocket") ```4. 发送和接收数据使用websocket库提供的send和recv方法可以实现向服务器发送数据和接收数据的功能，例如：```pythonws.send("Hello, Server!")result = ws.recv()```5. 实现交互功能将Websocket接收到的数据展示在GUI界面上，或者根据接收到的数据改变界面上的元素，实现交互功能。

PythonWebSocket长连接心跳与短连接的示例

PythonWebSocket长连接⼼跳与短连接的⽰例安装pip install websocket-client先来看⼀下，长连接调⽤⽅式：ws = websocket.WebSocketApp("ws:///",on_message = on_message,on_error = on_error,on_close = on_close)ws.on_open = on_openws.run_forever()长连接，参数介绍：（1）url: websocket的地址。

（2）header: 客户发送websocket握⼿请求的请求头，{'head1:value1','head2:value2'}。

（3）on_open：在建⽴Websocket握⼿时调⽤的可调⽤对象，这个⽅法只有⼀个参数，就是该类本⾝。

（4）on_message：这个对象在接收到服务器返回的消息时调⽤。

有两个参数，⼀个是该类本⾝，⼀个是我们从服务器获取的字符串（utf-8格式）。

（5）on_error：这个对象在遇到错误时调⽤，有两个参数，第⼀个是该类本⾝，第⼆个是异常对象。

（6）on_close：在遇到连接关闭的情况时调⽤，参数只有⼀个，就是该类本⾝。

（7）on_cont_message：这个对象在接收到连续帧数据时被调⽤，有三个参数，分别是：类本⾝，从服务器接受的字符串（utf-8），连续标志。

（8）on_data：当从服务器接收到消息时被调⽤，有四个参数，分别是：该类本⾝，接收到的字符串（utf-8），数据类型，连续标志。

（9）keep_running：⼀个⼆进制的标志位，如果为True，这个app的主循环将持续运⾏，默认值为True。

（10）get_mask_key：⽤于产⽣⼀个掩码。

（11）subprotocols：⼀组可⽤的⼦协议，默认为空。

长连接关键⽅法：ws.run_forever(ping_interval=60,ping_timeout=5)如果不断开关闭websocket连接，会⼀直阻塞下去。

python实现WebSocket服务端过程解析

python实现WebSocket服务端过程解析⼀种类似Flask开发的WebSocket-Server服务端框架，适⽤python3.X1、安装模块Pywsspip install pywss2、搭建简易服务器2.1 服务端代码代码简介route: 注册请求路径example_1(request, data):request: socket句柄，能够发送和接收数据接。

发送数据request.ws.send(data)，收数据request.ws_recv(1024)data: 客户端发送的数据存于此处from pywss import Pyws, route@route('/test/example/1')def example_1(request, data):return data + ' - data from pywss'if __name__ == '__main__':ws = Pyws(__name__, address='127.0.0.1', port=8866)ws.serve_forever()2.2 客户端代码客户端代码，建议直接在浏览器中运⾏，eg: Chorme打开新标签 -> F12 -> console代码简介WebSocket(ws_url): 发起协议升级为WebSocket连接请求，ws_url路径不要写错咯，要与服务端中的route()中注册路径对应起来ws.onmessage: 当有数据传递过来时，会执⾏此函数ws.onclose: 当连接断开时，会执⾏此函数ws.onopen: 当连接建⽴的时候，会执⾏此函数ws = new WebSocket("ws://127.0.0.1:8866/test/example/1");ws.onmessage = function (ev) {console.log(JSON.parse(ev.data));}ws.onclose = function (ev) {console.log('Connect Closed')}ws.onopen = function() {if (ws.readyState === WebSocket.OPEN) {ws.send('hello, pywss!') // you will get 'hello, pywss! - data from pywss'}}运⾏截图：服务端：客户端：如果觉得还不错，不妨give me start~⿎励下这个⼩码农QAQ以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

python3 websocket 的用法

python3 websocket 的用法在 Python 3 中使用 WebSocket 的方法可以大致分为两个部分：建立WebSocket 连接以及发送/接收数据。

建立 WebSocket 连接的方法是使用 WebSocket 类的 connect 方法，这个方法没有返回值。

一旦建立了连接，就可以使用 send 方法发送数据到服务器，以及使用 recv 方法从服务器接收数据。

此外，还有一个 close 方法可以用于关闭 WebSocket 连接。

在 WebSocket 类中，还可以使用一些其他的方法和参数来自定义连接，例如 get_mask_key 方法可以用于自定义 mask key 的生成函数，sockopt 参数可以用于设置 socket 的选项，sslopt 参数可以用于设置 SSL Socket 的选项等。

需要注意的是，接收和推送数据使用的包有区别，具体区别可以自行百度，此处省略。

以下是一个简单的 Python 3 WebSocket 客户端的示例代码：```pythonimport websocket创建一个 WebSocket 客户端对象ws = ()连接到 WebSocket 服务器("向服务器发送数据("Hello, server!")从服务器接收数据result = ()print("Received:", result)关闭 WebSocket 连接()```这个示例代码中，首先创建一个 WebSocket 客户端对象，然后使用connect 方法连接到 WebSocket 服务器。

接着使用 send 方法向服务器发送数据，然后使用 recv 方法从服务器接收数据。

最后使用 close 方法关闭WebSocket 连接。

python websockets用法

python websockets用法Websockets是一种在客户端和服务器之间进行实时双向通信的网络协议。

它基于HTTP协议，但提供了一种持久连接，允许服务器主动发送数据给客户端。

在Python中，我们可以使用第三方库websockets来实现Websockets的功能。

此库提供了一个高级别的API，使得编写Websockets应用程序变得非常简单。

本文将介绍Python Websockets的用法，并提供一些示例代码。

1. 安装使用pip命令安装websockets库：```pip install websockets```2. 连接到Websockets服务器首先，我们需要连接到一个Websockets服务器。

使用async关键字定义一个异步函数，并使用websockets库的connect函数建立连接。

连接函数需要传递一个URL作为参数，这个URL指定了服务器的地址和端口。

我们还可以设置其他的可选参数，比如超时时间和子协议。

下面是一个连接到Websockets服务器的简单示例：```pythonimport asyncioimport websocketsasync def connect():async with websockets.connect('ws://') as websocket:# 在这里编写与服务器通信的代码passasyncio.run(connect())```3. 发送和接收消息在连接成功后，我们可以使用send和recv函数来发送和接收消息。

使用send发送消息时，我们需要将消息作为字符串传递给函数。

函数将自动将消息转换为Websockets协议所需的格式。

使用recv接收消息时，函数将阻塞，直到接收到消息。

接收到的消息也是以字符串的形式返回。

下面是一个简单的例子，演示了如何发送和接收消息：```pythonimport asyncioimport websocketsasync def connect():async with websockets.connect('ws://') as websocket:# 发送消息await websocket.send('Hello, server!')# 接收消息message = await websocket.recv()print('Received message:', message)asyncio.run(connect())```4. 处理异常和关闭连接在使用Websockets时，我们应该处理可能出现的异常，并正确地关闭连接。

python websockets 用法

Python Websockets 是一个使用 Python 语言实现的 WebSocket 客户端和服务器端的库，它可以方便地实现 WebSocket 协议的通信，并且可以与其他 Python web 框架（如 Django、Flask 等）无缝集成。

本文将介绍 Python Websockets 的基本用法，包括安装、简单客户端和服务器的实现，以及与其他框架的集成。

一、安装 Python Websockets1. 使用 pip 安装在命令行中执行以下命令来安装 Python Websockets：```bashpip install websockets```二、实现简单的 WebSocket 服务器1. 导入相关模块在 Python 中实现一个简单的 WebSocket 服务器首先需要导入相应的模块：```pythonimport asyncioimport websockets```2. 编写服务器端代码接下来编写一个简单的 WebSocket 服务器端代码，监听客户端的连接，并在收到消息时进行回复：```pythonasync def server(websocket, path):while True:message = await websocket.recv()print(f"Received message: {message}")await websocket.send(f"Received message: {message}") ```3. 启动服务器使用 asyncio 库来启动服务器，并监听指定的端口：```pythonstart_server = websockets.serve(server, "localhost", 8765)asyncio.get_event_loop().run_untilplete(start_server) asyncio.get_event_loop().run_forever()```三、实现简单的 WebSocket 客户端1. 导入相关模块在 Python 中实现一个简单的 WebSocket 客户端首先需要导入相应的模块：```pythonimport asyncioimport websockets```2. 编写客户端代码接下来编写一个简单的 WebSocket 客户端代码，连接到指定的服务器，并发送消息给服务器：```pythonasync def client():async with websockets.connect("ws://localhost:8765") as websocket:await websocket.send("Hello, WebSocket Server!")response = await websocket.recv()print(f"Received response: {response}")asyncio.get_event_loop().run_untilplete(client())```四、与其他框架的集成Python Websockets 可以与其他 Python web 框架（如 Django、Flask 等）无缝集成，以下是与 Flask 框架的集成示例代码：```pythonfrom flask import Flaskimport asyncioimport websocketsapp = Flask(__name__)@app.route('/')def index():return 'Hello, WebSocket Client!'async def client(websocket):await websocket.send("Hello, WebSocket Server!") response = await websocket.recv()print(f"Received response: {response}")@app.route('/websocket')def websocket_route():asyncio.get_event_loop().run_untilplete(websockets.connect("ws://localhost:8765"))return 'WebSocket Connected!'if __name__ == '__main__':app.run()```以上就是 Python Websockets 的基本用法介绍，通过本文的学习，读者可以掌握 Python Websockets 的安装、简单服务器和客户端的实现，以及与其他框架的集成。

python中websocket实例的方法

python中websocket实例的方法WebSocket是一种在单个TCP连接上进行全双工通信的协议，它为现代Web应用程序提供了实时数据交换。

Python中提供了许多WebSocket实例的库和框架。

在本文中，我们将介绍如何使用Python中的websocket实例库和框架。

WebSocket实例主要由一些函数和类组成，用于建立WebSocket连接和处理WebSocket 消息。

以下是WebSocket实例提供的一些主要函数和类的详细介绍：1. websocket.WebSocketAppa. on_open: 当WebSocket连接建立时调用此方法。

您可以在此方法中设置自己的处理程序以处理WebSocket连接开启事件。

以下是使用WebSocketApp类的示例：```import websocketdef on_message(ws, message):print(message)websocket.WebSocket是websocket库中的另一个主要类。

它用于具有更低级别访问WebSocket的应用程序。

WebSocket类提供了一个send()方法，用于向WebSocket发送消息。

此外，WebSocket类还包括多个事件处理程序方法，例如on_open，on_close，on_message和on_error。

这些方法的用法与WebSocketApp类中的on_open，on_close，on_message和on_error方法类似。

```import tornado.ioloopimport tornado.webimport tornado.websocketclass EchoWebSocket(tornado.websocket.WebSocketHandler):def open(self):print("WebSocket opened")4. Django ChannelsDjango Channels是Django框架的一个扩展，它允许Django支持WebSocket和其他协议的实时通信。

Python中的WebSocket

Python中的WebSocketWebSocket是一种应用层协议，建立在HTTP协议之上，提供了全双工通信的能力，可以在Web浏览器和Web服务器之间实现实时数据的传输。

本文将重点介绍WebSocket的基本原理、实现过程、应用场景和未来发展趋势。

一、原理与实现WebSocket协议可以归纳为以下几个步骤：1.客户端与服务端建立连接：客户端通过HTTP协议发送一个Upgrade请求给服务端，请求升级到WebSocket协议。

2.服务端响应：服务端收到Upgrade请求后，判断客户端是否符合升级协议的要求，并返回101 Switching Protocols响应。

3.数据传输：客户端和服务端之间建立双向通信的数据传输通道，可以实现实时的数据传输。

客户端和服务端均可以发送和接收数据，实现全双工通信。

WebSocket的实现过程可以分为以下几个步骤：1.握手：客户端通过HTTP请求向服务端发起握手请求，将WebSocket协议升级请求信息发送给服务端。

2.响应：服务端接收到客户端的握手请求后，进行校验，返回101 Switching Protocols响应。

3.数据传输：客户端和服务端之间建立双向通信的数据传输通道，进行实时的数据传输。

二、应用场景1.实时通讯：WebSocket协议可以通过浏览器实现实时通讯，如在线聊天室、实时游戏等。

2.实时数据展示：通过WebSocket可以实现实时数据的展示，如实时股票行情、实时天气数据等。

3.远程控制：WebSocket可以实现远程控制，如终端控制、远程桌面等。

三、未来发展趋势1.安全升级：WebSocket协议通信使用的是明文传输，对于网络安全来说存在较大的风险。

因此，未来的WebSocket协议可能会通过加密的方式来保障安全性。

2.技术便捷性：WebSocket目前的应用还局限在浏览器端，未来可能会在不同的运行环境中得到应用，如移动端、桌面端、物联网等。

Python中的Websocket编程

Python中的Websocket编程随着互联网技术的发展，网络协议与应用场景的不断延伸，Websocket协议作为一种双向通信协议被广泛运用于实时通信和数据传输。

本文将从Websocket协议的概念、应用场景、技术实现和安全策略等方面进行探讨。

一、Websocket协议概述Websocket(下文简称WS)是一种全双工、长连接、双向通信协议，也是一种应用层协议。

WS协议的特点是与HTTP协议兼容，采用握手阶段和数据传输阶段两个阶段。

在协议握手阶段，客户端向服务器发送HTTP请求并带上特定的协议头，表明自己要升级到WS协议。

服务器收到请求后，进行协议头校验和升级操作，如果通过校验，返回101协议响应，并说明服务器端已经支持WS协议，可以进行数据传输。

在数据传输阶段，客户端与服务器端之间可以互相发送数据，WS 协议不对数据的格式和内容进行限制，数据传输方式也可以分为文本和二进制两种。

WS协议的双向通信特性使得它非常适合于实时数据传输场景，比如在线聊天、实时游戏、股票交易、在线视频会议等，这些应用需要与传统的HTTP协议不同的长连接方式来建立与服务器的通信，以实现即时响应和实时更新数据的效果。

二、Websocket的应用场景Websocket协议广泛应用于Web和移动应用领域，可以在以下场景中体现其优越性：1.实时通信WS协议可以实现双向通信，以实现实时聊天、即时状态更新、在线游戏等应用场景。

这些应用要求消息延迟较低，响应速度快，WS协议的长连接机制以及数据传输方式均可以优化数据传输效率，使得实时通信更加流畅和实时。

2.实时数据传输WS协议可以传输二进制和文本两种数据类型，能够承载实时视频、音频、图像等大量数据的即时传输，以及金融数据、股票交易等敏感数据的传输，在这些场景中，WS协议可以保证数据的即时性和完整性，提高用户体验和数据传输的效率。

3.移动应用WS协议对于移动应用也非常友好。

移动设备网络信号不稳定，网络连接容易断开，基于HTTP的传统架构不适合进行较长时间的通信。

websocketrunclient 传参数

websocketrunclient 传参数我不确定你指的是哪个编程语言的`websocket`客户端，推测你可能想了解`WebSocket`客户端如何传参。

`WebSocket`是一种在单个`TCP`连接上进行全双工通信的协议，它允许服务器和客户端之间实时交换消息。

以下是 JavaScript 和 Python 语言实现`WebSocket`客户端传参的示例：- JavaScript：```javascriptvar token=' dcvuahsdnfajw12kjfasfsdf34'// 发送参数send发送参数var ws = new WebSocket(" ws://" + url + " /webSocketServer" );ws.onopen=function(){ws.send(token)}```- Python：```pythonimport sslimport websocketimport _thread as threadclass WebsocketClient(object):"""docstring for WebsocketClient"""def __init__(self, address, send_message):super(WebsocketClient, self).__init__()self.address = addressself.send_message = send_messageself.recv = Nonedef on_message(self, ws, message):self.recv = messageprint("on_client_message:", self.recv)def on_error(self, ws, error):print("# error:", error)def on_close(self, ws):print("# closed #")def on_open(self, ws):print("on open")def run(*args):self.ws.send(self.send_message)print(self.send_message)# self.ws.close()thread.start_new_thread(run,())def get_message(self):return self.recvdef run():websocket.enableTrace(False)self.ws = websocket.WebSocketApp(self.address, on_message=self.on_message, on_error=self.on_error, on_close=self.on_close) self.ws.on_open = self.on_openself.ws.run_forever(sslopt={"cert_reqs": ssl.CERT_NONE})if __name__ == '__main__':ws_client = WebsocketClient("ws://121.40.165.18:8800",'hello')ws_client.run()print(ws_client.get_message())```无论外部向内部传参，还是内部向外部传参，都可以直接调用`send`方法发送参数。

ws4py 用法 -回复

ws4py 用法-回复ws4py是一个Python库，它提供了一种简单而强大的方法来实现WebSocket通信。

WebSocket是一种在客户端和服务器之间进行双向通信的网络协议。

由于它可以实时发送数据并且不需要频繁的HTTP请求，WebSocket在实时应用程序和即时通信中具有很大的优势。

在本文中，我们将详细介绍ws4py的用法，讨论如何安装和初始化库，如何建立WebSocket连接以及如何发送和接收消息。

第一步：安装ws4py在开始使用ws4py之前，首先需要安装该库。

可以通过使用pip包管理器运行以下命令来安装ws4py：pip install ws4py这将自动下载并安装最新版本的ws4py库。

第二步：初始化WebSocket连接在开始使用ws4py库之前，我们需要导入WebSocket类。

可以通过以下代码行来实现：from ws4py.client.threadedclient import WebSocketClient接下来，我们可以创建一个自定义的WebSocket客户端类，继承自WebSocketClient类。

在此类中，我们可以定义on_open、on_message、on_close和其他WebSocket事件处理方法。

下面是一个简单示例，展示了如何创建一个WebSocket客户端类：class MyWebSocketClient(WebSocketClient):def opened(self):print("WebSocket连接已建立")def closed(self, code, reason=None):print("WebSocket连接已关闭")def received_message(self, message):print("收到消息：", message)第三步：建立连接在我们创建了WebSocket客户端类之后，可以使用ws4py库的connect()方法来建立WebSocket连接。

ws4py 用法

ws4py 用法ws4py是python的一个websocket的第三方库，支持Python2.7+ 和 Python3.3+。

它的用法如下：```pythonfrom ws4py.websocket import WebSocket# WebSocket类应该由您的应用程序进行子类化class EchoWebSocket(WebSocket):def received_message(self, message):self.send(message.data, message.is_binary)# 示例代码from ws4py.messaging import TextMessagedef data_source():yield TextMessage(u'hello world')from mock import MagicMocksource = MagicMock(side_effect=data_source)ws = EchoWebSocket(sock=source)ws.send(u'hello there')```在上述代码中，我们首先导入了`WebSocket`类，并创建了一个子类`EchoWebSocket`。

然后，我们实现了一个数据源函数`data_source()`，用于生成测试消息。

接下来，我们使用`MagicMock`创建了一个假的数据源对象，并将其传递给`EchoWebSocket`的构造函数。

最后，我们使用`ws.send()`方法发送一条消息。

ws4py提供了一个高级但简单的界面，为应用程序提供WebSocket支持，如果你想了解更多关于ws4py的信息，可以查看它的官方文档。

python之websocket

python之websocket⼀、websocketWebSocket协议是基于TCP的⼀种新的协议。

WebSocket最初在HTML5规范中被引⽤为TCP连接，作为基于TCP的套接字API的占位符。

它实现了浏览器与服务器全双⼯(full-duplex)通信。

其本质是保持TCP连接，在浏览器和服务端通过Socket进⾏通信。

本⽂将使⽤Python编写Socket服务端，⼀步⼀步分析请求过程1. 启动服务端import socketsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)sock.bind(('127.0.0.1', 8002))sock.listen(5)# 等待⽤户连接conn, address = sock.accept().........启动Socket服务器后，等待⽤户【连接】，然后进⾏收发数据。

2. 客户端连接<script type="text/javascript">var socket = new WebSocket("ws://127.0.0.1:8002/xxoo");...</script>当客户端向服务端发送连接请求时，不仅连接还会发送【握⼿】信息，并等待服务端响应，⾄此连接才创建成功！3. 建⽴连接【握⼿】import socketsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)sock.bind(('127.0.0.1', 8002))sock.listen(5)# 获取客户端socket对象conn, address = sock.accept()# 获取客户端的【握⼿】信息data = conn.recv(1024).........conn.send('响应【握⼿】信息')请求和响应的【握⼿】信息需要遵循规则：从请求【握⼿】信息中提取 Sec-WebSocket-Key利⽤magic_string 和 Sec-WebSocket-Key 进⾏hmac1加密，再进⾏base64加密将加密结果响应给客户端注：magic string为：258EAFA5-E914-47DA-95CA-C5AB0DC85B11请求【握⼿】信息为：GET /chatsocket HTTP/1.1Host: 127.0.0.1:8002Connection: UpgradePragma: no-cacheCache-Control: no-cacheUpgrade: websocketOrigin: http://localhost:63342Sec-WebSocket-Version: 13Sec-WebSocket-Key: mnwFxiOlctXFN/DeMt1Amg==Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits......提取Sec-WebSocket-Key值并加密：import socketimport base64import hashlibdef get_headers(data):"""将请求头格式化成字典:param data::return:"""header_dict = {}data = str(data, encoding='utf-8')for i in data.split('\r\n'):print(i)header, body = data.split('\r\n\r\n', 1)header_list = header.split('\r\n')for i in range(0, len(header_list)):if i == 0:if len(header_list[i].split('')) == 3:header_dict['method'], header_dict['url'], header_dict['protocol'] = header_list[i].split('')else:k, v = header_list[i].split(':', 1)header_dict[k] = v.strip()return header_dictsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)sock.bind(('127.0.0.1', 8002))sock.listen(5)conn, address = sock.accept()data = conn.recv(1024)headers = get_headers(data) # 提取请求头信息# 对请求头中的sec-websocket-key进⾏加密response_tpl = "HTTP/1.1 101 Switching Protocols\r\n" \"Upgrade:websocket\r\n" \"Connection: Upgrade\r\n" \"Sec-WebSocket-Accept: %s\r\n" \"WebSocket-Location: ws://%s%s\r\n\r\n"magic_string = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'value = headers['Sec-WebSocket-Key'] + magic_stringac = base64.b64encode(hashlib.sha1(value.encode('utf-8')).digest())response_str = response_tpl % (ac.decode('utf-8'), headers['Host'], headers['url'])# 响应【握⼿】信息conn.send(bytes(response_str, encoding='utf-8')).........View Code4.客户端和服务端收发数据客户端和服务端传输数据时，需要对数据进⾏【封包】和【解包】。

python实现的websocket总结——wspy

python实现的websocket总结——wspy之前曾有php版的websocket封装包。

见，近期使⽤python做⼀些功能，须要⽤到对websocket的操作，因此，參照之前的实现，实现了这个python版本号。

源代码见。

总体实现起来，须要在建⽴socket监听port。

这须要⽤到socket标准库模块。

之后。

须要对对⽹络字节流进⾏操作，这个⽅⾯python有struct 标准库模块。

这个很好⽤；另外涉及到加密解密操作，还有hashlib模块和sha模块等使⽤。

特别在此总结⼀下。

⽬的主要是1 备忘2. 总结与思考1 socket 操作1 本地Socket建⽴建⽴TCPserver的⼀般流程：sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)sock.bind((addr,port))sock.listen(10)建⽴好本地socket，并绑定地址与port进⾏监听。

2 并发连接策略之后，须要使⽤不同的策略处理多个client连接的问题，最普通的处理⽅式就是直接使⽤accept堵塞，这样server端每次仅仅能处理⼀个client连接。

然后python标准库提供了select模块，⾥⾯有select、poll和epoll这些不同的并发连接的处理策略。

当中poll和epoll仅仅能在linux下使⽤，并且epoll在linux 2.6之后的版本号才⼲使⽤。

当然并发处理效果来看。

epoll⽐poll性能更好。

poll⽐select性能更优。

可是select确能够在多种平台下使⽤，为了兼容Windows系统。

本次实现中使⽤的是select策略，详细例如以下：... #接上述socket建⽴代码while True:rs, ws, es = select.select([sock], [], [])for r in rs:if r is sock: #r 是server端socketcliSock,addr = r.accept()r.connect(cliSock) #建⽴于client连接else:try:data = r.recv(bufferLen)... #处理client连接发送的数据...poll⽅法也是select模块内的⽅法。

python websocket 详解

WebSocket是一种在单个TCP连接上进行全双工通信的协议，它允许客户端和服务器之间进行实时数据传输。

在Python中，可以使用第三方库来实现WebSocket通信，最常用的库是`websockets`。

下面是一个简单的Python WebSocket示例，使用`websockets`库来创建一个简单的WebSocket 服务器和客户端：WebSocket服务器代码：import asyncioimport websocketsasync def echo(websocket, path):async for message in websocket:await websocket.send(message)start_server = websockets.serve(echo, "localhost", 8765)asyncio.get_event_loop().run_until_complete(start_server)asyncio.get_event_loop().run_forever()WebSocket客户端代码：import asyncioimport websocketsasync def hello():async with websockets.connect('ws://localhost:8765') as websocket:await websocket.send("Hello, WebSocket!")response = await websocket.recv()print(response)asyncio.get_event_loop().run_until_complete(hello())在这个示例中，我们使用`websockets`库创建了一个简单的WebSocket服务器和客户端。

服务器使用`websockets.serve`函数创建一个WebSocket服务器，并在`echo`函数中实现了简单的回声功能，即将接收到的消息原样发送回去。

用Python实现一个简单的WebSocket服务器

ubuntu下python2.76windows Python 2.79, chrome37 firefox35通过代码是在基础上改的, 主要改动了parsedata和sendmessage这2个函数.改代码参考下面了这段文档. 主要是第5条, 发送的数据长度分别是8bit和16bit和64 bit(即127, 65535,和2^64-1)三种情况发送和收取是一样的, 例如1.长度小于125时(由于使用126, 127用作标志位.)2. 数据长度在128-65525之间时, Payload Length位设为126, 后面额外使用16bit表示长度(前面的126不再是长度的一部分)3.数据长度在65526-2^64-1之间时, Payload Length位设为127, 后面额外使用64bit表示长度(前面的127不再是长度的一部分)1.Fin (bit 0): determines if this is the last frame in the message. This would beset to 1 on the end of a series of frames, or in a single-frame message, it would be set to 1 as it is both the first and last frame.2.RSV1, RSV2, RSV3 (bits 1-3): these three bits are reserved for websocketextensions, and should be 0 unless a specific extension requires the use of any of these bytes.3.Opcode (bits 4-7): these four bits deterimine the type of the frame. Controlframes communicate WebSocket state, while non-control framescommunicate data. The various types of codes include:1.x0: continuation frame; this frame contains data that should be appended tothe previous frame2.x1: text frame; this frame (and any following) contains text3.x2: binary frame; this frame (and any following) contains binary data4.x3 - x7: non-control reserved frames; these are reserved for possiblewebsocket extensions5.x8: close frame; this frame should end the connection6.x9: ping frame7.xA: pong frame8.xB - xF: control reserved frames4.Mask (bit 8): this bit determines whether this specific frame uses a mask ornot.5.Payload Length (bits 9-15, or 16-31, or 16-79): these seven bytes determine thepayload length. If the length is 126, the length is actually determined by bits 16 through 31 (that is, the following two bytes). If the length is 127, the length is actually determined by bits 16 through 79 (that is, the following eight bytes).6.Masking Key (the following four bytes): this represents the mask, if the Maskbit is set to 1.7.Payload Data (the following data): finally, the data. The payload data may besent over multiple frames; we know the size of the entire message by thepayload length that was sent, and can append data together to form a single message until we receive the message with the Fin flag. Each consecutivepayload, if i t exists, will contain the 0 “continuation frame” opcode.服务器[python]view plain copy1.#coding=utf82.#!/usr/bin/python3.4.5.import struct,socket6.import hashlib7.import threading,random8.import time9.import struct10.from base64 import b64encode, b64decode11.12.13.connectionlist = {}14.g_code_length = 015.g_header_length = 016.17.18.def hex2dec(string_num):19.return str(int(string_num.upper(), 16))21.22.23.24.def get_datalength(msg):25.global g_code_length26.global g_header_length27.28.print (len(msg))29. g_code_length = ord(msg[1]) & 12730. received_length = 0;31.if g_code_length == 126:32.#g_code_length = msg[2:4]33.#g_code_length = (ord(msg[2])<<8) + (ord(msg[3]))34. g_code_length = struct.unpack('>H', str(msg[2:4]))[0]35. g_header_length = 836.elif g_code_length == 127:37.#g_code_length = msg[2:10]38. g_code_length = struct.unpack('>Q', str(msg[2:10]))[0]39. g_header_length = 1440.else:41. g_header_length = 642. g_code_length = int(g_code_length)43.return g_code_length44.45.def parse_data(msg):46.global g_code_length47. g_code_length = ord(msg[1]) & 12748. received_length = 0;49.if g_code_length == 126:50. g_code_length = struct.unpack('>H', str(msg[2:4]))[0]51. masks = msg[4:8]52. data = msg[8:]53.elif g_code_length == 127:54. g_code_length = struct.unpack('>Q', str(msg[2:10]))[0]55. masks = msg[10:14]56. data = msg[14:]57.else:58. masks = msg[2:6]59. data = msg[6:]60.61.62. i = 063. raw_str = ''65.66.for d in data:67. raw_str += chr(ord(d) ^ ord(masks[i%4]))68. i += 169.70.71.print (u"总长度是：%d" % int(g_code_length))72.return raw_str73.74.75.def sendMessage(message):76.global connectionlist77.78. message_utf_8 = message.encode('utf-8')79.for connection in connectionlist.values():80. back_str = []81. back_str.append('\x81')82. data_length = len(message_utf_8)83.84.85.if data_length <= 125:86. back_str.append(chr(data_length))87.elif data_length <= 65535 :88. back_str.append(struct.pack('b', 126))89. back_str.append(struct.pack('>h', data_length))90.#back_str.append(chr(data_length >> 8))91.#back_str.append(chr(data_length & 0xFF))92.#a = struct.pack('>h', data_length)93.#b = chr(data_length >> 8)94.#c = chr(data_length & 0xFF)95.elif data_length <= (2^64-1):96.#back_str.append(chr(127))97. back_str.append(struct.pack('b', 127))98. back_str.append(struct.pack('>q', data_length))99.#back_str.append(chr(data_length >> 8))100.#back_str.append(chr(data_length & 0xFF))101.else :102.print (u'太长了')103. msg = ''104.for c in back_str:105. msg += c;106. back_str = str(msg) + message_utf_8#.encode('utf-8')107.#connection.send(str.encode(str(u"\x00%s\xFF\n\n" % message))) #这个是旧版108.#print (u'send message:' + message)109.if back_str != None and len(back_str) > 0:110.print (back_str)111. connection.send(back_str)112.113.114.def deleteconnection(item):115.global connectionlist116.del connectionlist['connection'+item]117.118.119.class WebSocket(threading.Thread):#继承Thread120.121.122. GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"123.124.125.def __init__(self,conn,index,name,remote, path="/"):126. threading.Thread.__init__(self)#初始化父类Thread127. self.conn = conn128. self.index = index129. = name130. self.remote = remote131. self.path = path132. self.buffer = ""133. self.buffer_utf8 = ""134. self.length_buffer = 0135.def run(self):#重载Thread的run136.print('Socket%s Start!' % self.index)137. headers = {}138. self.handshaken = False139.140.141.while True:142.if self.handshaken == False:143.print ('Socket%s Start Handshaken with %s!' % (self.index,s elf.remote))144. self.buffer += bytes.decode(self.conn.recv(1024))145.146.147.if self.buffer.find('\r\n\r\n') != -1:148. header, data = self.buffer.split('\r\n\r\n', 1)149.for line in header.split("\r\n")[1:]:150. key, value = line.split(": ", 1)151. headers[key] = value152.153.154. headers["Location"] = ("ws://%s%s" %(headers["Host"], s elf.path))155. key = headers['Sec-WebSocket-Key']156. token = b64encode(hashlib.sha1(str.encode(str(key + self.GUID))).digest())157.158.159. handshake="HTTP/1.1 101 Switching Protocols\r\n"\ 160."Upgrade: websocket\r\n"\161."Connection: Upgrade\r\n"\162."Sec-WebSocket-Accept: "+bytes.decode(token)+"\r\n"\163."WebSocket-Origin: "+str(headers["Origin"])+"\r\n"\164."WebSocket-Location: "+str(headers["Location"])+"\r \n\r\n"165.166.167. self.conn.send(str.encode(str(handshake)))168. self.handshaken = True169.print ('Socket %s Handshaken with %s success!' %(self.i ndex, self.remote))170. sendMessage(u'Welcome, ' + + ' !')171. self.buffer_utf8 = ""172. g_code_length = 0173.174.175.else:176.global g_code_length177.global g_header_length178. mm=self.conn.recv(128)179.if len(mm) <= 0:180.continue181.if g_code_length == 0:182. get_datalength(mm)183.#接受的长度184. self.length_buffer = self.length_buffer + len(mm)185. self.buffer = self.buffer + mm186.if self.length_buffer - g_header_length < g_code_length :187.continue188.else :189. self.buffer_utf8 = parse_data(self.buffer) #utf8190. msg_unicode = str(self.buffer_utf8).decode('utf-8', 'ig nore') #unicode191.if msg_unicode=='quit':192.print (u'Socket%s Logout!' % (self.index))193. nowTime = time.strftime('%H:%M:%S',time.localtime(t ime.time()))194. sendMessage(u'%s %s say: %s' % (nowTime, self.remot e, +' Logout'))195. deleteconnection(str(self.index))196. self.conn.close()197.break#退出线程198.else:199.#print (u'Socket%s Got msg:%s from %s!' % (self.ind ex, msg_unicode, self.remote))200. nowTime = time.strftime(u'%H:%M:%S',time.localtime( time.time()))201. sendMessage(u'%s %s say: %s' % (nowTime, self.remot e, msg_unicode))202.#重置buffer和bufferlength203. self.buffer_utf8 = ""204. self.buffer = ""205. g_code_length = 0206. self.length_buffer = 0207. self.buffer = ""208.209.210.class WebSocketServer(object):211.def __init__(self):212. self.socket = None213.def begin(self):214.print( 'WebSocketServer Start!')215. self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 216. self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) 217. self.socket.bind(("127.0.0.1",12345))218. self.socket.listen(50)219.220.221.global connectionlist222.223.225.while True:226. connection, address = self.socket.accept()227.228.229. username=address[0]230. newSocket = WebSocket(connection,i,username,address) 231. newSocket.start() #开始线程,执行run函数232. connectionlist['connection'+str(i)]=connection233. i = i + 1234.235.236.if __name__ == "__main__":237. server = WebSocketServer()238. server.begin()客户端测试了chrome37, firefox35[html]view plain copy1.<!DOCTYPE html>2.<html>3.<head>4.<title>WebSocket</title>5.6.<style>7. html, body {8. font: normal 0.9em arial, helvetica;9. }10.11. #log {12. width: 440px;13. height: 200px;14. border: 1px solid #7F9DB9;15. overflow: auto;16. }17.18. #msg {19. width: 330px;20. }21.</style>22.24. var socket;25.26. function init() {27. var host = "ws://127.0.0.1:12345/";28. try {29.socket = new WebSocket(host);30.socket.onopen = function (msg) {31. log('Connected');32. };33.socket.onmessage = function (msg) {34. log(msg.data);35. };36.socket.onclose = function (msg) {37. log("Lose Connection!");38. };39. }40. catch (ex) {41. log(ex);42. }43. $("msg").focus();44. }45.46. function send() {47. var txt, msg;48.txt = $("msg");49.msg = txt.value;50. if (!msg) {51. alert("Message can not be empty");52. return;53. }54.txt.value = "";55. txt.focus();56. try {57. socket.send(msg);58. } catch (ex) {59. log(ex);60. }61. }62.63.window.onbeforeunload = function () {64. try {65. socket.send('quit');66. socket.close();67.socket = null;68. }69. catch (ex) {70. log(ex);71. }72. };73.74.75. function $(id) {76. return document.getElementById(id);77. }78. function log(msg) {79. $("log").innerHTML += "<br>" + msg;80. }81. function onkey(event) {82. if (event.keyCode == 13) {83. send();84. }85. }86.</script>87.88.</head>89.90.91.<body onload="init()">92.<h3>WebSocket</h3>93.<br><br>94.95.<div id="log"></div>96.<input id="msg"type="textbox"onkeypress="onkey(event)"/>97.<button onclick="send()">发送</button>98.</body>99.100.</html>。

python websocket实例

Python WebSocket是一种在Web应用程序中实现实时通信的技术。

使用WebSocket，Web应用程序可以通过在客户端和服务器之间建立持久的连接来实时地交换数据。

在Python中，可以使用标准库中的websocket模块来实现WebSocket客户端和服务器端的功能。

以下是一个简单的Python WebSocket客户端的示例代码：pythonimport websocketdef on_open(ws):print("Opened")ws.send("Hello, Server")def on_close(ws):print("Closed")def on_message(ws, message):print("Received: %s" % message)if __name__ == "__main__":websocket.enableTrace(True)ws = websocket.WebSocketApp("ws://localhost:8080/",on_open=on_open,on_close=on_close,on_message=on_message)ws.run_forever()在上面的代码中，我们使用websocket模块中的WebSocketApp类创建一个WebSocket客户端。

我们指定了WebSocket服务器的URL，以及三个回调函数：on_open，on_close和on_message。

当WebSocket连接打开时，on_open函数将被调用，我们在这里发送一条消息到服务器。

当WebSocket连接关闭时，on_close 函数将被调用。

当从服务器接收到消息时，on_message函数将被调用。

以上是一个简单的示例，你可以根据你的需要自定义回调函数和发送的消息。

python websockets.connect的headers写法

python websockets.connect的headers写法使用Python的websockets库进行WebSocket连接时，可以通过headers 参数设置HTTP请求的头部信息。

headers参数应该是一个字典类型，其中包含要发送的头部字段和对应的值。

以下是示例代码，展示了如何使用headers参数进行WebSocket连接：import asyncioimport websocketsasync def connect():headers = {'Authorization': 'Bearer token123','User-Agent': 'MyWebSocketClient/1.0','Custom-Header': 'CustomValue'}async with websockets.connect('wss://网址/ws', extra_headers=headers) as websocket:# 连接成功后的处理逻辑await websocket.send('Hello, Server!')response = await websocket.recv()print(response)asyncio.run(connect())在上述代码中，我们通过headers变量定义了一个字典，其中包含了需要添加到HTTP头部的字段和对应的值。

然后，我们通过将headers传递给extra_headers参数，将这些头部信息发送到服务器。

需要注意的是，具体要发送哪些头部信息以及头部字段的名称和值应该根据实际需求和服务器要求进行设置。

上述示例中的头部字段（如Authorization、User-Agent和Custom-Header）仅作为示例，需要根据实际情况进行相应的修改。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

ubuntu下python2.76windows Python 2.79, chrome37 firefox35通过代码是在别人(cddn有人提问)基础上改的, 主要改动了parsedata和sendmessage这2个函数.改代码参考下面了这段文档. 主要是第5条, 发送的数据长度分别是8bit和16bit和64 bit(即127, 65535,和2^64-1)三种情况发送和收取是一样的, 例如1.长度小于125时(由于使用126, 127用作标志位.)2. 数据长度在128-65525之间时, Payload Length位设为126, 后面额外使用16bit表示长度(前面的126不再是长度的一部分)3.数据长度在65526-2^64-1之间时, Payload Length位设为127, 后面额外使用64bit表示长度(前面的127不再是长度的一部分)1.Fin (bit 0): determines if this is the last frame in the message. Thiswould be set to 1 on the end of a series of frames, or in a single-frame message, it would be set to 1 as it is both the first and last frame.2.RSV1, RSV2, RSV3 (bits 1-3): these three bits are reserved forwebsocket extensions, and should be 0 unless a specific extension requires the use of any of these bytes.3.Opcode (bits 4-7): these four bits deterimine the type of the frame. Control frames communicate WebSocket state, while non-control frames communicate data. The various types of codes include:4.1.x0: continuation frame; this frame contains data that should beappended to the previous frame2.x1: text frame; this frame (and any following) contains text3.x2: binary frame; this frame (and any following) contains binarydata4.x3 - x7: non-control reserved frames; these are reserved forpossible websocket extensions5.x8: close frame; this frame should end the connection6.x9: ping frame7.xA: pong frame8.xB - xF: control reserved frames5.Mask (bit 8): this bit determines whether this specific frame uses amask or not.6.Payload Length (bits 9-15, or 16-31, or 16-79): these seven bytesdetermine the payload length. If the length is 126, the length is actuallydetermined by bits 16 through 31 (that is, the following two bytes). If the length is 127, the length is actually determined by bits 16 through 79 (that is, thefollowing eight bytes).7.Masking Key (the following four bytes): this represents the mask, if theMask bit is set to 1.8.Payload Data (the following data): finally, the data. The payload datamay be sent over multiple frames; we know the size of the entire message by the payload length that was sent, and can append data together to form a single message until we receive the message with the Fin flag. Each consecutivepayload, if it exists, will contain the 0 “continuation frame” opcode.服务器[python]view plain copy1.#coding=utf82.#!/usr/bin/python3.4.5.import struct,socket6.import hashlib7.import threading,random8.import time9.import struct10.from base64 import b64encode, b64decode11.12.13.connectionlist = {}14.g_code_length = 015.g_header_length = 016.17.18.def hex2dec(string_num):19.return str(int(string_num.upper(), 16))20.21.22.23.24.def get_datalength(msg):25.global g_code_length26.global g_header_length27.28.print (len(msg))29. g_code_length = ord(msg[1]) & 12730. received_length = 0;31.if g_code_length == 126:32.#g_code_length = msg[2:4]33.#g_code_length = (ord(msg[2])<<8) + (ord(msg[3]))34. g_code_length = struct.unpack('>H', str(msg[2:4]))[0]35. g_header_length = 836.elif g_code_length == 127:37.#g_code_length = msg[2:10]38. g_code_length = struct.unpack('>Q', str(msg[2:10]))[0]39. g_header_length = 1440.else:41. g_header_length = 642. g_code_length = int(g_code_length)43.return g_code_length44.45.def parse_data(msg):46.global g_code_length47. g_code_length = ord(msg[1]) & 12748. received_length = 0;49.if g_code_length == 126:50. g_code_length = struct.unpack('>H', str(msg[2:4]))[0]51. masks = msg[4:8]52. data = msg[8:]53.elif g_code_length == 127:54. g_code_length = struct.unpack('>Q', str(msg[2:10]))[0]55. masks = msg[10:14]56. data = msg[14:]57.else:58. masks = msg[2:6]59. data = msg[6:]60.61.62. i = 063. raw_str = ''64.65.66.for d in data:67. raw_str += chr(ord(d) ^ ord(masks[i%4]))68. i += 169.70.71.print (u"总长度是：%d" % int(g_code_length))72.return raw_str73.74.75.def sendMessage(message):76.global connectionlist77.78. message_utf_8 = message.encode('utf-8')79.for connection in connectionlist.values():80. back_str = []81. back_str.append('\x81')82. data_length = len(message_utf_8)83.84.85.if data_length <= 125:86. back_str.append(chr(data_length))87.elif data_length <= 65535 :88. back_str.append(struct.pack('b', 126))89. back_str.append(struct.pack('>h', data_length))90.#back_str.append(chr(data_length >> 8))91.#back_str.append(chr(data_length & 0xFF))92.#a = struct.pack('>h', data_length)93.#b = chr(data_length >> 8)94.#c = chr(data_length & 0xFF)95.elif data_length <= (2^64-1):96.#back_str.append(chr(127))97. back_str.append(struct.pack('b', 127))98. back_str.append(struct.pack('>q', data_length))99.#back_str.append(chr(data_length >> 8))100.#back_str.append(chr(data_length & 0xFF))101.else :102.print (u'太长了')103. msg = ''104.for c in back_str:105. msg += c;106. back_str = str(msg) + message_utf_8#.encode('utf-8') 107.#connection.send(str.encode(str(u"\x00%s\xFF\n\n" % message))) #这个是旧版108.#print (u'send message:' + message)109.if back_str != None and len(back_str) > 0:110.print (back_str)111. connection.send(back_str)112.113.114.def deleteconnection(item):115.global connectionlist116.del connectionlist['connection'+item]117.118.119.class WebSocket(threading.Thread):#继承Thread120.121.122. GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"123.124.125.def __init__(self,conn,index,name,remote, path="/"):126. threading.Thread.__init__(self)#初始化父类Thread127. self.conn = conn128. self.index = index129. = name130. self.remote = remote131. self.path = path132. self.buffer = ""133. self.buffer_utf8 = ""134. self.length_buffer = 0135.def run(self):#重载Thread的run136.print('Socket%s Start!' % self.index)137. headers = {}138. self.handshaken = False139.140.141.while True:142.if self.handshaken == False:143.print ('Socket%s Start Handshaken with %s!' % (self.index,self.remote))144. self.buffer += bytes.decode(self.conn.recv(1024))145.146.147.if self.buffer.find('\r\n\r\n') != -1:148. header, data = self.buffer.split('\r\n\r\n', 1) 149.for line in header.split("\r\n")[1:]:150. key, value = line.split(": ", 1)151. headers[key] = value152.153.154. headers["Location"] = ("ws://%s%s" %(headers["Host"], s elf.path))155. key = headers['Sec-WebSocket-Key']156. token = b64encode(hashlib.sha1(str.encode(str(key + self.GUID))).digest())157.158.159. handshake="HTTP/1.1 101 Switching Protocols\r\n"\ 160."Upgrade: websocket\r\n"\ 161."Connection: Upgrade\r\n"\162."Sec-WebSocket-Accept: "+bytes.decode(token)+"\r\n"\163."WebSocket-Origin: "+str(headers["Origin"])+"\r\n"\ 164."WebSocket-Location: "+str(headers["Location"])+"\r\n\r\n"165.166.167. self.conn.send(str.encode(str(handshake)))168. self.handshaken = True169.print ('Socket %s Handshaken with %s success!' %(self.i ndex, self.remote))170. sendMessage(u'Welcome, ' + + ' !') 171. self.buffer_utf8 = ""172. g_code_length = 0173.174.175.else:176.global g_code_length177.global g_header_length178. mm=self.conn.recv(128)179.if len(mm) <= 0:180.continue181.if g_code_length == 0:182. get_datalength(mm)183.#接受的长度184. self.length_buffer = self.length_buffer + len(mm)185. self.buffer = self.buffer + mm186.if self.length_buffer - g_header_length < g_code_length : 187.continue188.else :189. self.buffer_utf8 = parse_data(self.buffer) #utf8190. msg_unicode = str(self.buffer_utf8).decode('utf-8', 'ig nore') #unicode191.if msg_unicode=='quit':192.print (u'Socket%s Logout!' % (self.index)) 193. nowTime = time.strftime('%H:%M:%S',time.localtime(t ime.time()))194. sendMessage(u'%s %s say: %s' % (nowTime, self.remot e, +' Logout'))195. deleteconnection(str(self.index))196. self.conn.close()197.break#退出线程198.else:199.#print (u'Socket%s Got msg:%s from %s!' % (self.ind ex, msg_unicode, self.remote))200. nowTime = time.strftime(u'%H:%M:%S',time.localtime( time.time()))201. sendMessage(u'%s %s say: %s' % (nowTime, self.remot e, msg_unicode))202.#重置buffer和bufferlength203. self.buffer_utf8 = ""204. self.buffer = ""205. g_code_length = 0206. self.length_buffer = 0207. self.buffer = ""208.209.210.class WebSocketServer(object):211.def __init__(self):212. self.socket = None213.def begin(self):214.print( 'WebSocketServer Start!')215. self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 216. self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)217. self.socket.bind(("127.0.0.1",12345))218. self.socket.listen(50)219.220.221.global connectionlist222.223.224. i=0225.while True:226. connection, address = self.socket.accept()227.228.229. username=address[0]230. newSocket = WebSocket(connection,i,username,address) 231. newSocket.start() #开始线程,执行run函数232. connectionlist['connection'+str(i)]=connection233. i = i + 1234.235.236.if __name__ == "__main__":237. server = WebSocketServer()238. server.begin()客户端测试了chrome37, firefox35[html]view plain copy1.<!DOCTYPE html>2.<html>3.<head>4.<title>WebSocket</title>5.6.<style>7. html, body {8. font: normal 0.9em arial, helvetica;9. }10.11. #log {12. width: 440px;13. height: 200px;14. border: 1px solid #7F9DB9;15. overflow: auto;16. }17.18. #msg {19. width: 330px;20. }21.</style>22.23.<script>24. var socket;25.26. function init() {27. var host = "ws://127.0.0.1:12345/";28. try {29.socket = new WebSocket(host);30.socket.onopen = function (msg) {31. log('Connected');32. };33.socket.onmessage = function (msg) {34. log(msg.data);35. };36.socket.onclose = function (msg) {37. log("Lose Connection!");38. };39. }40. catch (ex) {41. log(ex);42. }43. $("msg").focus();44. }45.46. function send() {47. var txt, msg;48.txt = $("msg");49.msg = txt.value;50. if (!msg) {51. alert("Message can not be empty");52. return;53. }54.txt.value = "";55. txt.focus();56. try {57. socket.send(msg);58. } catch (ex) {59. log(ex);60. }61. }62.63.window.onbeforeunload = function () {64. try {65. socket.send('quit');66. socket.close();67.socket = null;68. }69. catch (ex) {70. log(ex);71. }72. };73.74.75. function $(id) {76. return document.getElementById(id);77. }78. function log(msg) {79. $("log").innerHTML += "<br>" + msg;80. }81. function onkey(event) {82. if (event.keyCode == 13) {83. send();84. }85. }86.</script>87.88.</head>89.90.91.<body onload="init()">92.<h3>WebSocket</h3>93.<br><br>94.95.<div id="log"></div>96.<input id="msg"type="textbox"onkeypress="onkey(event)"/>97.<button onclick="send()">发送</button>98.</body>99.100.</html>。