python----socket编程（二）

复制代码
import socket

UDP_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)  #先创建基于这种通信协议的对象
client_IP_port = ("127.0.0.1",8080)     #通信IP地址和端口

while True:      #通信循环
    inp = input(">>>:").strip()  #交互
    UDP_client.sendto(inp.encode("utf-8"),client_IP_port) #与服务端建立通信，发送消息，格式:（data,服务器通信地址）
    data,server_addr = UDP_client.recvfrom(1024)   #收到返回的消息
    print(data.decode("utf-8"))  #打印
复制代码

复制代码
#coding:utf-8
import socket,subprocess,struct
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
IP_port = ("127.0.0.1",8080)
phone.bind(IP_port)

phone.listen(5)

while True:
    conn,addr = phone.accept()
    print("client addr:",addr)
    while True:
        try:
            cmd = conn.recv(1024).decode("utf-8")
            res = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
            out_res = res.stdout.read()
            err_res = res.stderr.read()
            data_size = len(out_res)+len(err_res)

            #发送报头（数据的大小）
            conn.send(struct.pack("i",data_size))
            #发送数据部分
            conn.send(out_res)
            conn.send(err_res)
        except Exception:
            break
    conn.close()
phone.close()
复制代码

复制代码
import socket,struct
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
IP_port = ("127.0.0.1",8080)
phone.connect(IP_port)

while True:
    cmd = input(">>>:").strip()
    if not cmd:continue
    phone.send(bytes(cmd,encoding="utf-8"))

    #收报头
    header = phone.recv(4)
    data_size = struct.unpack("i",header)[0]

    #收数据
    recv_size = 0
    recv_data = b‘‘
    while recv_size < data_size:
        data = phone.recv(1024)
        recv_size += len(data)
        recv_data += data
    print(recv_data.decode("utf-8"))

phone.close()
复制代码

复制代码
#coding:utf-8
#首先明确一点：
#1、不管是发数据或是接收数据，都是先发送到缓存中，或是从缓存中读取！
#2、TCP协议为了传输数据，有自己的处理方法：为了避免网络延迟导致的数据传输问题，对很小的多段数据，会和到一起处理成一个大的数据包，然后再发送
#或者是一次性发送的数据过大，大于自定义的最大接收数据的值，数据就会先被接收一部分，剩余的还存在缓存之中不会丢失。
#这样再发送新数据的话，就会和上次剩余的数据在缓存中拼接在一起。这两种情况都会导致 粘包
#3、基于socket的TCP协议通信，在通信管道中数据是以 字节数据流 的形式传输，对于这个数据流我们不知道它是从哪里开始，有是到哪里结束。

#为了避免粘包，在传递真实数据之前，先自定义一个报头，报头中写入要传递的数据的信息，先把报头的长度 打包 发送给客户端；
# 客户端拿到数据之后，解包收到的内容（即报头的长度），然后再根据收到的数据 自定义接收报头的 字节 长度（减少缓存中的占用，需要多少用多少）；
#服务端再将已经转码成字节格式的报头发送给客户端，客户端接收到报头之后，将字节转码成字符串，然后利用json将字符串类型的数据转成真实的数据类型（字典）；
#然后客户端在得到的字典中获取真实数据的大小，根据这个大小获取服务端发送给客户端所有的数据，进行 循环 接收；
# 避免大数据传输中一次性接收，设备缓存的资源不足问题。同时数据不接收完不打印，避免粘包。

import socket,subprocess,struct,json
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #先声明一个基于socket通信对象
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #处理time_wait
IP_port = ("127.0.0.1",8080)  #服务端唯一通信地址和端口
phone.bind(IP_port)    #作为本机的唯一标签，绑定到本机

phone.listen(5)  #等待通信

while True: #连接循环
    conn,addr = phone.accept()  #等待连接
    print("client addr:",addr)
    while True:  #通讯循环
        try: #异常判断
            cmd = conn.recv(1024).decode("utf-8")   #接收从客户端发来的数据（bytes数据）
                          # 1024 指定义的从缓存中一次拿取数据的最大量，取值范围是（单位：字节）：0-1024
            res = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)  #在当前操作系统中执行操作
            out_res = res.stdout.read()  #正确的命令，按照操作得到正确的内容 （bytes数据）
            err_res = res.stderr.read()  #错误的命名，得到错误的提示   （bytes数据）
            data_size = len(out_res)+len(err_res)   #计算得到的数据 字节长度

            #报头内容
            head_dic = {"data_size":data_size}  #做一个字典格式的报头，里边囊括所有关于真实数据的信息

            head_json = json.dumps(head_dic)   #将字典类型的报头转成json格式的字符串
            head_bytes = head_json.encode("utf-8")  #将字符串转成bytes，因为socket通信传输的都是字节数据

            #part1:先发送报头长度
            conn.send(struct.pack("i",len(head_json)))  #将报头的长度打包发送（字符串格式的长度）

            #part2:再发送报头
            conn.send(head_bytes)  #将报头发送

            #part3:发送数据
            conn.send(out_res)  #将真实的数据发送
            conn.send(err_res)
        except Exception:   #捕获异常
            break  #退出
    conn.close()    #关闭通讯
phone.close()
复制代码

复制代码
#coding:utf-8
import socket,struct,json

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #先声明一个基于socket通信对象
IP_port = ("127.0.0.1",8080)   #连接地址
phone.connect(IP_port)   #与服务端建立通信连接
#通讯循环
while True:
    #发消息
    cmd = input(">>>:").strip()  #用户交互发送消息
    if not cmd:continue
    phone.send(bytes(cmd,encoding="utf-8"))

    #part1:先收报头的长度
    head_struct = phone.recv(4)  #收到从服务端返回的报头数据
    head_len = struct.unpack("i",head_struct)[0]  #解包字节数据，获取报头的长度

    #part2:再收报头
    head_bytes = phone.recv(head_len)   #根据报头的长度，接收报头（字节数据）
    head_json = head_bytes.decode("utf-8")  #将接收到的报头转码成字符串
    head_dic = json.loads(head_json)  #再将json字符串，反序列化成字典
    print(head_dic)

    data_size = head_dic["data_size"]   #获取真实数据的大小

    #part3:收数据
    recv_size = 0
    recv_data = b‘‘
    while recv_size < data_size:  #循环从缓存中获取真实数据，不取完不打印
        data = phone.recv(1024)
        recv_size += len(data)
        recv_data += data
    print(recv_data.decode("utf-8"))

phone.close()
复制代码

复制代码
#基于TCP协议实现 多并发 服务端 编写模版
import socketserver  #导入socketserver模块

class 类名(socketserver.BaseRequestHandler):  #建立通讯  class创建一个类名继承 socketserver.BaseRequestHandler 父类
    def handle(self):  #注意此处没有__init__而是直接引用handle(self):函数，实例化对象直接调用此方法
        print("=-====>",self)
        # print(self.request)
        while True:  #通信循环 （这里就可以任意编写）
            server = self.request  #建立通讯连接，与tcp协议中accept功能一致！收到的是client_addr的通信线路
            data = server.recv(1024)  #接收数据
            print(data.decode("utf-8"))
            server.send(data.upper())  #发送数据

IP_port = ("IP地址",端口)  #给定唯一的地址
if __name__ == ‘__main__‘:  #判断是否为主函数
    obj = socketserver.ThreadingTCPServer(IP_port,类名)#实例化一个 TCP服务 对象（绑定地址，创建的类）
    obj.serve_forever() #该对象建立链接循环
复制代码

复制代码
#基于UDP协议实现 多并发 服务端 编写模版
import socketserver  #导入socketserver模块

class 类名(socketserver.BaseRequestHandler): #建立通讯  class创建一个类名继承 socketserver.BaseRequestHandler 父类
    def handle(self): #注意此处没有__init__而是直接继承引用handle(self):函数，实例化对象直接调用此方法
#        print("=-====>",self)
        data = self.request[0]       #从客户端收到的数据
        print(data.decode("utf-8"))  #打印
        UDP_server_conn = self.request[1] #建立通讯连接，得到一个客户端与服务端连接建立的套接字对象！
        UDP_client = self.client_address  #获取服务端的地址
        msg = input(">>>:").strip()   #回复内容
        UDP_server_conn.sendto(msg.encode(‘utf-8‘),UDP_client)  #服务端像客户端发送内容（内容，和服务端建立连接的客户端地址）

IP_Port = (‘IP地址‘,端口)  #唯一通信地址

if __name__ == ‘__main__‘: #判断是否为主函数
    obj=socketserver.ThreadingUDPServer(IP_Port,类名) #实例化一个 UDP服务 对象（绑定地址，创建的类）
    obj.serve_forever()  #建立链接循环
复制代码

复制代码
import socketserver

class FTPserver(socketserver.BaseRequestHandler):  #通讯
    def handle(self):
        print("=-====>",self)
        # print(self.request)
        while True:
            server = self.request
            data = server.recv(1024)
            print(data.decode("utf-8"))
            server.send(data.upper())

IP_port = ("127.0.0.1",8080)
if __name__ == ‘__main__‘:
    obj = socketserver.ThreadingTCPServer(IP_port,FTPserver)
    obj.serve_forever() #链接循环
复制代码

复制代码
#coding:utf-8
import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #基于TCP/IP协议通信
phone.connect(("127.0.0.1",8080))  #主动初始化TCP服务器连接 发起连接(必须是元组形式，前边是地址，后边是接口)

while True:     #通信循环
    inp = input(">>>:").strip()
    if not inp:continue
    phone.send(inp.encode("utf-8")) #字节数据 向服务端传值

    data = phone.recv(1024)   #接收服务端返回的数据
    print(data.decode("utf-8"))

phone.close()
复制代码

复制代码
#coding:utf-8
import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #基于TCP/IP协议通信
phone.connect(("127.0.0.1",8080))  #主动初始化TCP服务器连接 发起连接(必须是元组形式，前边是地址，后边是接口)

while True:     #通信循环
    inp = input(">>>:").strip()
    if not inp:continue
    phone.send(inp.encode("utf-8")) #字节数据 向服务端传值

    data = phone.recv(1024)   #接收服务端返回的数据
    print(data.decode("utf-8"))

phone.close()
复制代码

复制代码
import socketserver  #导入socketserver模块

class UDPServer(socketserver.BaseRequestHandler): #建立通讯  class创建一个类名继承 socketserver.BaseRequestHandler 父类
    def handle(self): #注意此处没有__init__而是直接继承引用handle(self):函数，实例化对象直接调用此方法
#        print("=-====>",self)
        data = self.request[0]       #从客户端收到的数据
        print(data.decode("utf-8"))  #打印
        UDP_server_conn = self.request[1] #建立通讯连接，得到一个客户端与服务端连接建立的套接字对象！
        UDP_client = self.client_address  #获取服务端的地址
        msg = input(">>>:").strip()   #回复内容
        UDP_server_conn.sendto(msg.encode(‘utf-8‘),UDP_client)  #服务端像客户端发送内容（内容，和服务端建立连接的客户端地址）

IP_Port = (‘127.0.0.1‘,8080)  #唯一通信地址

if __name__ == ‘__main__‘: #判断是否为主函数
    obj=socketserver.ThreadingUDPServer(IP_Port,UDPServer) #实例化一个 UDP服务 对象（绑定地址，创建的类）
    obj.serve_forever()  #建立链接循环
复制代码

复制代码
import socket

UDP_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)  #先创建基于这种通信协议的对象
client_IP_port = ("127.0.0.1",8080)     #通信IP地址和端口

while True:      #通信循环
    inp = input(">>>:").strip()  #交互
    UDP_client.sendto(inp.encode("utf-8"),client_IP_port) #与服务端建立通信，发送消息，格式:（data,服务器通信地址）
    data,server_addr = UDP_client.recvfrom(1024)   #收到返回的消息
    print(data.decode("utf-8"))  #打印
复制代码

复制代码
import socket

UDP_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)  #先创建基于这种通信协议的对象
client_IP_port = ("127.0.0.1",8080)     #通信IP地址和端口

while True:      #通信循环
    inp = input(">>>:").strip()  #交互
    UDP_client.sendto(inp.encode("utf-8"),client_IP_port) #与服务端建立通信，发送消息，格式:（data,服务器通信地址）
    data,server_addr = UDP_client.recvfrom(1024)   #收到返回的消息
    print(data.decode("utf-8"))  #打印
复制代码