2021-01-22socket模块

2021-01-22 18:24:14 21 收藏
分类专栏： python 网络编程 文章标签： socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51324662/article/details/112988476
版权

socket：
我们经常把socket翻译为套接字，socket是在应用层和传输层之间的一个抽象层，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用已实现进程在网络中通信。
在这里插入图片描述
socket起源于UNIX，在Unix一切皆文件哲学的思想下，socket是一种"打开—读/写—关闭"模式的实现，服务器和客户端各自维护一个"文件"，在建立连接打开后，可以向自己文件写入内容供对方读取或者读取对方内容，通讯结束时关闭文件。
在这里插入图片描述
在这里插入图片描述

客户端代码：

#创建服务端
import socket
#创建服务端
response=socket.socket(socket.AF_INET,socket.SOCK_STREAM)   #流式协议=》tcp协议
socket.socket(socket.AF_INET,socket.SOCK_DGRAM)    #utp协议
#绑定ip地址
#linux系统ifconfig查看ip地址
#windows系统ipconfig查看ip地址
#在服务器上直接连接0.0.0.0就可以公网ip也可以
#ip：127.0.0.1测试时使用
#0-65535，1024之前被系统使用
response.bind(("127.0.0.1",8080))
#设置半连接池的大小
response.listen(5)
#等待连接请求
#双次赋值,就是这个函数返回两个值为一个元组形式，把元组的第一个值赋给conn第二个值赋给clint_addr
conn,client_addr=response.accept()
print(conn)
print("客户端的ip和端口：",client_addr)
#5收\发消息
data=conn.recv(1024)                #最大接收数据量1024bytes，收到的bytes类型
print("客户端发来的消息：",data.decode("utf-8"))
conn.send(data.upper())
#6.关闭电话连接conn
conn.close()
#7.关闭服务端
conn.close()

服务端：

#这是客户端
import socket
get=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#连接服务端
get.connect(("127.0.0.1",8080))
#通信
get.send("hello 编程人".encode("utf-8"))
#关闭的连接
get.close()

#linux系统ifconfig查看ip地址
#windows系统ipconfig查看ip地址
查询效果：
在这里插入图片描述
实现服务端与客户端连接通信简单操作的代码：
服务端：

#创建服务端
import socket
import time
#管理者函数：
#def manger():
#主要功能是收到管理者的信息然后暂停函数
#创建服务端
response=socket.socket(socket.AF_INET,socket.SOCK_STREAM)   #流式协议=》tcp协议
#socket.socket(socket.AF_INET,socket.SOCK_DGRAM)    #utp协议
#绑定ip地址
#linux系统ifconfig查看ip地址
#windows系统ipconfig查看ip地址
#在服务器上直接连接0.0.0.0就可以公网ip也可以
#ip：127.0.0.1测试时使用
#0-65535，1024之前被系统使用
ip_place=("127.0.0.1",8080)
response.bind(ip_place)
#设置半连接池的大小
response.listen(5)
print("服务端启动完成，监听地址为："+str(ip_place))
#等待连接请求
#双次赋值,就是这个函数返回两个值为一个元组形式，把元组的第一个值赋给conn第二个值赋给clint_addr
conn,client_addr=response.accept()
print(conn)
print("客户端的ip和端口：",client_addr)
#5收\发消息
c=0
while True:
    conn, client_addr = response.accept()
    while True:
        try:
            data = conn.recv(1024)  # 最大接收数据量1024bytes，收到的bytes类型
            #这是linux的防触发装置
            if not data:
                break
        #当远程主机断开时linux主机会返回空然后服务端就会阻塞
        #而windows系统会直接断开并且提示错误
            print("客户端发来的消息：",data.decode("utf-8"))
            if data.decode("utf-8") == "mzy":
                print("正在进行操作")
            conn.send(data)
        except:
            #延迟二十秒会停止，中间连接20次
            c+=1
            time.sleep(1)
            print("此连接已终止")
            if c==20:
                break
#6.关闭电话连接conn
conn.close()
#7.关闭服务端
conn.close()

客户端：

#这是客户端
import socket
get=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#连接服务端
get.connect(("127.0.0.1",8080))
#通信
while True:
    quest=input("》》》》")
    data = get.send(quest.encode("utf-8"))
    if not data:
        print("请输入非空字符")
        continue
    #收取服务端消息
    data1=get.recv(1024)
    print(data1.decode("utf-8"))
#关闭的连接
get.close()

subprocess模块
Python subprocess模块
subprocess
#基于subprocess模块实现对远程主机终端的操作
#粘包问题：
1.tcp是流式协议，数据像水流一样，没有边界
2.收数据远远大于recv的参数值，会与下一次结果混淆在一起
所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。
此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

1·TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
2·UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
3·tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略
4·udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠

tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

#解决方法：
每次收干净
代码实现：
终端代码：

  #当远程主机断开时linux主机会返回空然后服务端就会阻塞
        #而windows系统会直接断开并且提示错误
            print("客户端发来的消息：",data.decode("utf-8"))
            #这个是终端使用的方法
            #linux是utf-8解码
            cmd=subprocess.Popen(
                             data.decode("utf-8"),
                             shell=True,
                             stdin=subprocess.PIPE,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )
            print("hello")
            if cmd.poll()!=0:
                conn.send("正在运行".strip().encode("utf-8"))
            #print(cmd.stdout)
            #subprocess.getoutput()
            stdout_res = cmd.stdout.read()  # 正确结果
            stderr_res = cmd.stderr.read()  # 错误结果
            #这里有一个瑕疵就是如果运行的一个程序类似于python程序会卡顿在这里暂无解决方法，后来学了多线程可以尝试更改
            if len((stderr_res+stdout_res).decode("utf-8"))==0:
                conn.send("传入为空集或者导入程序".strip().encode("utf-8"))
            else:
                conn.send(stderr_res + stdout_res)
                print(stderr_res + stdout_res)
            #文件保存机制
            with open("1.mp4",mode="rb") as f:
                for line in f:

总结代码如下：
服务端：

#from socket import *
#创建服务端
import socket
import time
import subprocess
import struct
import json
#管理者函数：
#def manger():
#主要功能是收到管理者的信息然后暂停函数
#创建服务端
response=socket.socket(socket.AF_INET,socket.SOCK_STREAM)   #流式协议=》tcp协议
#socket.socket(socket.AF_INET,socket.SOCK_DGRAM)    #utp协议
#绑定ip地址
#linux系统ifconfig查看ip地址
#windows系统ipconfig查看ip地址
#在服务器上直接连接0.0.0.0就可以公网ip也可以
#ip：127.0.0.1测试时使用
#0-65535，1024之前被系统使用
ip_place=("127.0.0.1",8081)
response.bind(ip_place)
#设置半连接池的大小
response.listen(5)
print("服务端启动完成，监听地址为："+str(ip_place))
#等待连接请求
#解压赋值,就是这个函数返回两个值为一个元组形式，把元组的第一个值赋给conn第二个值赋给clint_addr
#5收\发消息
c=0
while True:
    conn, client_addr = response.accept()
    print("客户端的ip和端口：", client_addr)
    while True:
        try:
            data = conn.recv(1024)  # 最大接收数据量1024bytes，收到的bytes类型
            #这是linux的防触发装置
            if len(data)==0:
                break
        #当远程主机断开时linux主机会返回空然后服务端就会阻塞
        #而windows系统会直接断开并且提示错误
            print("客户端发来的消息：",data.decode("utf-8"))
            #这个是终端使用的方法
            #linux是utf-8解码
            cmd=subprocess.Popen(
                             data.decode("utf-8"),
                             shell=True,
                             stdin=subprocess.PIPE,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )
            print("hello")
            if cmd.poll()==0:
                conn.send("非正常运行".strip().encode("utf-8"))
                break
            #print(cmd.stdout)
            #subprocess.getoutput()
            stdout_res = cmd.stdout.read()  # 正确结果
            stderr_res = cmd.stderr.read()  # 错误结果
            print(len(stdout_res)+len(stderr_res))  #这是数据的总大小
            ##send函数发的是数据必须用encode来转换一下
            #1先发头信息（固定长度的bytes）：对数据描述信息
            #这是一个自定义协议
            # header_dic={
            #     "filename":"a.txt",
            #     "total_size":len(stdout_res)+len(stderr_res),
            #     "md5":"123123xi12"
            # }
            # json_str=json.dump(header_dic)
            # json_str_bytes=json_str.encode("utf-8")
            # #发送头的长度
            # header_num = struct.pack('i', len(json_str_bytes))
            # conn.send(header_num)
            # #字典里面有数据长度
            header=struct.pack('i',len(stdout_res)+len(stderr_res))
            conn.send(header)
            #这是一个失败的方法conn.send(str(len(stdout_res)+len(stderr_res)).encode("utf-8"))
            #这里有一个瑕疵就是如果运行的一个程序类似于python程序会卡顿在这里暂无解决方法，后来学了多线程可以尝试更改
            if len(stderr_res)+len(stdout_res)==0:
                conn.send("传入为空集或者导入程序".strip().encode("utf-8"))
            else:
                conn.send(stderr_res + stdout_res)
                print((stderr_res + stdout_res).decode("utf-8"))
            #文件保存机制
            # with open("1.mp4",mode="rb") as f:
            #     for line in f:

        except:
            #延迟二十秒会停止，中间连接20次
            c+=1
            time.sleep(1)
            print("此连接已终止")
            if c==5:
                conn.close()
                break
#6.关闭电话连接conn
conn.close()
#7.关闭服务端
conn.close()

客户端：

from socket import *
import struct
import time
import json
client=socket(AF_INET,SOCK_STREAM)
client.connect(("127.0.0.1",8081))
while True:
    msg=input("请输入命令>>:").strip()
    if  len(msg)==0:
        continue

    client.send(msg.encode("utf-8"))
    #为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节,这是应用层定的标准
    header=client.recv(4)
    #返回的是一个元组的形式其中第一个数据就是报头的长度
    toatal_size=struct.unpack('i',header)[0]
    # #这里是接收端的头的长度
    # json_str_bytes=client.recv(toatal_size)
    # json_str=json_str_bytes.decode("utf-8")
    # #获得数据字典
    # header_dic=json.loads(json_str)
    print(toatal_size)
    recv_size=0
    cmd_ress=b''
    while recv_size<toatal_size:
        cmd_res = client.recv(1024)
        recv_size+=len(cmd_res)
        cmd_ress+=cmd_res
    # else:
    #     #没有被break结束后加上else的操作
    #     print("")
    try:
        if cmd_ress.decode("utf-8"):
            print(cmd_ress.decode("utf-8"))
    except:
        print(cmd_ress.decode("gbk"))

socketserver模块

基于tcp的套接字，关键就是两个循环，一个链接循环，一个通信循环

socketserver模块中分两大类：server类（解决链接问题）和request类（解决通信问题）
server类：
在这里插入图片描述
request类：
在这里插入图片描述
继承关系:
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

总的代码：
服务端：

import socketserver
import time
import subprocess
import struct
import json
class MyRequestHandle(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request)
        print("以连接客户端地址为：",self.client_address)
        c=0
        while True:
            try:
                data = self.request.recv(1024)  # 最大接收数据量1024bytes，收到的bytes类型
                # 这是linux的防触发装置
                if len(data) == 0:
                    break
                # 当远程主机断开时linux主机会返回空然后服务端就会阻塞
                # 而windows系统会直接断开并且提示错误
                print("客户端发来的消息：", data.decode("utf-8"))
                # 这个是终端使用的方法
                # linux是utf-8解码
                cmd = subprocess.Popen(
                    data.decode("utf-8"),
                    shell=True,
                    stdin=subprocess.PIPE,
                    stdout=subprocess.PIPE,
                    stderr=subprocess.PIPE
                )
                print("hello")
                if cmd.poll() == 0:
                    self.request.send("非正常运行".strip().encode("utf-8"))
                    break
                # print(cmd.stdout)
                # subprocess.getoutput()
                stdout_res = cmd.stdout.read()  # 正确结果
                stderr_res = cmd.stderr.read()  # 错误结果
                print(len(stdout_res) + len(stderr_res))  # 这是数据的总大小
                ##send函数发的是数据必须用encode来转换一下
                # 1先发头信息（固定长度的bytes）：对数据描述信息
                # 这是一个自定义协议
                # header_dic={
                #     "filename":"a.txt",
                #     "total_size":len(stdout_res)+len(stderr_res),
                #     "md5":"123123xi12"
                # }
                # json_str=json.dump(header_dic)
                # json_str_bytes=json_str.encode("utf-8")
                # #发送头的长度
                # header_num = struct.pack('i', len(json_str_bytes))
                # conn.send(header_num)
                # #字典里面有数据长度
                header = struct.pack('i', len(stdout_res) + len(stderr_res))
                self.request.send(header)
                # 这是一个失败的方法conn.send(str(len(stdout_res)+len(stderr_res)).encode("utf-8"))
                # 这里有一个瑕疵就是如果运行的一个程序类似于python程序会卡顿在这里暂无解决方法，后来学了多线程可以尝试更改
                if len(stderr_res) + len(stdout_res) == 0:
                    self.request.send("传入为空集或者导入程序".strip().encode("utf-8"))
                else:
                    self.request.send(stderr_res + stdout_res)
                    print((stderr_res + stdout_res).decode("utf-8"))
                # 文件保存机制
                # with open("1.mp4",mode="rb") as f:
                #     for line in f:

            except:
                # 延迟二十秒会停止，中间连接20次
                c += 1
                time.sleep(1)
                print("此连接已终止")
                if c == 5:
                    self.request.close()
                    break
s=socketserver.ThreadingTCPServer(("127.0.0.1",8888),MyRequestHandle)

s.serve_forever()
#server_forever() 等同于：while true：
#                           conn,client_addr=server.accept()
#                           启动一个线程（conn，client_addr）
#第二件事：拿到连接对象，与其进行通讯循环===》handle

客户端：

from socket import *
import struct
import time
import json
client=socket(AF_INET,SOCK_STREAM)
client.connect(("127.0.0.1",8888))
while True:
    msg=input("请输入命令>>:").strip()
    if  len(msg)==0:
        continue

    client.send(msg.encode("utf-8"))
    #为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节,这是应用层定的标准
    header=client.recv(4)
    #返回的是一个元组的形式其中第一个数据就是报头的长度
    toatal_size=struct.unpack('i',header)[0]
    # #这里是接收端的头的长度
    # json_str_bytes=client.recv(toatal_size)
    # json_str=json_str_bytes.decode("utf-8")
    # #获得数据字典
    # header_dic=json.loads(json_str)
    print(toatal_size)
    recv_size=0
    cmd_ress=b''
    while recv_size<toatal_size:
        cmd_res = client.recv(1024)
        recv_size+=len(cmd_res)
        cmd_ress+=cmd_res
    # else:
    #     #没有被break结束后加上else的操作
    #     print("")
    try:
        if cmd_ress.decode("utf-8"):
            print(cmd_ress.decode("utf-8"))
    except:
        print(cmd_ress.decode("gbk"))

注意：其实这个直接套方法就可以了

class MyRequestHandle(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request)
        print("以连接客户端地为：",self.client_address)
       ##########目标代码###############
       ###############################
s=socketserver.ThreadingTCPServer(("127.0.0.1",8888),MyRequestHandle)
s.serve_forever()

引用了一个很好的博客https://www.cnblogs.com/linhaifeng/articles/6129246.html#_label8

已标记关键词 清除标记
c# socket模块
08-20
c# socket模块
表情包
插入表情
还能输入1000个字符
python---socket模块---监控端口
菜鸟的博客
04-29 2166
import socket,re #.*?叫做非贪婪匹配，尽可能的少匹配 #.*叫做贪婪匹配，尽可能的多匹配 # a = 'fenif1212nfi129f21f' # res = re.compile('(\d+)').findall(a) # print(res) hosts = ['1.1.1.1:90','2.2.2.2:8080','127.0.0.1:80','3.3.3.3:50'...
vue项目使用socket.io-client
ploki8的博客
05-05 4881
vue项目使用socket.io-client客户端 安装socket.io-client模块 npm install socket.io-client --save 新建一个js文件，配置socket： import Vue from ‘vue’; import io from ‘socket.io-client’; //引入socket.io-client export default ne...
HP-Socket国产优秀socket通信组件推荐
阿斌(Ben)的博客
04-07 4万+
* HP-Socket 官方网站：http://www.jessma.org * HP-Socket 项目主页：http://www.oschina.net/p/hp-socket * HP-Socket 开发文档：http://www.oschina.net/p/hp-socket/doc *HP-Socket 源代码下载地址：https://github.com/ldcsaa/HP-
易语言Winsocket模块
01-22
本模块使用Winsocket系列API实现,可以实现TCP/UDP的基本通信
cocos2d-x 基于BSD Socket网络通讯模块
luxiaoyu_sdc的专栏
07-11 9824
最近cocos2d-x项目需求, 写了个客户端的基于TCP的网络通讯模块(ios, android, win32), 把使用到的东东和遇到的问题记录下来. 1. 预备知识: 线程,互斥锁,信号量:  //创建一个线程 int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict a
Arduino - ESP8266-01模块
光庆的学习笔记
12-16 5658
一、模块接线：首先最关注的还是接线问题。 PCB板上竟然没有印刷针脚标识，怎么破？？ 先查资料，掌握如下信息： 针脚列表： 编号 针脚 GPIO 功能说明 1 UTXD GPIO1 TX 发送端 2 GND GND 3 CH_PD 高电平工作，低电平模块供电关掉 4 GPIO2 GPIO2 开机上电时必须为
Python----socket编程
一个有深度的博客
09-26 1万+
基于TCP的套接字编程： socket层的位置：socket在传输层和应用层之间 socket是什么： Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。 所以，我们无需深入理解...
Vuex+Vue-socket.io+Node.js
AeoRus的博客
05-07 2934
简单介绍项目使用的插件： "dependencies": { "express": "^4.16.3", "socket.io": "^2.1.0", "vue": "^2.5.2", "vue-router": "^3.0.1", "vue-socket.io": "^2.1.1-b", "vuex": "^3.0.1" }第一步构建node服
2021-01-31
champships的博客
02-01 73
***java基础知识30题*** 1.下列程序执行后结果为( ) class A { public int func1(int a, int b) { return a - b; } } class B extends A { public int func1(int a, int b) { return a + b; } } public class ChildClass { public static void main(String[] args) { A a = new ...
socket.io-client 实时通讯，用socket.io-client的坑
沐枫
09-20 1万+
前言： 由于项目需要，前端所渲染的数据，要从后端(PHP)实时主动推送到前端（前端也可以实时主动推送到后端，以前的做法是在前端用定时任务，隔多少时间后就请求一下后端API），所以就不像平时用Ajax、Fetch、Axios等来调用后端的API接口了，这次采用的是WebSocket方式（什么是WebSocket），现在的WebAPI中本身就支持WebSocket的，所有可以前端可以直接调，但是使用...
Python学习（22）python网络编程
weixin_34293246的博客
04-21 183
Python 网络编程 Python 提供了两个级别访问的网络服务。： 低级别的网络服务支持基本的 Socket，它提供了标准的 BSD Sockets API，可以访问底层操作系统Socket接口的全部方法。 高级别的网络服务模块 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。 什么是 Socket? Socket又称"套接字"，应用程序通常通...
2021-01-22网络协议学习
qq_51324662的博客
01-25 17
软件开发架构： ·bs架构 ·cs架构 #本质bs和cs是一致的 一个简单的web框架： #http协议 网络协议 数据传输明文 #https协议 网络协议 数据传输密文 #websocket协议 网络协议 数据传输密文 http协议 1.基于请求响应 2.基于tcp，ip作用于应用层之上的协议 3.无状态 4.短/无链接 数据格式 1.请求首行 2.请求头 3.请求体 响应状态码 1xx 2xx 3xx 4xx 5xx ...
2021-01-24
boybs的博客
01-24 14
Linux内核驱动基础框架（在树莓派中运行） 一、准备工作 首先自己写一个驱动的框架以模块的形式模块的形式（在Linux中写一个框架名为drivepin4.c 已经测试程序 drive_pin4.c ） //drivepin4.c #include <linux/fs.h> #include <linux/module.h> #include <linux/init.h> #include <linux/device.h> #include <lin
pyinstaller打包py文件时如果有import socket则不要使用-w参数
dugushangliang的博客
09-12 1395
版权声明：转载请注明作者（独孤尚良dugushangliang）出处：https://blog.csdn.net/dugushangliang/article/details/100762354 socket需要使用到命令行，如果pyinstaller的打包参数含有-w则会出现错误。本例打包时的语句为： pyinstaller --onefile fa.py -w 导致的结果是：报错...
DirectX修复工具V4.0增强版
06-13
DirectX修复工具(DirectX Repair)是一款系统级工具软件，简便易用。本程序为绿色版，无需安装，可直接运行。 本程序的主要功能是检测当前系统的DirectX状态，如果发现异常则进行修复
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页