1.基礎版(供學習瞭解原理使用,low)

server服務端

import socket
import struct
import json

server = socket.socket()
ip_port = ('127.0.0.1', 8001)
server.bind(ip_port)
server.listen()
conn, addr = server.accept()

head_len_msg = conn.recv(4)
head_len = struct.unpack('i',head_len_msg)[0]
head_byte = conn.recv(head_len)
head = json.loads(head_byte.decode('utf-8'))
file_size = head['size']
size = 0
with open('檔案副本',mode='wb') as f1:
    while file_size:
        if file_size >= 1024:
            line = conn.recv(1024)
            f1.write(line)
            file_size -= 1024
        else:
            content = conn.recv(1024)
            break
conn.close()
server.close()

client客戶端

import os
import socket
import struct
import json

client = socket.socket()
client.connect(('127.0.0.1', 8001))

buffer = 1024
filepath = input('請輸入檔案路徑')
filesize = os.path.getsize(filepath)
head = {'size':os.path.getsize(filepath)}
head_json = json.dumps(head)
head_byte = head_json.encode('utf-8')
head_len = len(head_byte)
pack_len = struct.pack('i', head_len)
client.send(pack_len)
client.send(head_byte)

with open(filepath,mode='rb') as f:
    while filesize:
        if filesize>buffer:
            content = f.read(buffer)
            client.send(content)
            filesize -= buffer
        else:
            content = f.read(filesize)
            client.send(content)
            break

2.升級版(正常使用)

封裝了報頭,解決了粘包問題的FTP傳檔案　

server服務端

import struct,json,socket
import subprocess
import os

class MyTcpServer:
    address_family = socket.AF_INET
    socket_type = socket.SOCK_STREAM
    allow_reuse_address = False
    max_packet_size = 8192
    coding = 'utf-8'
    request_queue_size = 5
    server_dir = 'file_upload'

    def __init__(self, server_address, bind_and_active = True):
        self.server_address = server_address
        self.socket = socket.socket()

        if bind_and_active:
            try:
                self.server_bind()
                self.server_activate()
            except:
                self.server_close()
                raise

    def server_bind(self):
        if self.allow_reuse_address:
            self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR, 1)

        self.socket.bind(self.server_address)
        self.server_address = self.socket.getsockname()



    def server_activate(self):
        self.socket.listen(self.request_queue_size)

    def server_close(self):
        self.socket.close()

    def get_request(self):
        return self.socket.accept()

    def close_request(self,request):
        request.close()
    def run(self):
        while 1:
            self.conn,self.client_addr = self.get_request()
            print('from client ', self.client_addr)
            while 1:
                try:
                    head_struct = self.conn.recv(4)
                    if not head_struct: break

                    head_len = struct.unpack('i', head_struct)[0]
                    head_json = self.conn.recv(head_len).decode(self.coding)
                    head_dic = json.loads(head_json)
                    print(head_dic)
                    cmd = head_dic['cmd']
                    if hasattr(self,cmd):
                        func = getattr(self,cmd)
                        func(head_dic)


                except Exception:
                    break

    def put(self,args):
        file_path = os.path.normpath(os.path.join(self.server_dir,args['filename']))
        filesize = args['filesize']
        recv_size = 0
        print('----->',file_path)
        with open(file_path,'wb') as f:
            while recv_size < filesize:
                recv_data = self.conn.recv(self.max_packet_size)
                f.write(recv_data)
                recv_size += len(recv_data)
                print('recvsize: %s filesize: %s' %(recv_size,filesize))

tcpserver1 = MyTcpServer(('127.0.0.1', 8001))
tcpserver1.run()

client客戶端

import os
import socket,json,subprocess,struct

class MyTcpClient:
    addresss_family = socket.AF_INET
    socket_type = socket.SOCK_STREAM
    allow_reuse_address = False
    max_packet_size = 8192
    coding = 'utf-8'
    request_queue_size = 5
    def __init__(self, server_address, connect = True):
        self.servver_address = server_address
        self.socket = socket.socket(self.addresss_family,self.socket_type)
        if connect:
            try:
                self.client_connect()
            except:
                self.client_close()
                raise

    def client_connect(self):
        self.socket.connect(self.servver_address)

    def client_close(self):
        self.socket.close()

    def run(self):
        while True:
            inp = input('>>: ').strip()
            if not inp:continue
            l = inp.split()
            cmd = l[0]
            if hasattr(self,cmd):
                func = getattr(self,cmd)
                func(l)

    def put(self,args):
        cmd = args[0]
        filename = args[1]
        if not os.path.isfile(filename):
            print('file:%s is not exists' % filename)
        else:
            filesize = os.path.getsize(filename)

        head_dic = {'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize}
        print(head_dic)
        head_json = json.dumps(head_dic)
        head_json_bytes = bytes(head_json, encoding=self.coding)

        head_struct = struct.pack('i', len(head_json_bytes))
        self.socket.send(head_struct)
        self.socket.send(head_json_bytes)
        send_size = 0
        with open(filename,'rb') as f:
            for line in f:
                self.socket.send(line)
                send_size += len(line)
                print(send_size)
            else:
                print('upload successful')

client = MyTcpClient(('127.0.0.1', 8001))
client.run()