python笔记8 socket(TCP) subprocess模块 粘包现象 struct模块 基于UDP的套接字协议

socket

基于tcp协议socket

服务端

import socket

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 买电话
# socket.SOCK_STREAM 流式协议 就是TCP协议
phone.bind(('127.0.0.1', 8080))  # 买电话卡

phone.listen(5)  # 开机。
# 5 不是链接数，链接可以产生N个，同一时刻只能监听5个请求。

conn, addr = phone.accept() # 等待接电话  # 阻塞状态
# print(222)
print(conn, addr)  # conn 代表的是socket通信的对象，一个管道

client_data = conn.recv(1024)  # 交流过程
print(client_data)
conn.send(client_data.upper())

conn.close()
phone.close()

客户端

import socket

phone = socket.socket()  # 买电话

phone.connect(('127.0.0.1', 8080))  # 拨号

msg = input('>>>').strip()
phone.send(msg.encode('utf-8'))
server_data = phone.recv(1024)  # 限制的是最大接收字节数。
print(server_data)
phone.close()

服务端与客户端循环 聊

import socket
import subprocess
# socket.SOCK_STREAM 流式协议 就是TCP协议
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 买电话
phone.bind(('127.0.0.1', 8080))  # 绑定电话卡,写自己的IP  (俩括号)
phone.listen(5)   #开机   5不是限制连接数,而是同一时刻只接受5个请求,可以不写,不写为默认,默认可以开启N个
#运行后停在这里,下边不执行
while 1:
    conn,addr = phone.accept()  #等待接电话 phone.accept()  conn和addr分别接收phone..accept()生成的两个参数
    print(addr)  #打印连接进来的客户端
    while 1:
        try:
            client_data = conn.recv(1024)   #接受的字节数
            c = client_data.decode('gbk')
            obj = subprocess.Popen(c,
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE)
            RET = obj.stdout.read()
            RET1 = obj.stderr.read()
            print(RET.decode('gbk'))
            conn.send(RET+RET1) #返回的信息
        except Exception:
            break
    conn.close()
phone.close()

客户端

import socket
phone = socket.socket()
phone.connect(('127.0.0.1', 8080))  # 拨号,写服务端的IP  (俩括号)
while 1:
    fasong = input('>>>')
    if fasong.upper() == 'Q': break
    elif  not fasong :continue            #如果发送为空,则跳过本次循环 not False3 = True
    phone.send(fasong.encode('gbk'))       #刚给服务端发信息
    server_data = phone.recv(1024)    #接收服务端的信息,1024限制的是最大接受的字节数
    print(server_data.decode('gbk'))
phone.close()

subprocess模块

subprocess模块用于接收shell界面执行的命令并返回结果

import subprocess
obj = subprocess.Popen('ip a',          #输入命令
                        shell=True,           #shell为Tree
                       stdout=subprocess.PIPE,              #stdout接收正确
                       stderr=subprocess.PIPE)               #stderr接收错误返回
RET = obj.stdout.read()
print(RET.decode('utf-8'))        

粘包现象

tcp协议

1. 流式协议.数据全部都像水一样连在一起,一次性发送多字节(全部在客户端操作系统的缓存区),客户端每次只取1024字节,剩余字节在缓存区等待下次取

client_data = conn.recv(1024)    

server_data = phone.recv(1024)    

2.针对于(客户端/服务端)发送的连续的小的数据,对方会一次性接收.

客户端

import socket
phone = socket.socket()
phone.connect(('127.0.0.1', ))  # 拨号,写服务端的IP  (俩括号)
phone.send(b'hello')              #先发送hello
phone.send(b'word')               #紧接着在发送word
while :
    server_data = phone.recv()    #接收服务端的信息,1024限制的是最大接受的字节数
    print(server_data.decode('gbk'))
phone.close()

服务端

import socket
import subprocess
# socket.SOCK_STREAM 流式协议 就是TCP协议
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 买电话
phone.bind(('127.0.0.1', ))  # 绑定电话卡,写自己的IP  (俩括号)
phone.listen()   #开机   5不是限制连接数,而是同一时刻只接受5个请求,可以不写,不写为默认,默认可以开启N个
#运行后停在这里,下边不执行
conn,addr = phone.accept()  #等待接电话 phone.accept()  conn和addr分别接收phone..accept()生成的两个参数
print(addr)  #打印连接进来的客户端
while  :
    client_data = conn.recv()   #接受的字节数
    print(client_data)
    conn.send(client_data.upper()) #返回的信息
conn.close()
phone.close()

('127.0.0.1', )       #服务端接收客户端的信息连在了一起
b'helloword'

客户端

import socket
import time
phone = socket.socket()
phone.connect(('127.0.0.1', ))  # 拨号,写服务端的IP  (俩括号)
phone.send(b'hello')
time.sleep(0.1)                #等待0.1秒在发送word
phone.send(b'word')
while :
    server_data = phone.recv()    #接收服务端的信息,1024限制的是最大接受的字节数
    print(server_data.decode('gbk'))
phone.close()

服务端

import socket
import subprocess
# socket.SOCK_STREAM 流式协议 就是TCP协议
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 买电话
phone.bind(('127.0.0.1', ))  # 绑定电话卡,写自己的IP  (俩括号)
phone.listen()   #开机   5不是限制连接数,而是同一时刻只接受5个请求,可以不写,不写为默认,默认可以开启N个
#运行后停在这里,下边不执行
conn,addr = phone.accept()  #等待接电话 phone.accept()  conn和addr分别接收phone..accept()生成的两个参数
print(addr)  #打印连接进来的客户端
while  :
    client_data = conn.recv()   #接受的字节数
    print(client_data)
    conn.send(client_data.upper()) #返回的信息
conn.close()
phone.close()

('127.0.0.1', )               #接受的字符分开了
b'hello'
b'word'

解决粘包问题

发送固定头部,固定头部包含(数据的总大小) + 数据

struct模块  将一个数据,int 转化为固定的bytes

import struct
ret = struct.pack('i',)    #将151923212 转换为固定的bytes类型
print(ret,type(ret) ,len(ret),sep='\n') #sep='\n',将分隔符换为\n

ret1 = struct.unpack('i',ret)
print(ret1)

b'\x0c*\x0e\t'
<class 'bytes'>
4                         #转为固定的4字节
(,)

解决粘包问题代码

low版

一旦数据传入过大则struct模块报错, struct模块不能转译 较长的字符串

服务端:

将数据大小通过struct模块转为固定大小发给客户端

import socket
import subprocess
import struct
# socket.SOCK_STREAM 流式协议 就是TCP协议
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 买电话
phone.bind(('127.0.0.1', 8080))  # 绑定电话卡,写自己的IP  (俩括号)
phone.listen(5)   #开机   5不是限制连接数,而是同一时刻只接受5个请求,可以不写,不写为默认,默认可以开启N个
#运行后停在这里,下边不执行
conn,addr = phone.accept()  #等待接电话 phone.accept()  conn和addr分别接收phone..accept()生成的两个参数
print(addr)  #打印连接进来的客户端
while 1 :                            #以下为粘包解决方法
    try:
        client_data = conn.recv(1024)  # 接受的字节数
        obj = subprocess.Popen(client_data.decode('utf-8'),   #将接收的字节在本地shell执行 并返回结果
                               shell=True,
                               stdout=subprocess.PIPE,
                               stderr=subprocess.PIPE,)
        ret = obj.stdout.read()           #正确结果
        ret1 = obj.stderr.read()          #错误结果
        ss = len(ret1 + ret)               #算返回结果的总长度
        ret2 = struct.pack('i',ss)         #通过struct将算返回结果的总长度变为固定长度的bytes类型
        conn.send(ret2)    #发送报头
        conn.send(ret)      #发送正确结果
        conn.send(ret1)    #发送错误结果
    except Exception:
        break
conn.close()
phone.close()

客户端:

客户端根据服务端发来的内容大小取内容

import socket
import time
import struct

phone = socket.socket()
phone.connect(('127.0.0.1', 8080))  # 拨号,写服务端的IP  (俩括号)
while 1:
    msg = input('>>>').strip()          #输入发往服务端的内容,如果是q退出,如果是空从新输入
    if msg.upper() == 'Q':
        break
    elif not msg:         #not + 空就是 True 执行continue 重新输入
        continue
    phone.send(msg.encode('utf-8'))         #往服务端发送内容
    head = phone.recv(4)               #接收报头 报头大小为固定4字节
    head_size = struct.unpack('i', head)[0]          #直接将报头反解为服务端发送内容的长度,返回是元组,取第一个值
    datas = 0   　　 #定义一个datas大小为0
    res = b''       #定义一个空的bytes类型的变量
    while datas < head_size:     #如果datas小于发送的内容的总长度为真
        data = phone.recv(1024)   #取1024字节
        res = res + data                #将取出的内容追加到res里
        datas += len(data)            #datas加上取出内容字节的大小
    print(res.decode('gbk'))         #读出res里的内容

phone.close()

uper版

服务端:

将服务端发送数据大小写到字典,

将字典转为json,

再将json转为字符串,

取字符串长度给struct模块转为固定大小

将固定大小,bytes类型的字典以及所有数据传给客户端

import socket
import subprocess
import struct
import json
# socket.SOCK_STREAM 流式协议 就是TCP协议
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 买电话
phone.bind(('127.0.0.1', 8080))  # 绑定电话卡,写自己的IP  (俩括号)
phone.listen(5)   #开机   5不是限制连接数,而是同一时刻只接受5个请求,可以不写,不写为默认,默认可以开启N个
#运行后停在这里,下边不执行
conn,addr = phone.accept()  #等待接电话 phone.accept()  conn和addr分别接收phone..accept()生成的两个参数
print(addr)  #打印连接进来的客户端
while 1 :
    try:
        client_data = conn.recv(1024)  # 接受的字节数
        obj = subprocess.Popen(client_data.decode('utf-8'),
                               shell=True,
                               stdout=subprocess.PIPE,
                               stderr=subprocess.PIPE,)
        ret = obj.stdout.read()
        ret1 = obj.stderr.read()
        ss = len(ret1 + ret)
        head_dict = {                         #定义一个字典,total_size的值为发送数据的大小,字典里可定义多个键值传递多种信息
            'total_size':ss
        }
        head_json = json.dumps(head_dict)       #将字典转为json格式
        head_bytes = head_json.encode('utf-8')  #再将json格式转为bytes格式
        ret2 = struct.pack('i',len(head_bytes))   #将转为bytes格式的长度通过struct转为固定字节

        conn.send(ret2)             #发送固定字节
        conn.send(head_bytes)     #发送bytes类型的字典
        conn.send(ret)                #发送内容
        conn.send(ret1)
    except Exception:
        break
conn.close()
phone.close()

客户端:

将服务端发送的头部大小获取字典大小

通过字典大小获取内容大小

通过内容大小获取内容

import socket
import json
import struct

phone = socket.socket()
phone.connect(('127.0.0.1', 8080))  # 拨号,写服务端的IP  (俩括号)
while 1:
    msg = input('>>>').strip()
    if msg.upper() == 'Q':
        break
    elif not msg:
        continue
    phone.send(msg.encode('utf-8'))
    he = struct.unpack('i', phone.recv(4))[0]   #将头部的大小(phone.recv(4))通过struct模块解析出字典bytes类型的大小
    head_dic_bytes = phone.recv(he)             #通过解析出字典bytes类型的大小获取bytes类型字典的数据
    head_json = head_dic_bytes.decode('utf-8')  #将bytes数据反解为json类型
    head_doc = json.loads(head_json)            #反解json获得字典
    datas = 0
    res = b''
    while datas < head_doc['total_size']:       #将字典total_size键对应的内容大小的值取出,获得内容
        data = phone.recv(1024)
        res = res + data
        datas += len(data)
    print(res.decode('gbk'))

phone.close()

基于UDP的套接字协议

服务端

import socket
udp_sk = socket.socket(type=socket.SOCK_DGRAM)   # (type=socket.SOCK_DGRAM)基于UDP的套接字TCP为socket.AF_INET, socket.SOCK_STREAM

udp_sk.bind(('127.0.0.1', 10000))     #绑定服务器套接字

while 1:
    msg, addr = udp_sk.recvfrom(1024) #tcp里的accept()里的recv() 是阻塞的 这里的recvfrom(1024)是非阻塞的
    print(msg.decode('utf-8'))        #打印内容
    udp_sk.sendto(b'hi',addr)         #返回给客户端的内容

客户端

import socket
ip = ('127.0.0.1',10000)                            #创建个IP
udp_sk=socket.socket(type=socket.SOCK_DGRAM)        #开启udp的socket
while 1:
    sd = input('>>>').encode('utf-8')
    udp_sk.sendto(sd,ip)                             #给服务端发送内容
    back_msg,addr=udp_sk.recvfrom(1024)              #获取服务端回复的内容
    print(back_msg.decode('utf-8'),addr)             #打印服务端回复的内容
udp_sk.close()