Python Websocket

最新推荐文章于 2024-05-27 22:17:46 发布
最新推荐文章于 2024-05-27 22:17:46 发布
阅读量3.7k 收藏 13
点赞数 2
分类专栏： django websocket 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a649344475/article/details/81234825
版权

1 django dwebsocket 模块

一、创建项目（dj_websocket）：
1、创建项目
python django-admin.py startproject dj_websocket
2、进入项目
cd dj_websocket
3、创建APP（myapp）
python manage.py startapp myapp
4、创建，static （静态文件夹），已经 templates（模板文件夹）
mkdir static
mkdir templates

二、配置 settings.py

1、在 INSTALLED_APPS 列表加上（myapp）：
INSTALLED_APPS = [
	...,
    'myapp',
]

2、在 TEMPLATES 列表的DIRS加上：
TEMPLATES = [
    {
        ...,
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        ...,
    },
]

3、在文件末尾加上：
STATICFILES_DIRS = [os.path.join(BASE_DIR,'static')]

三、views.py 文件编写：

import json
import time
import datetime
from django.shortcuts import render
from dwebsocket.decorators import accept_websocket,require_websocket

# Create your views here.



def index(request):
    return render(request, 'index.html',{'init':'init'})


@accept_websocket
def echo(request):
    if not request.is_websocket():#判断是不是websocket连接
    	#如果是普通的http方法
        try:
            message = request.GET['message']
            return HttpResponse(message)
        except:
            return render(request,'index.html')
    else:
    	# 如果是websocket请求
        for message in request.websocket:
            request.websocket.send(message)#发送消息到客户端
            #request.websocket.send(message)
            # 推送10次，当然你可以无限次的推送
            for i in range(10):
                dt = str(datetime.datetime.now())
                s={'test':f"你好 {i} {dt}"}
                s=json.dumps(s).encode()
                request.websocket.send(s)
                time.sleep(0.1) # 间隔0.1秒

四、urls.py 文件编写：

from django.conf.urls import url
from django.contrib import admin

from myapp import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^index/', views.index),
    url(r'^echo$', views.echo),
]

五、index.html 编写（templates文件夹）
其中使用了 jquery-1.8.3.min.js ，需要下载到我们的 static 文件夹

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>django-websocket</title>
    {% load staticfiles %}
    <script src="{% static 'jquery-1.8.3.min.js' %}"></script>
    <script type="text/javascript">//<![CDATA[
    $(function () {
            /*创建socket连接
            var socket = new WebSocket("ws://" + window.location.host + "/echo");
            socket.onopen = function () {
                console.log('WebSocket open');//成功连接上Websocket
                 socket.send($('#message').val());//通过websocket发送数据
            };
            socket.onmessage = function (e) {
                console.log('message: ' + e.data);//打印出服务端返回过来的数据
                $('#messagecontainer').prepend('<p>' + e.data + '</p>');
            };
            // Call onopen directly if socket is already open
            //if (socket.readyState == WebSocket.OPEN) socket.onopen();
            // 这些代码可以实现一进入页面就自动推送,不可停止
            */

        $('#connect_websocket').click(function () {
            if (window.s) {
                window.s.close();
            }
            /*创建socket连接*/
            var socket = new WebSocket("ws://" + window.location.host + "/echo");
            socket.onopen = function () {
                console.log('WebSocket open');//成功连接上Websocket
            };
            socket.onmessage = function (e) {
                console.log('message: ' + e.data);//打印出服务端返回过来的数据
                var d= $.parseJSON(e.data);
                //alert(typeof(d));
                $('#messagecontainer').prepend('<p>' + d.test + '</p>');
            };
            // Call onopen directly if socket is already open
            if (socket.readyState == WebSocket.OPEN) socket.onopen();
            window.s = socket;
        });
        $('#send_message').click(function () {
            //如果未连接到websocket
            if (!window.s) {
                alert("websocket未连接.");
            } else {
                window.s.send($('#message').val());//通过websocket发送数据
            }
        });
        $('#close_websocket').click(function () {
            if (window.s) {
                window.s.close();//关闭websocket
                console.log('websocket已关闭');
            }
        });

    });
    //]]></script>
</head>
<body>
<br>
<input type="text" id="message" value="开始..."/>
<button type="button" id="connect_websocket">连接 websocket</button>
<button type="button" id="send_message">发送 message</button>
<button type="button" id="close_websocket">关闭 websocket</button>
<h1>Received Messages</h1>
<div id="messagecontainer">

</div>
{{init}}
</body>
</html>

六、开始执行：
这两句在这里不是必要的
python manage.py makemigrations
python manage.py migrate

运行服务器
python manage.py runserver

七、访问：
打开浏览器输入地址：http://localhost:8000/index/
我们将看到页面：
img1

点击连接，再点击发送，开始推送：
这里写图片描述

2 websockets 模块

**1 server.py **

import websockets
import asyncio
import time
import datetime
import json

async def hello(websocket,path):
  name = await websocket.recv()
  print(f'A new client: {name}')
  for i in range(10):
    dt = str(datetime.datetime.now())
    s = json.dumps({'test':f"{name} {i} {dt}"})
    await websocket.send(s)
    print(f'send {name} {i} {dt}')
    time.sleep(0.1)


start_server = websockets.serve(hello,'localhost',8000)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

run server.py:
python server.py

**2 client.py **

import websockets
import asyncio


async def hello():
  async with websockets.connect('ws://localhost:8000') as websocket:
    name = input("what's your name?")
    await websocket.send(name)
    print(f"send server:{name}")
    while 1:
      greeting = await websocket.recv()
      print(f'receive from server:{greeting}')

asyncio.get_event_loop().run_until_complete(hello())

run client.py
python client.py
input：hello
output to server

A new client: hello
send hello 0 2018-07-28 20:24:11.410886
send hello 1 2018-07-28 20:24:11.511604
send hello 2 2018-07-28 20:24:11.612339
send hello 3 2018-07-28 20:24:11.713062
send hello 4 2018-07-28 20:24:11.813771
send hello 5 2018-07-28 20:24:11.914492
send hello 6 2018-07-28 20:24:12.015099
send hello 7 2018-07-28 20:24:12.115936
send hello 8 2018-07-28 20:24:12.216658
send hello 9 2018-07-28 20:24:12.317399

output to client.py

what's your name?hello
send server:hello
receive from server:{"test": "hello 0 2018-07-28 20:24:11.410886"}
receive from server:{"test": "hello 1 2018-07-28 20:24:11.511604"}
receive from server:{"test": "hello 2 2018-07-28 20:24:11.612339"}
receive from server:{"test": "hello 3 2018-07-28 20:24:11.713062"}
receive from server:{"test": "hello 4 2018-07-28 20:24:11.813771"}
receive from server:{"test": "hello 5 2018-07-28 20:24:11.914492"}
receive from server:{"test": "hello 6 2018-07-28 20:24:12.015099"}
receive from server:{"test": "hello 7 2018-07-28 20:24:12.115936"}
receive from server:{"test": "hello 8 2018-07-28 20:24:12.216658"}
receive from server:{"test": "hello 9 2018-07-28 20:24:12.317399"}

3 client.html

<html>
<head>
    <meta charset="utf-8">
    <title>django-websocket</title>
    <script src="jquery-1.8.3.min.js"></script>
<script type="text/javascript">
    $(function () {
        $('#connect_websocket').click(function () {
            if (window.s) {
                window.s.close();
            }
            /*创建socket连接*/
            var socket = new WebSocket("ws://localhost:8000");
            socket.onopen = function () {
                console.log('WebSocket open');//成功连接上Websocket
            };
            socket.onmessage = function (e) {
                console.log('message: ' + e.data);//打印出服务端返回过来的数据
                var d= $.parseJSON(e.data);
                $('#messagecontainer').prepend('<p>' + d.test + '</p>');
            };
            if (socket.readyState == WebSocket.OPEN) socket.onopen();
            window.s = socket;
        });
        $('#send_message').click(function () {
            //如果未连接到websocket
            if (!window.s) {
                alert("websocket未连接.");
            } else {
                window.s.send($('#message').val());//通过websocket发送数据
            }
        });
        $('#close_websocket').click(function () {
            if (window.s) {
                window.s.close();//关闭websocket
                console.log('websocket已关闭');
            }
        });

    });
</script>
</head>
<body>
<br>
<input type="text" id="message" value="开始..."/>
<button type="button" id="connect_websocket">连接 websocket</button>
<button type="button" id="send_message">发送 message</button>
<button type="button" id="close_websocket">关闭 websocket</button>

<div id="messagecontainer">

</div>
</body>
</html>

run client.html
打开浏览器输入地址：file:///home/huang/Practise/demo1/client.html

输入 ：你好，点击连接，再点击发送，开始推送：
output to server

A new client: 你好
send 你好 0 2018-07-28 20:38:34.384413
send 你好 1 2018-07-28 20:38:34.485158
send 你好 2 2018-07-28 20:38:34.585793
send 你好 3 2018-07-28 20:38:34.686401
send 你好 4 2018-07-28 20:38:34.787105
send 你好 5 2018-07-28 20:38:34.887769
send 你好 6 2018-07-28 20:38:34.988483
send 你好 7 2018-07-28 20:38:35.089176
send 你好 8 2018-07-28 20:38:35.189867
send 你好 9 2018-07-28 20:38:35.290481

output to client.html

你好 9 2018-07-28 20:38:35.290481

你好 8 2018-07-28 20:38:35.189867

你好 7 2018-07-28 20:38:35.089176

你好 6 2018-07-28 20:38:34.988483

你好 5 2018-07-28 20:38:34.887769

你好 4 2018-07-28 20:38:34.787105

你好 3 2018-07-28 20:38:34.686401

你好 2 2018-07-28 20:38:34.585793

你好 1 2018-07-28 20:38:34.485158

你好 0 2018-07-28 20:38:34.384413

3 websockets 模块模拟动态推送K线图数据回测

1、web_server.py

import json
import time
import random
import datetime
import asyncio
import websockets

async def echo2(websocket, path):
    message = await websocket.recv()
    await websocket.send(message)

@asyncio.coroutine
def echo(websocket, path):
    message = yield from websocket.recv()
    print('recv', message)
    dt = datetime.datetime.now()
    cc = 1000
    for i in range(1000):
        dt2 = str(dt + datetime.timedelta(minutes=i))[11:19]
        y = [cc + random.randint(-80, 100) for i in range(4)]
        v = []
        mi = min(y)
        ma = max(y)
        y.remove(mi)
        y.remove(ma)
        y = [y[0], y[1], mi, ma]
        cc = y[2] if y[2] > 900 else 1000
        s = {'datetime': dt2, 'topic': 'bar','open':y[0],'close':y[1],'high':y[2],'low':y[3]}
        s = json.dumps(s)#.encode()
        #print(s)
        # request.websocket.send(s)
        yield from websocket.send(s)

        v = random.randint(0,5)
        if v in (3,4):
            v = 'SELL' if v==4 else 'BULL' # 卖出、买入
            s = {'topic':'trade','trading_dt':dt2,'price':y[1],'side':v}
            print(s)
        s = json.dumps(s)#.encode()

        # request.websocket.send(s)
        yield from websocket.send(s)

        time.sleep(0.5)  # 间隔0.5秒


start_server = websockets.serve(echo, 'localhost', 8000)

asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

2 web_client.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>django-websocket</title>
    <script type="text/javascript" src="jquery-1.8.3.min.js"></script>
    <script type="text/javascript" src="echarts.min.js"></script>
</head>
<body>
<br>
<input type="text" id="message" value="200"/>
<button type="button" id="connect_websocket">连接</button>
<button type="button" id="send_message">开始画图</button>
<button type="button" id="close_ht">暂停画图</button>
<button type="button" id="close_websocket">关闭接收数据</button>
<div id="messagecontainer">

</div>
<div id="main" style="width: auto;height: 800px;" align="center"></div>
    <script type="text/javascript">

var myChart = echarts.init(document.getElementById('main'));
var bs = new Array();
var xzs = new Array();

option = {
    title : {
        text: '回测',
        subtext: 'K线'
    },
    tooltip : {
        trigger: 'axis'
    },
    legend: {
        data:['回测','卖出','买入']
    },
    toolbox: {
        show : true,
        feature : {
            mark : {show: true},
            dataView : {show: true, readOnly: false},
            restore : {show: true},
            saveAsImage : {show: true}
        }
    },
    dataZoom : {
        show : true,
        realtime: true,
        start : 50,
        end : 100
    },
    xAxis : [
        {
            type : 'category',
            boundaryGap : true,
            data : [

            ]
        }
    ],
    yAxis : [
        {
            type : 'value',
            scale:true,
            splitNumber: 5,
            boundaryGap: [0.05, 0.05]
        }
    ],
    series : [
        {
            name:'回测',
            type:'k',
            data:[ // 开盘，收盘，最低，最高
            ]
        },{
            name:'卖出',
            type:'scatter',
            symbol: 'arrow',//'star3',
            symbolSize: 12,
            smooth:true,
            symbolRotate:180,

            itemStyle:{
                //symbolRotate:-90,
                normal: { color:function(p){
                    return bs[p.name];
                 }
                }
            },
            
            data: []
        },{
            name:'买入',
            type:'scatter',
            symbol: 'arrow',//'star3',
            symbolSize: 12,
            smooth:true,
            symbolRotate:0,

            itemStyle:{
                //symbolRotate:-90,
                normal: { color:function(p){
                    return bs[p.name];
                 }
                }
            },
            
            data: []
        }
    ]
};

stringToDate = function(dateStr,separator){
     if(!separator){
            separator="-";
     }
     var dateArr = dateStr.split(separator);
     var year = parseInt(dateArr[0]);
     var month;
     //处理月份为04这样的情况
     if(dateArr[1].indexOf("0") == 0){
         month = parseInt(dateArr[1].substring(1));
     }else{
          month = parseInt(dateArr[1]);
     }
     var day = parseInt(dateArr[2]);
     var date = new Date(year,month -1,day);
     return date;
 }

var k_x = new Array();
var k_y = new Array();
var y_x = new Array();
var y_y = new Array();
var y_y2 = new Array();
var is_huatu = true;
var size = $('#message').val()-0;

//myChart.setOption(option);

function timeTicket(x,y,type,side){
    // 动态数据接口 addData
    // lastIndex += 1;
    // var len2 = option.series[0].data.length;
    // var d = option.xAxis[0].data[len2-1];
    // d = stringToDate(d,'/');
    // d.setDate(d.getDate()+1);
    // d = d.getFullYear()+'/'+(d.getMonth()+1)+'/'+d.getDate();

    if(type=='k'){
        var ind = k_x.indexOf(x);
        if(ind<0){
                k_x.push(x);
                k_y.push(y);
                y_y.push('');
                y_y2.push('');
            }else{
                k_y[ind] = y;
            }
            
            if(is_huatu){
                option.xAxis[0].data=k_x.slice(-size);
                option.series[0].data=k_y.slice(-size);
                option.series[1].data=y_y.slice(-size);
                option.series[2].data=y_y2.slice(-size);
                //option.series[1].symbolRotate=y_y.slice(-size);
                myChart.setOption(option);
            }
    }else if(type=='y'){
            var ind = k_x.indexOf(x);
            
            if(ind<0){
                k_x.push(x);
                k_y.push(k_y[k_y.length-1]);
                if(side=='SELL'){
                    y_y.push(y);
                    y_y2.push('')
                }else{
                    y_y.push('');
                    y_y2.push(y)
                }
            }else{
                //y_y[ind] = y;
                if(side=='SELL'){
                    y_y[ind] = y;
                }else{
                   y_y2[ind] = y;
                }
            }
            if(is_huatu){
                option.xAxis[0].data=k_x.slice(-size);
                option.series[0].data=k_y.slice(-size);
                option.series[1].data=y_y.slice(-size);
                option.series[2].data=y_y2.slice(-size);
               myChart.setOption(option);
            }
    }else{
        option.xAxis[0].data=k_x.slice(-size);
        option.series[0].data=k_y.slice(-size);
        option.series[1].data=y_y.slice(-size);
        option.series[2].data=y_y2.slice(-size);
        myChart.setOption(option);
    }
        /*myChart.addData([
            [
                0,        // 系列索引
                option.series[0].data[lastIndex%len], // 新增数据
                false,     // 新增数据是否从队列头部插入
                false,     // 是否增加队列长度，false则自定删除原有数据，队头插入删队尾，队尾插入删队头
                d //option.xAxis[0].data[lastIndex%len]
            ]
        ]);*/
}

$(function () {
        function manages(info){
            if (window.s) {
                window.s.close();
            }
            /*创建socket连接*/
            var url = "ws://localhost:8000"; // 连接地址
            var socket = new WebSocket(url); //window.location.host
            socket.onopen = function () {
                console.log('WebSocket open');//成功连接上Websocket
                if(info) alert('WebSocket open');
            };
            var x=null,y=null;
            socket.onmessage = function (e) {
                console.log('message: ' + e.data);//打印出服务端返回过来的数据
                var d= $.parseJSON(e.data);
                if(d.topic=='bar'){
                    x = d.datetime;
                    y=[d.open,d.close,d.high,d.low]
                    timeTicket(x,y,'k','');
                }else if(d.topic=='trade'){
                    x = d.trading_dt;
                    y = d.price;
                    //bs = d.bs;
                    if(d.side=='SELL'){
                        bs[x]='green';
                    }else{
                        bs[x]='red';
                    }
                    timeTicket(x,y,'y',d.side);
                }
            };
            // Call onopen directly if socket is already open
            if (socket.readyState == WebSocket.OPEN) socket.onopen();
            window.s = socket;
        }
        manages(false);
        $('#connect_websocket').click(function () {
            manages(true);
        });
        $('#send_message').click(function () {
            //如果未连接到websocket
            is_huatu = true;
            if (!window.s) {
                alert("websocket未连接.");
            } else {
                window.s.send($('#message').val());//通过websocket发送数据
            }
        });
        $('#close_websocket').click(function () {
            if (window.s) {
                window.s.close();//关闭websocket
                console.log('websocket已关闭');
            }
        });
        $('#close_ht').click(function () {
            is_huatu = false;
            size = $('#message').val()-0;
            timeTicket('','','','');
        });
    });


//var t=setInterval("timeTicket()",100);
</script>
</body>
</html>

3 执行
1、python web_server.py
2、浏览器打开：web_client.html，点击开始画图

服务端输出结果：

D:\tools>python server_web.py
recv 200
{'topic': 'trade', 'trading_dt': '18:58:22', 'price': 882, 'side': 'BULL'}
{'topic': 'trade', 'trading_dt': '18:59:22', 'price': 1032, 'side': 'BULL'}
{'topic': 'trade', 'trading_dt': '19:01:22', 'price': 856, 'side': 'BULL'}
。。。。。。

浏览器输出结果：
这里写图片描述
注：此代码只是个人根据当时的环境满足了当时的需求，记录下来用做后续参考！如有问题，请检查软硬件环境是否一致，由于时间精力有限，大部分未做详细环境描述。

医然
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
python之websocket
python学习者的博客
06-10 1万+
一、websocket WebSocket协议是基于TCP的一种新的协议。WebSocket最初在HTML5规范中被引用为TCP连接，作为基于TCP的套接字API的占位符。它实现了浏览器与服务器全双工(full-duplex)通信。其本质是保持TCP连接，在浏览器和服务端通过Socket进行通信。 本文将使用Python编写Socket服务端，一步一步分析请求过程！！！ 1. 启动服...
python---websocket的使用
SherryJin的博客
05-05 3270
WebSocket 是什么原理？为什么可以实现持久连接？WebSocket：5分钟从入门到精通（很好）WebSocket协议是基于TCP的一种新的协议。WebSocket最初在HTML5规范中被引用为TCP连接，作为基于TCP的套接字API的占位符。它实现了浏览器与服务器全双工(full-duplex)通信。其本质是保持TCP连接，在浏览器和服务端通过Socket进行通信。
python中使用websocket方法【OK】
最新发布
qq_31432773的博客
05-27 394
WebSocket是一种网络通信协议,它在单个TCP连接上提供全双工的通信信道,本文我们将探讨如何在Python中使用WebSocket实现实时通信,感兴趣的朋友跟随小编一起看看吧
为什么需要 WebSocket？
ahjxhy2010的博客
05-31 1194
WebSocket 是一种网络通信协议，很多高级功能都需要它。 一、为什么需要 WebSocket？ 初次接触 WebSocket 的人，都会问同样的问题：我们已经有了 HTTP 协议，为什么还需要另一个协议？它能带来什么好处？ 答案很简单，因为 HTTP 协议有一个缺陷：通信只能由客户端发起。 举例来说，我们想了解今天的天气，只能是客户端向服务器发出请求，服务器返
Python websocket之 websocket-client 库的使用
热门推荐
tz_zs的博客
08-04 3万+
____tz_zs 本次，我将从主流的三方框架使用出发，带大家熟悉和使用 Python 中常见的 websocket 库。 一、websocket-client 库 websocket-client 库是一个简单好用的同步的 websocket 的客户端的库，基于回调的方式使用。 pypi地址： https://pypi.org/project/websocket-client/ GitHub地址： https://github.com/websocket-client/websocket-client
测试人必会：Python带你上手WebSocket
人生不怕起点低，就怕没追求
11-13 1803
关于Socket那些事 Socket，即网络套接字，是双向通信通道的端点（是抽象的）。 套接字可以在一个进程内、同一台机器上的进程之间，或者在不同机器上的进程之间进行通信。 网络套接字可以通过多种不同的通道类型得以实现，例如TCP、UDP等。 换句话说，网络套接字，是在计算机网络中，两个运行程序之间通信流中的一个端点。这个端点是一个虚拟抽象的概念，并不存在任何硬件。 网络套接字可以通过IP地址和端口号的组合来唯一标识。下面我们对于Socket套接字相关术语做简单介绍，以便于后续内容的理解。 Domain（.
详解python websocket获取实时数据的几种常见链接方式
09-19
主要介绍了详解python websocket获取实时数据的几种常见链接方式，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Python Websocket服务端通信的使用示例
09-17
Python Websocket服务端通信是建立实时双向通信的关键技术，它允许服务器和客户端之间进行持续的数据交换，而无需频繁地打开和关闭连接。WebSocket协议在HTTP之上，但与HTTP不同，它建立一次连接后，就可以在客户端...
Python WebSocket长连接心跳与短连接的示例
01-19
ws = websocket.WebSocketApp(ws://echo.websocket.org/, on_message = on_message, on_error = on_error, on_close = on_close) ws.on_open = on_open ws.run_forever()  长连接，参数介绍： （1）url: ...
python实现websocket的客户端压力测试
09-19
主要为大家详细介绍了python实现websocket的客户端压力测试，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
WebSocket - 基于 Python 的主流实现方式总结
LIN的博客
07-02 2万+
目录 一、WebSocket -网络通信协议 1-1 简介 二、Websockets servers and clients in Python 2-0 connect 2-0-1 建立一对一短连接 ​ 2-0-2 建立一对一长连接 2-0-3 建立一对多长连接 2-1 asyncio 三、SocketIO 3-0 Flask-Sockets VS Flask-SocketIO...
Python进行websocket接口测试
思月行云
01-10 4049
Python进行websocket接口测试 Nikon937 Python进行websocket接口测试 - 简书 我们在做接口测试时，除了常见的http接口，还有一种比较多见，就是socket接口，今天讲解下怎么用Python进行websocket接口测试。 现在大多数用的都是websocket，那我们就先来安装一下websocket的安装包。 pip install websocket-client 安装完之后，我们就开始我们的websocket之旅了。 我们先来看个简单的例子：
python建立客户端wesocket
qq_36797488的博客
10-13 2920
python建立websocket客户端链接
python websocket库 安装_python 的 websocket的使用
weixin_39962341的博客
12-04 1807
一：websocket使用场景https://django-websocket-redis.readthedocs.io/en/latest/running.html最典型的使用场景：聊天。还有就是：当我们做异步处理的任务的时候，之前采用的长轮询或者计时器的方法，但是这种方法的开销和性能比较差。对于网页的性能的不是很好。而html5的时候 支持websocket和python 本身也支持webso...
python-socket、websocket协议相关知识
m0_62649400的博客
09-18 844
socket通信是基于TCP/IP协议，适用于传输大量数据和可靠的连接。它在网络编程中应用广泛，但不适用于实时性要求较高的场景。在Python中，socket和socketserver是两个用于网络编程的库。socket库提供了基本的网络通信功能，包括创建套接字、绑定地址、监听连接等。它主要用于实现客户端或服务器端的网络通信。使用socket库时，需要手动处理数据的发送和接收，以及错误处理等。
websocket 在python中的使用
lhzhqq的博客
11-17 1911
websocket 的作用就不在此赘述了，下面通过一个简单的案例介绍websocket的使用。
Python爬取WebSocket数据 - 初尝试
Enderman_xiaohei的博客
05-03 4977
参考链接： WebSocket 通信原理【底层】：原来你是这样的Websocket–抓包分析 Python 爬取 WebSocket【顶层】：Python如何爬取实时变化的WebSocket数据的方法 注意：可以直接参考上述链接，解释地很详细。 WebSocket 爬虫 目录 1. WebSocket 介绍 2. 分析 3. 编写爬序 4. 其它 5. 总结 一、WebSocket 介绍 ↶...
Python 基于 Flask 框架实现 Websocket 实时通信详细教程（待更新）
唤醒手腕的博客
06-11 2万+
Websocket 和 Http WebSocket 是 HTML5 出的东西（协议），也就是说HTTP协议没有变化，或者说没关系，但HTTP是不支持持久连接的（长连接，循环连接的不算） 首先HTTP有 1.1 和 1.0 之说，也就是所谓的 keep-alive ，把多个HTTP请求合并为一个，但是 Websocket 其实是一个新协议，跟HTTP协议基本没有关系，只是为了兼容现有浏览器的握手规范而已，也就是说它是HTTP协议上的一种补充可以通过这样一张图理解： 有交集，但是并不是全部 GET /cha
python websocket库 安装_Python WebSocket
weixin_39928736的博客
12-04 5280
安装pip install websocket-client先来看一下，长连接调用方式：ws = websocket.WebSocketApp("ws://echo.websocket.org/",on_message = on_message,on_error = on_error,on_close = on_close)ws.on_open = on_openws.run_forever()长...
python websocket
07-27
Python WebSocket 是一种实现了 WebSocket 协议的 Python 库。它使得在 Python 中可以轻松地创建 WebSocket 服务器和客户端。通过使用 WebSocket，可以实现实时的双向通信，适用于需要实时数据传输的应用程序。 要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值