• 网络编程



    socket通信


    1.简单的套接字通信
     1 import socket
     2 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     3 phone.bind(('127.0.0.1',8080))
     4 phone.listen(5)
     5 print('starting...')
     6 conn,client_addr = phone.accept()
     7 data = conn.recv(1024)
     8 conn.send(data.upper())
     9 conn.close()
    10 phone.close()
    服务端
    1 import socket
    2 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    3 phone.connect(('127.0.0.1',8080))
    4 phone.send('hello'.encode('utf-8'))
    5 data = phone.recv(1024)
    6 print(data)
    客户端
    2.加上通信循环
     1 import socket
     2 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     3 phone.bind(('127.0.0.1',8080))
     4 phone.listen(5)
     5 print('starting...')
     6 conn,client_addr = phone.accept()
     7 while True:
     8     data = conn.recv(1024)
     9     print('%s 客户端发的数据'%str(client_addr),data)
    10     conn.send(data.upper())
    11 conn.close()
    12 phone.close()
    服务端
    1 import socket
    2 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    3 phone.connect(('127.0.0.1',8080))
    4 while True:
    5     msg = input('msg>>>:').strip()
    6     phone.send(msg.encode('utf-8'))
    7     data = phone.recv(1024)
    8     print('服务端返回的数据:',data)
    9 phone.close()
    客户端
    3.bug 修复
     1 import socket
     2 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     3 #如果遇到:Address already in use,需要socket配置,重用ip和端口,这里适合windows
     4 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
     5 phone.bind(('127.0.0.1',8080))
     6 phone.listen(5)
     7 print('starting...')
     8 conn,client_addr = phone.accept()
     9 while True:
    10     try:  # client断开,这里适合windows
    11         data = conn.recv(1024)
    12         if not data:break  # client断开,这里适合linux
    13         print(data)
    14         conn.send(data.upper())
    15     except ConnectionResetError as e:
    16         print(e)
    17         break
    18 conn.close()
    19 phone.close()
    服务端
     1 import socket
     2 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     3 phone.connect(('127.0.0.1',8080))
     4 while True:
     5     msg = input('msg>>>:').strip()
     6     if not msg: continue   # 不能发 '' 空 数据 因为数据传给了 os os收到空 不会处理传到server端
     7     phone.send(msg.encode('utf-8'))  # 发送数据 将str型转成bytes型
     8     data = phone.recv(1024)
     9     print(data.decode('utf-8')) # 收数据 将bytes型转成str型
    10 phone.close()
    客户端
    4.加上链接循环
     1 import socket
     2 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     3 phone.bind(('127.0.0.1',8080))
     4 phone.listen(5)
     5 print('starting...')
     6 while True:
     7     conn,client_addr = phone.accept()
     8     while True:
     9         try:
    10             data = conn.recv(1024)
    11             if not data:break
    12             print('%s 的数据'%str(client_addr),data)
    13             conn.send(data.upper())
    14         except ConnectionResetError as e:
    15             # print(e)
    16             break
    17     conn.close()
    18 phone.close()
    服务端
     1 import socket
     2 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     3 phone.connect(('127.0.0.1',8080))
     4 while True:
     5     msg = input("msg>>>:").strip()
     6     if not msg:continue
     7     phone.send(msg.encode('utf-8'))
     8     data = phone.recv(1024)
     9     print(data.decode('utf-8'))
    10 phone.close()
    客户端
    5.模拟ssh远程执行命令
     1 import subprocess
     2 obj = subprocess.Popen('dir d:',shell=True,
     3                  stdout=subprocess.PIPE, # 正确的结果
     4                  stderr=subprocess.PIPE) # 错误的结果
     5 
     6 print('1:',obj.stdout.read().decode('gbk'))
     7 print('2:',obj.stderr.read())
     8 
     9 import socket
    10 import subprocess
    11 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    12 phone.bind(('127.0.0.1',8080))
    13 phone.listen(5)
    14 print('starting...')
    15 while True:
    16     conn,client_addr = phone.accept()
    17     print(client_addr)
    18     while True:
    19         try:
    20             cmd = conn.recv(1024)
    21             if not cmd: break
    22             print(cmd)
    23             obj = subprocess.Popen(cmd.decode('utf-8'),shell=True,
    24                              stdout=subprocess.PIPE,
    25                              stderr=subprocess.PIPE)
    26             stdout = obj.stdout.read()
    27             stderr = obj.stderr.read()
    28 
    29             print(len(stdout)+len(stderr))
    30 
    31             conn.send(stdout)
    32             conn.send(stderr)  # 这样写比两个加起来 效率高 因为底层粘包不会影响 若是加起来就会新开一块内存
    33         except ConnectionResetError as e:
    34             break
    35     conn.close()
    36 
    37 phone.close()
    服务端
     1 import socket
     2 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     3 phone.connect(('127.0.0.1',8080))
     4 while True:
     5     cmd = input('cmd>>>:').strip()
     6     if not cmd:continue  # 一定要写 不允许发空
     7     phone.send(cmd.encode('utf-8'))
     8     data = phone.recv(1024)  # 这里如果收到的数据 > 1024 就发生了粘包
     9     print(len(data))
    10     print(data.decode('gbk'))  # linux 是gbk  windows是utf-8
    11 
    12 phone.close()
    客户端

    粘包

    6.粘包
     1 # 数据量比较小 时间比较短 才会发生粘包
     2 # 解决粘包的办法:
     3 # 明确知道对方给我发的包的长度
     4 
     5 import socket
     6 server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     7 server.bind(('127.0.0.1',8080))
     8 server.listen(5)
     9 conn,client_addr = server.accept()
    10 res1 = conn.recv(3)
    11 print(res1.decode('utf-8'))
    12 res2 = conn.recv(3)
    13 print(res2)
    14 res3 = conn.recv(10)
    15 print(res3)
    16 
    17 print(len('我们'.encode('utf-8')))  # len() 中文表示的是字符的长度  转成bytes型 len() 表示字节长度
    服务端
    1 # send recv 不是一一对应,一发可以多收,一收可以多发
    2 import socket
    3 client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    4 client.connect(('127.0.0.1',8080))
    5 client.send('我们'.encode('utf-8'))
    6 client.send(b'hello')
    7 client.send(b'world')
    客户端
    7.解决粘包 简单版
     1 # struct模块 介绍
     2 import struct
     3 import json
     4 # struct 模块可以将很长的一个数字压缩成4位
     5 # i 有限的 若数字过大,会报错
     6 # q Q d 是8位  i l L 是4位  d 不会报错
     7 
     8 res = struct.pack('i',23213123)
     9 print(res,len(res),type(res))
    10 # b'C4bx01' 4 <class 'bytes'>
    11 data = struct.unpack('i',res)
    12 print(data)
    13 # (23213123,)
    14 
    15 header_dic = {
    16     'filename': 'a.txt',
    17     'md5': '我们',
    18     'total_size':1231142342342342323423432423234234
    19 }
    20 header_json = json.dumps(header_dic)
    21 print(len(header_json.encode('utf-8')))
    22 header_bytes = header_json.encode('utf-8')
    23 res = struct.pack('i',len(header_bytes))
    24 print(res,len(res))
    25 data = struct.unpack('i',res)
    26 print(data)
    struct 模块
     1 import socket
     2 import subprocess
     3 import struct
     4 server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     5 server.bind(('127.0.0.1',8080))
     6 server.listen(5)
     7 print('starting...')
     8 while True:
     9     conn,client_addr = server.accept()
    10     print(client_addr)
    11     while True:
    12         try:
    13             cmd = conn.recv(1024)
    14             if not cmd:continue
    15             print(cmd)
    16             obj = subprocess.Popen(cmd.decode('utf-8'),shell=True,
    17                              stdout=subprocess.PIPE,
    18                              stderr=subprocess.PIPE)
    19             stdout = obj.stdout.read()
    20             stderr = obj.stderr.read()
    21             total_size = len(stdout) + len(stderr)
    22 
    23             print(total_size)
    24             header = struct.pack('i',total_size)
    25             conn.send(header)
    26             conn.send(stdout)
    27             conn.send(stderr)
    28         except ConnectionResetError as e:
    29             # print(e)
    30             break
    31     conn.close()
    32 
    33 server.close()
    服务端
     1 import socket
     2 import struct
     3 client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     4 client.connect(('127.0.0.1',8080))
     5 while True:
     6     cmd = input('>>>:').strip()
     7     if not cmd: continue
     8     client.send(cmd.encode('utf-8'))
     9     obj = client.recv(4)
    10     total_size = struct.unpack('i',obj)[0]
    11 
    12     # recv_data = client.recv(total_size)  # 不能这样做 因为total_size 很可能很大,
    13                                            # 有关部门建议的不要超过8192,再大反而会出现影响收发速度和不稳定的情况
    14     recv_size = 0
    15     recv_data = b'' # 这里不能写 None
    16     while recv_size < total_size:
    17         res = client.recv(1024)
    18         recv_data += res
    19         recv_size += len(res)
    20 
    21     print(recv_data.decode('gbk')) # linux 是utf-8 windows 是gbk
    22 
    23 client.close()
    客户端
    8.解决粘包 终极版
     1 import socket
     2 import subprocess
     3 import struct
     4 import pickle
     5 
     6 server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     7 server.bind(('127.0.0.1',8080))
     8 server.listen(5)
     9 print('starting...')
    10 while True:
    11     conn,client_addr = server.accept()
    12     print(client_addr)
    13     while True:
    14         try:
    15             cmd = conn.recv(1024)
    16             if not cmd:continue
    17             obj = subprocess.Popen(cmd.decode('utf-8'),shell=True,
    18                                    stdout=subprocess.PIPE,
    19                                    stderr=subprocess.PIPE)
    20             stdout = obj.stdout.read()
    21             stderr = obj.stderr.read()
    22             total_size = len(stdout) + len(stderr)
    23 
    24             header_dic = {
    25                 'filename':'a.txt',
    26                 'md5': 'xxxxxx',
    27                 'total_size':total_size
    28             }
    29             header_bytes = pickle.dumps(header_dic)
    30             conn.send(struct.pack('i',len(header_bytes)))
    31             conn.send(header_bytes)
    32             conn.send(stdout)
    33             conn.send(stderr)
    34 
    35         except ConnectionResetError:
    36             break
    37     conn.close()
    38     
    39 server.close()
    服务端
     1 import socket
     2 import struct
     3 import pickle
     4 client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     5 client.connect(('127.0.0.1',8080))
     6 while True:
     7     cmd = input('>>>:').strip()
     8     if not cmd: continue
     9     client.send(cmd.encode('utf-8'))
    10     header = client.recv(4)
    11     header_size = struct.unpack('i',header)[0]
    12     header_bytes = client.recv(header_size)
    13     header_dic = pickle.loads(header_bytes)
    14     print(header_dic)
    15     total_size = header_dic['total_size']
    16 
    17     recv_size = 0
    18     recv_data = b''
    19     while recv_size < total_size:
    20         res = client.recv(1024)
    21         recv_data += res
    22         recv_size += len(res)
    23     print(recv_data.decode('gbk'))
    24 
    25 client.close()
    客户端
    文件传输

    9.文件传输 简单版
     1 import socket
     2 import os
     3 import struct
     4 import pickle
     5 
     6 dirname = os.path.dirname(os.path.abspath(__file__))
     7 filepath = os.path.join(dirname,'share')
     8 
     9 server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    10 server.bind(('127.0.0.1',8080))
    11 server.listen(5)
    12 print('starting...')
    13 while True:
    14     conn,client_addr = server.accept()
    15     print(client_addr)
    16     while True:
    17         try:
    18             res = conn.recv(1024)
    19             if not res:continue
    20             cmds = res.decode('utf-8').split()
    21             filename = cmds[1]
    22 
    23             file_path = os.path.join(filepath,filename)
    24             if os.path.isfile(file_path):
    25                 header = {
    26                     'filename': filename,
    27                     'md5': 'xxxxxx',
    28                     'file_size': os.path.getsize(file_path)
    29                 }
    30                 header_bytes = pickle.dumps(header)
    31                 conn.send(struct.pack('i',len(header_bytes)))
    32                 conn.send(header_bytes)
    33 
    34                 with open(file_path,'rb') as f:
    35                     for line in f:
    36                         conn.send(line)
    37             else:
    38                 conn.send(struct.pack('i',0))
    39         except ConnectionResetError:
    40             break
    41     conn.close()
    42 
    43 server.close()
    服务端
     1 import socket
     2 import struct
     3 import pickle
     4 import os
     5 
     6 dirname = os.path.dirname(os.path.abspath(__file__))
     7 filepath = os.path.join(dirname,'download')
     8 
     9 client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    10 client.connect(('127.0.0.1',8080))
    11 while True:
    12     msg = input(">>>:").strip()  # get a.txt
    13     if not msg:continue
    14     client.send(msg.encode('utf-8'))
    15     obj = client.recv(4)
    16     header_size = struct.unpack('i',obj)[0]
    17     if header_size == 0:
    18         print('文件不存在')
    19     else:
    20         header_types = client.recv(header_size)
    21         header_dic = pickle.loads(header_types)
    22         print(header_dic)
    23         file_size = header_dic['file_size']
    24         filename = header_dic['filename']
    25 
    26         with open('%s/%s' % (filepath, filename), 'wb') as f:
    27             recv_size = 0
    28             while recv_size < file_size:
    29                 res = client.recv(1024)
    30                 f.write(res)
    31                 recv_size += len(res)
    32                 print('总大小:%s 已下载:%s'%(file_size,recv_size))
    33 
    34 client.close()
    客户端
    10.文件传输 优化版
     1 import socket
     2 import os
     3 import struct
     4 import pickle
     5 
     6 dirname = os.path.dirname(os.path.abspath(__file__))
     7 filepath = os.path.join(dirname, 'share')
     8 
     9 
    10 def get(cmds,conn):
    11     filename = cmds[1]
    12     file_path = os.path.join(filepath, filename)
    13     if os.path.isfile(file_path):
    14         header = {
    15             'filename': filename,
    16             'md5': 'xxxxxx',
    17             'file_size': os.path.getsize(file_path)
    18         }
    19         header_bytes = pickle.dumps(header)
    20         conn.send(struct.pack('i', len(header_bytes)))
    21         conn.send(header_bytes)
    22 
    23         with open(file_path, 'rb') as f:
    24             for line in f:
    25                 conn.send(line)
    26     else:
    27         conn.send(struct.pack('i', 0))
    28 
    29 
    30 def put(cmds,conn):
    31     pass
    32 
    33 
    34 def run():
    35     server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    36     server.bind(('127.0.0.1', 8080))
    37     server.listen(5)
    38     print('starting...')
    39     while True:
    40         conn, client_addr = server.accept()
    41         print(client_addr)
    42         while True:
    43             try:
    44                 res = conn.recv(1024)
    45                 if not res: continue
    46                 cmds = res.decode('utf-8').split()
    47                 if cmds[0] == 'get':
    48                     get(cmds,conn)
    49                 elif cmds[0] == 'put':
    50                     put(cmds,conn)
    51             except ConnectionResetError:
    52                 break
    53         conn.close()
    54 
    55     server.close()
    56 
    57 
    58 if __name__ == '__main__':
    59     run()
    服务端
     1 import socket
     2 import struct
     3 import pickle
     4 import os
     5 
     6 dirname = os.path.dirname(os.path.abspath(__file__))
     7 filepath = os.path.join(dirname,'download')
     8 
     9 
    10 def get(client):
    11     obj = client.recv(4)
    12     header_size = struct.unpack('i', obj)[0]
    13     if header_size == 0:
    14         print('文件不存在')
    15     else:
    16         header_types = client.recv(header_size)
    17         header_dic = pickle.loads(header_types)
    18         print(header_dic)
    19         file_size = header_dic['file_size']
    20         filename = header_dic['filename']
    21 
    22         with open('%s/%s' % (filepath, filename), 'wb') as f:
    23             recv_size = 0
    24             while recv_size < file_size:
    25                 res = client.recv(1024)
    26                 f.write(res)
    27                 recv_size += len(res)
    28                 print('总大小:%s 已下载:%s' % (file_size, recv_size))
    29 
    30 
    31 def put():
    32     pass
    33 
    34 
    35 def run():
    36     client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    37     client.connect(('127.0.0.1',8080))
    38     while True:
    39         msg = input(">>>:").strip()  # get a.txt
    40         if not msg:continue
    41         client.send(msg.encode('utf-8'))
    42 
    43         cmds = msg.split()
    44         if cmds[0] == 'get':
    45             get(client)
    46         elif cmds[0] == 'put':
    47             put()
    48 
    49     client.close()
    50 
    51 
    52 if __name__ == '__main__':
    53     run()
    客户端
    11.文件传输 面向对象版本
      1 import socket
      2 import os
      3 import struct
      4 import pickle
      5 
      6 
      7 class TCPServer:
      8     address_family = socket.AF_INET
      9     socket_type = socket.SOCK_STREAM
     10     listen_count = 5
     11     max_recv_bytes = 8192
     12     coding = 'utf-8'
     13     allow_reuse_address = False
     14     # 下载的文件存放路径
     15     down_filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'share')
     16     # 上传的文件存放路径
     17     upload_filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'upload')
     18 
     19     def __init__(self,server_address,bind_and_listen=True):
     20         self.server_address = server_address
     21         self.socket = socket.socket(self.address_family,self.socket_type)
     22 
     23         if bind_and_listen:
     24             try:
     25                 self.server_bind()
     26                 self.server_listen()
     27             except Exception:
     28                 self.server_close()
     29 
     30     def server_bind(self):
     31         if self.allow_reuse_address:
     32             self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
     33         self.socket.bind(self.server_address)
     34 
     35     def server_listen(self):
     36         self.socket.listen(self.listen_count)
     37 
     38     def server_close(self):
     39         self.socket.close()
     40 
     41     def server_accept(self):
     42         return self.socket.accept()
     43 
     44     def conn_close(self,conn):
     45         conn.close()
     46 
     47     def run(self):
     48         print('starting...')
     49         while True:
     50             self.conn,self.client_addr = self.server_accept()
     51             print(self.client_addr)
     52             while True:
     53                 try:
     54                     res = self.conn.recv(self.max_recv_bytes)
     55                     if not res:continue
     56                     cmds = res.decode(self.coding).split()
     57                     if hasattr(self,cmds[0]):
     58                         func = getattr(self,cmds[0])
     59                         func(cmds)
     60                 except Exception:
     61                     break
     62             self.conn_close(self.conn)
     63 
     64     def get(self,cmds):
     65         """ 下载
     66         1.找到下载的文件
     67         2.发送 header_size
     68         3.发送 header_bytes file_size
     69         4.读文件 rb 发送 send(line)
     70         5.若文件不存在,发送0 client提示:文件不存在
     71         :param cmds: 下载的文件 eg:['get','a.txt']
     72         :return:
     73         """
     74         filename = cmds[1]
     75         file_path = os.path.join(self.down_filepath, filename)
     76         if os.path.isfile(file_path):
     77             header = {
     78                 'filename': filename,
     79                 'md5': 'xxxxxx',
     80                 'file_size': os.path.getsize(file_path)
     81             }
     82             header_bytes = pickle.dumps(header)
     83             self.conn.send(struct.pack('i', len(header_bytes)))
     84             self.conn.send(header_bytes)
     85             with open(file_path, 'rb') as f:
     86                 for line in f:
     87                     self.conn.send(line)
     88         else:
     89             self.conn.send(struct.pack('i', 0))
     90 
     91     def put(self,cmds):
     92         """ 上传
     93         1.接收4个bytes  得到文件的 header_size
     94         2.根据 header_size  得到 header_bytes  header_dic
     95         3.根据 header_dic  得到 file_size
     96         3.以写的形式 打开文件 f.write()
     97         :param cmds: 下载的文件 eg:['put','a.txt']
     98         :return:
     99         """
    100         obj = self.conn.recv(4)
    101         header_size = struct.unpack('i', obj)[0]
    102         header_bytes = self.conn.recv(header_size)
    103         header_dic = pickle.loads(header_bytes)
    104         print(header_dic)
    105         file_size = header_dic['file_size']
    106         filename = header_dic['filename']
    107 
    108         with open('%s/%s' % (self.upload_filepath, filename), 'wb') as f:
    109             recv_size = 0
    110             while recv_size < file_size:
    111                 res = self.conn.recv(self.max_recv_bytes)
    112                 f.write(res)
    113                 recv_size += len(res)
    114 
    115 
    116 tcp_server = TCPServer(('127.0.0.1',8080))
    117 tcp_server.run()
    118 tcp_server.server_close()
    服务端
      1 import socket
      2 import struct
      3 import pickle
      4 import os
      5 
      6 
      7 class FTPClient:
      8     address_family = socket.AF_INET
      9     socket_type = socket.SOCK_STREAM
     10     # 下载的文件存放路径
     11     down_filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'download')
     12     # 上传的文件存放路径
     13     upload_filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'share')
     14     coding = 'utf-8'
     15     max_recv_bytes = 8192
     16 
     17     def __init__(self, server_address, connect=True):
     18         self.server_address = server_address
     19         self.socket = socket.socket(self.address_family, self.socket_type)
     20         if connect:
     21             try:
     22                 self.client_connect()
     23             except Exception:
     24                 self.client_close()
     25 
     26     def client_connect(self):
     27         self.socket.connect(self.server_address)
     28 
     29     def client_close(self):
     30         self.socket.close()
     31 
     32     def run(self):
     33         while True:
     34             # get a.txt 下载   put a.txt 上传
     35             msg = input(">>>:").strip()
     36             if not msg: continue
     37             self.socket.send(msg.encode(self.coding))
     38             cmds = msg.split()
     39             if hasattr(self,cmds[0]):
     40                 func = getattr(self,cmds[0])
     41                 func(cmds)
     42 
     43     def get(self, cmds):
     44         """ 下载
     45         1.得到 header_size
     46         2.得到 header_types header_dic
     47         3.得到 file_size file_name
     48         4.以写的形式 打开文件
     49         :param cmds: 下载的内容 eg: cmds = ['get','a.txt']
     50         :return:
     51         """
     52         obj = self.socket.recv(4)
     53         header_size = struct.unpack('i', obj)[0]
     54         if header_size == 0:
     55             print('文件不存在')
     56         else:
     57             header_types = self.socket.recv(header_size)
     58             header_dic = pickle.loads(header_types)
     59             print(header_dic)
     60             file_size = header_dic['file_size']
     61             filename = header_dic['filename']
     62 
     63             with open('%s/%s' % (self.down_filepath, filename), 'wb') as f:
     64                 recv_size = 0
     65                 while recv_size < file_size:
     66                     res = self.socket.recv(self.max_recv_bytes)
     67                     f.write(res)
     68                     recv_size += len(res)
     69                     print('总大小:%s 已下载:%s' % (file_size, recv_size))
     70                 else:
     71                     print('下载成功!')
     72 
     73     def put(self, cmds):
     74         """ 上传
     75         1.查看上传的文件是否存在
     76         2.上传文件 header_size
     77         3.上传文件 header_bytes
     78         4.以读的形式 打开文件 send(line)
     79         :param cmds: 上传的内容 eg: cmds = ['put','a.txt']
     80         :return:
     81         """
     82         filename = cmds[1]
     83         file_path = os.path.join(self.upload_filepath, filename)
     84         if os.path.isfile(file_path):
     85             file_size = os.path.getsize(file_path)
     86             header = {
     87                 'filename': os.path.basename(filename),
     88                 'md5': 'xxxxxx',
     89                 'file_size': file_size
     90             }
     91             header_bytes = pickle.dumps(header)
     92             self.socket.send(struct.pack('i', len(header_bytes)))
     93             self.socket.send(header_bytes)
     94 
     95             with open(file_path, 'rb') as f:
     96                 send_bytes = b''
     97                 for line in f:
     98                     self.socket.send(line)
     99                     send_bytes += line
    100                     print('总大小:%s 已上传:%s' % (file_size, len(send_bytes)))
    101                 else:
    102                     print('上传成功!')
    103         else:
    104             print('文件不存在')
    105 
    106 
    107 ftp_client = FTPClient(('127.0.0.1',8080))
    108 ftp_client.run()
    109 ftp_client.client_close()
    客户端
    UDP

    12.UDP协议 简单版
    1 import socket
    2 server = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
    3 server.bind(('127.0.0.1',8080))
    4 while True:
    5     data,client_addr = server.recvfrom(1024)
    6     print('客户端数据:',data)
    7     server.sendto(data.upper(),client_addr)
    服务端
    1 import socket
    2 client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
    3 while True:
    4     msg = input('>>>:').strip()
    5     client.sendto(msg.encode('utf-8'),('127.0.0.1',8080))
    6     data,server_addr =client.recvfrom(10224)
    7     print(data,server_addr)
    客户端
    13.UDP协议 不会粘包
    1 import socket
    2 server = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
    3 server.bind(('127.0.0.1',8080))
    4 res1 = server.recvfrom(5)
    5 print(res1)
    6 res2 = server.recvfrom(1024)
    7 print(res2)
    8 server.close()
    服务端
    1 import socket
    2 client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
    3 client.sendto(b'hello',('127.0.0.1',8080))
    4 client.sendto(b'world',('127.0.0.1',8080))
    5 client.close()
    客户端
    14.UDP 执行指令查看服务端的时间,设置时间同步
     1 import socket
     2 import subprocess
     3 import time
     4 server = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
     5 server.bind(('127.0.0.1',8080))
     6 while True:
     7     data,client_addr = server.recvfrom(1024)
     8     print(data,client_addr)
     9     # obj = subprocess.Popen(data.decode('utf-8'),shell=True,  # time 命令在windows 下不能用
    10     #                  stdout=subprocess.PIPE,
    11     #                  stderr=subprocess.PIPE)
    12     # stdout = obj.stdout.read()
    13     # stderr = obj.stderr.read()
    14     # print(stdout+stderr)
    15     # server.sendto(stdout+stderr,client_addr)
    16     if data.decode('utf-8') == 'time':
    17         str_time = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())
    18         # str_time = '2017-01-01 00:00:00'
    19         server.sendto(str_time.encode('gbk'),client_addr)
    20         
    21 server.close()
    服务端
     1 import socket
     2 import os
     3 import time
     4 client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
     5 while True:
     6     msg = input('>>>:').strip()
     7     client.sendto(msg.encode('utf-8'),('127.0.0.1',8080))
     8     data,server_addr = client.recvfrom(1024)
     9     print(data.decode('utf-8'),server_addr)
    10     # localtime = time.localtime()
    11     # os.system("date %d-%d-%d" % (localtime.tm_year, localtime.tm_mon, localtime.tm_mday))  # 设置日期
    12     # os.system("time %d:%d:%d.0" % (localtime.tm_hour, localtime.tm_min, localtime.tm_sec))  # 设置时间
    13 
    14 client.close()
    客户端
    
    
  • 相关阅读:
    【Oracle/PLSQL】没事玩一个简单的表充值程序
    findmnt命令查找已挂载的文件系统
    如何让shell脚本变成可执行文件
    在Linux中如何查看文件的修改日期
    Dutree – Linux上的命令行磁盘使用情况分析工具
    用FRP做内网穿透使用远程桌面连接家里的windows电脑
    Dog-用于DNS查询的命令行工具
    【DeFi】一文读懂预言机原理、类型、现状和发展方向
    Vitalik Buterin 解读 Nathan Schneider 论文:加密经济治理的局限与改进思路
    Vitalik:回顾区块链近 5 年经济学进展,以及新出现的问题
  • 原文地址:https://www.cnblogs.com/alice-bj/p/8610363.html
Copyright © 2020-2023  润新知