Python--socket

socket网络编程：socket、socketserver

socket：{server，client}

socket_server示例：

import  socket # 导入模块
server = socket.socket() #实例化一个server
server.bind(('localhost', 6969)) # 绑定监听的地址和端口
server.listen() # 开始监听
while True: # 循环等待客户端的连接，当一个连接断开后，继续等待下个客户端的连接
    coon, addr = server.accept() # 等待客户端的连接，当有客户端连接时，conn,addr才有值
    while True: # 循环接收客户端的数据
        data = coon.recv(1024) #接收客户端的数据，接收数据大小为1K
        print("server recv:", data.decode()) #接收到的数据类型为b,需要decode
        if not data: # 如果无数据，则代表客户端断开
            print("client is lost...")
            break # 与客户端断开，等待下次客户端的连接
        coon.send(data.upper()) # 向客户端发送数据，注意将发送的数据encode()，此处data即为b类型，所以不需要
server.close() # 实例关闭

socket_client示例：

import  socket #导入模块
client = socket.socket() # 创建客户端实例
client.connect(('localhost', 6969)) # 实例连接服务端地址及端口
while True: # 循环接收用户输入并发送
    msg = input(">>:").strip() # 等待用户输入
    if len(msg.strip()) == 0: # 如果用户输入为空，则继续让用户输入
        continue
    client.send(msg.encode("utf-8")) # 将用户输入发送只server端
    data = client.recv(1024) # 接收server端发送的数据
    print("recv:", data.decode()) 
client.close() # 客户端关闭

应用：

1、 使用socket实现类似ssh登录后执行命令的操作

socket_ssh_server

import socket,os,time # 导入模块
server = socket.socket() # 实例化server
server.bind(('localhost',9999)) # server绑定地址和端口
server.listen() # 监听
while True:
    conn, addr = server.accept() # 等待客户端的连接
    print("new conn:",addr)
    while True:
        print("等待新指令")
        data = conn.recv(1024) # 接收客户端的指令
        if not data:
            print("客户端已断开")
            break
        print("执行指令:",data)
        cmd_res = os.popen(data.decode()).read() #使用os.popen执行收到的指令,返回结果赋值给cmd_res
        print("before send",len(cmd_res)) # 输出命令的长度
        if len(cmd_res) ==0: # 如果指令结果长度为0,则没此命令
            cmd_res = "cmd has no output..." 
        conn.send( str(len(cmd_res.encode())).encode("utf-8"))     #先发大小给客户端
        conn.recv(1024) # 等待客户端确认,防止发送指令大小和发送结果出现粘包现象
        conn.send(cmd_res.encode("utf-8")) # 发送指令输出结果
        print("send done")
server.close()

socket_ssh_client

import  socket # 导入模块
client = socket.socket() # 实例化客户端
client.connect(('localhost', 9999)) # 连接服务端
while True: # 循环接收用户输入
    data = input(">>:").strip()
    if len(data) == 0:continue
    client.send(data.encode("utf-8")) # 发送指令
    result_data_size = client.recv(1024) # 接收执行返回结果的大小
    print(result_data_size.decode()) 
    client.send(b"please send cmd result")
    recv_data_size = 0
    recv_data = b""
    while recv_data_size < int(result_data_size.decode()): # 当指令结果大小大于1024时,循环接收指令结果
        recv_data_block = client.recv(1024)
        recv_data_size += len(recv_data_block)
        recv_data += recv_data_block
    else:
        print(recv_data_size)
        print(recv_data.decode())
client.close()

2、 使用socket实现文件发送并计算MD5值

socket_file_server

import socket, os, hashlib #导入模块
server = socket.socket()
server.bind(("localhost", 9999))
server.listen()
while True:
    conn, addr = server.accept()
    print("新连接：", addr)
    while True:
        print("等待指令")
        data = conn.recv(1024)
        if not data:
            print("客户端已断开")
            break
        filename = data.split()[1]
        print("文件名：", filename)
        m = hashlib.md5()
        if os.path.isfile(filename):
            file_size = os.stat(filename).st_size
            conn.send(str(file_size).encode())
            conn.recv(1024)
            print("等待接收端确认")
            f = open(filename, "rb")
            for line in f:
                m.update(line)
                conn.send(line)
            f.close()
            conn.send(m.hexdigest().encode())
        print("file send done")
server.close()

socket_file_client

import  socket, hashlib
client = socket.socket()
client.connect(("localhost", 9999))
while True:
    cmd = input(">>:").strip()
    if len(cmd) == 0:continue
    if cmd.startswith("get"):
        client.send(cmd.encode())
        filename = cmd.split()[1]
        res_filesize = client.recv(1024).decode()
        print("文件总大小是",res_filesize)
        client.send("please send".encode())
        m = hashlib.md5()
        recv_size = 0
        f = open(filename+"new","wb")
        while recv_size < int(res_filesize):
            if int(res_filesize) - recv_size > 1024: # 解决文件发送与MD5发送的粘包问题
                size = 1024
            else:
                size = int(res_filesize) - recv_size
            data = client.recv(size)
            recv_size += len(data)
            m.update(data)
            f.write(data)
        else:
            print("文件接收完毕，源文件大小%s,已接收文件大小%s" % (res_filesize,recv_size))
            old_file_md5 = client.recv(1024).decode()
        f.close()
        print("new file md5: ", m.hexdigest())
        print("old file md5: ", old_file_md5)
client.close()

3、 socketserver示例

socketserver_server

import  socketserver # 导入模块
class MyTcpSocketServer(socketserver.BaseRequestHandler):  # 创建一个类,继承socketserver.BaseRequestHandler
    def handle(self): # 重写handle方法
        print(self.client_address)
        while True:
            try: #抓取客户端断开的异常
                self.data = self.request.recv(1024).strip() # 接收客户端的数据
                self.request.send(self.data.upper()) # 发送数据给客户端
            except ConnectionResetError as e:
                print("Error:", e)
                break

if __name__ == "__main__":
    HOST, PORT = "localhost", 9889
    print(">>>>等待新连接>>>>")
    server = socketserver.ThreadingTCPServer((HOST, PORT), MyTcpSocketServer) #实例化,ThreadingTCPServer可以实现多用户同时交互
    server.serve_forever()  # 永久接收客户端的请求

socketserver_client：直接使用socket模块即可

import  socket
client = socket.socket()
client.connect(("localhost",9889))
while True:
    data = input(">>:").strip()
    if len(data) == 0:continue
    client.send(data.encode())
    recv_data = client.recv(1024)
    print(recv_data)
client.close()

进阶

使用面向对象实现客户端文件上传到服务器端

socketserver_server

import  socketserver,json,os # 导入模块

class MyTcpServer(socketserver.BaseRequestHandler): # 创建socketserver类

    def put(self,*args):  # 接收文件函数
        file_dic = args[0]
        filename = file_dic["filename"]
        filesize = file_dic["size"]
        if os.path.isfile(filename):
            f = open(filename+".new","wb")
        else:
            f = open(filename,"wb")
        self.request.send(b"please send")
        recv_size = 0
        while recv_size < int(filesize):
            data = self.request.recv(1024)
            f.write(data)
            recv_size += len(data)
        else:
            print("接收完成")

    def handle(self): # 重写handle方法
        while True:
            try:
                self.data = self.request.recv(1024).strip()
                file_dic = json.loads(self.data.decode())
                action = file_dic["action"]
                if hasattr(self,action):  # 使用反射
                    func = getattr(self,action)
                    func(file_dic)
                else:
                    print("no action:", action)
            except Exception as e:
                print(e)
                break

if __name__ == "__main__":
    HOST,PORT = "localhost", 9999
    server = socketserver.ThreadingTCPServer((HOST,PORT), MyTcpServer)
    server.serve_forever()

socketserver_client

import  socket,os,json # 导入模块
class MyFtpClient(object): # 定义客户端类
    def __init__(self):
        self.client = socket.socket()  # 客户端初始化

    def connect(self,ip,port):
        self.client.connect((ip,port)) # 连接服务端

    def interactive(self):
        while True: # 循环接收用户输入
            cmd = input(">>:").strip()
            if len(cmd)==0:continue
            cmd_split = cmd.split()
            action = cmd_split[0]
            if hasattr(self,action):  # 使用反射判断有无用户输入的指令,没有时返回help
                func = getattr(self,action)
                func(cmd_split)
            else:
                self.help()

    def help(self):
        msg = '''
        ls
        pwd
        put filename
        cd ../..
        '''
        print(msg)
    def put(self,*args):  # 上传函数
        cmd_split = args[0]
        filename = cmd_split[1]
        if os.path.isfile(filename):  # 使用os模块判断文件是否存在
            filesize = os.stat(filename).st_size
            file_dic = {
                "action": "put",
                "filename": filename,
                "size": filesize,
                "overridden": True
            }
            self.client.send(json.dumps(file_dic).encode('utf-8'))
            self.client.recv(1024)
            f = open(filename,"rb")
            for line in f:
                self.client.send(line)
            else:
                print("send done")
        else:
            print(filename,"is nor exist")

client = MyFtpClient() # 实例化客户端
client.connect("localhost",9999) # 实例连接服务端
client.interactive() # 实例调用用户交互函数