官方文档对socket模块下的socket.send()和socket.sendall()解释如下：

socket.send(string[, flags])

Send data to the socket. The socket must be connected to a remote socket. The optional flags argument has the same meaning as for recv() above.

Returns the number of bytes sent. Applications are responsible for checking that all data has been sent; if only some of the data was transmitted,

the application needs to attempt delivery of the remaining data.

send()的返回值是发送的字节数量，这个数量值可能小于要发送的string的字节数，也就是说可能无法发送string中所有的数据。如果有错误则会抛出异常。

socket.sendall(string[, flags])

Send data to the socket. The socket must be connected to a remote socket. The optional flags argument has the same meaning as for recv() above.

Unlike send(), this method continues to send data from string until either all data has been sent or an error occurs. None is returned on success.

On error, an exception is raised, and there is no way to determine how much data, if any, was successfully sent.

尝试发送string的所有数据，成功则返回None，失败则抛出异常。

故，下面两段代码是等价的：

sock.sendall('Hello world\n')

buffer = 'Hello world\n'

while buffer:

    bytes = sock.send(buffer)

    buffer = buffer[bytes:]

send和sendall

# 服务端：

import os

import hmac

import socket

def auth(conn):

    msg = os.urandom(32)  # 生成一个32位的随机的字节码(urandom生成的字节码就是bytes类型的)

    conn.send(msg)  # 把这个随机的字节码发送到client端

    # hmac接收两个参数，第一个参数相当于hashlib的盐，第二个参数是我们随机生成的字节码，两个参数都是bytes类型

    result = hmac.new(secret_key, msg)  # 处理这个随机字节码，socket_key是盐

    res = result.hexdigest()  # 得到结果(字符串)

    client_digest = conn.recv(1024)  # 接收client端处理的结果

    if res == client_digest.decode('utf-8'):

        print('合法的连接')  # 对比成功可以继续通信

        return True

    else:

        print('不合法连接')  # 不成功

        return False

secret_key = b'xiaoming'  # hmac的盐

sk = socket.socket()

sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

sk.bind(('127.0.0.1', 8080))

sk.listen()

conn, addr = sk.accept()

if auth(conn):

    msg = conn.recv(1024)  # True正常的和client端进行沟通

    print(msg.decode('utf-8'))

    conn.close()

else:

    conn.close()  # False 直接关闭和这个客户端的连接

sk.close()

# 客户端：

import hmac

import socket

def auth(sk):

    msg = sk.recv(32)  # 接收服务端传来的随机字节码

    result = hmac.new(secret_key, msg)  # 处理接收到的随机字节码

    res = result.hexdigest()  # 得到结果

    sk.send(res.encode('utf-8'))  # 把结果发回给服务端，让服务端进行验证

secret_key = b'xiaoming'  # 因为盐是程序员自己设置的，那么程序员写的客户端肯定知道自己的盐是什么

sk = socket.socket()

sk.connect(('127.0.0.1', 8080))

auth(sk)

sk.send(b'connect success')  # 进行其他正常的和server端的沟通

sk.close()

import socketserver

# tcp协议的server端就不需要导入socket

class Myserver(socketserver.BaseRequestHandler):  # 继承socketserver.BaseRequestHandler这个类

    def handle(self):  # 必须继承handle方法并重写

        print(self.client_address)  # 客户端的IP和端口: ('127.0.0.1', 64491)

        print(type(self.request))  # <class 'socket.socket'> 与客户端连接的socket套接字

        # <socket.socket fd=500, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8888), raddr=('127.0.0.1', 64491)>

        print(self.request)  # 与客户端连接的套接字

        conn = self.request  # self.request就是客户端的对象

        conn.send(b'helloworld')

        print(conn.recv(1024).decode('utf-8'))

# 设置allow_reuse_address允许服务器重用地址

socketserver.TCPServer.allow_reuse_address = True

# 创建一个对象server,绑定ip和端口,相当于sk = socket.socket() sk.bind(('127.0.0.1',8888))这两步的结合

server = socketserver.ThreadingTCPServer(('127.0.0.1', 8888), Myserver)

# 让server一直运行下去，除非强制停止程序

server.serve_forever()

import socket

sk = socket.socket()

sk.connect(('127.0.0.1', 8888))

msg = sk.recv(1024)

print(msg.decode('utf-8'))

sk.send(b'hiworld')

sk.close()

import socketserver

class Myserver(socketserver.BaseRequestHandler):  # 继承socketserver.BaseRequestHandler这个类

    def handle(self):  # 必须继承handle方法并重写

        print(self.client_address)  # 客户端的IP和端口: ('127.0.0.1', 60575)

        print(type(self.request))  # udp的时候，request是元组：<class 'tuple'>

        print(self.request[0])  # 客户端的消息msg: b'dog'

        print(self.request[1])  # udp套接字: <socket.socket fd=480, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8888)>

        sk = self.request[1]

        sk.sendto(b'cat', self.client_address)

# 设置allow_reuse_address允许服务器重用地址

socketserver.UDPServer.allow_reuse_address = True

# 创建一个对象server,绑定ip和端口,相当于sk = socket.socket(type=socket.SOCK_DGRAM) sk.bind(('127.0.0.1',8888))这两步的结合

server = socketserver.ThreadingUDPServer(('127.0.0.1', 8888), Myserver)

# 让server一直运行下去，除非强制停止程序

server.serve_forever()

import socket

sk = socket.socket(type=socket.SOCK_DGRAM)

sk.sendto(b'dog', ('127.0.0.1', 8888))

msg, addr = sk.recvfrom(1024)

print(msg.decode('utf-8'))

sk.close()

Myserver这个类没有__init__方法，那么它就会去继承使用父类BaseRequestHandler的__init__方法

看看BaseRequestHandler源码：

class BaseRequestHandler:

    def __init__(self, request, client_address, server):

        self.request = request  # 获取客户端的连接(对象)，设置为自己的属性

        self.client_address = client_address  # 客户端的地址

        self.server = server

        self.setup()

        try:

            self.handle()  # 初识化对象的时候执行handler方法

        finally:

            self.finish()

    def setup(self):

        pass

    def handle(self):

        pass

    def finish(self):

        pass

总结：

也就是说，子类继承了父类的__init__方法，这个方法里面已经取到了客户端的对象conn，和地址addr，

并且初始化的时候调用了handler方法，但是父类的handler方法并没有实现任何功能，所以子类应该重写handler方法便于与客户端交互。

# server.py

import json

import struct

import socketserver

import operate_handler

class MyFTP(socketserver.BaseRequestHandler):

    def handle(self):

        conn = self.request

        length = conn.recv(4)

        length = struct.unpack('i', length)[0]

        operate = (conn.recv(length)).decode('utf-8')

        operate_dic = json.loads(operate)

        opt = operate_dic['operate']

        usr = operate_dic['user']

        print(opt, usr)

        getattr(operate_handler, opt)(conn, usr)

socketserver.TCPServer.allow_reuse_address = True

server = socketserver.ThreadingTCPServer(('127.0.0.1', 9000), MyFTP)

server.serve_forever()

# operate_handler.py

import os

import json

import struct

base_path = r'E:\PythonProject\ftp\server\root'

def upload(conn, usr):

    fileinfo_len = conn.recv(4)

    fileinfo_len = struct.unpack('i', fileinfo_len)[0]

    fileinfo = (conn.recv(fileinfo_len)).decode('utf-8')

    fileinfo = json.loads(fileinfo)

    file_path = os.path.join(base_path, usr, fileinfo['filename'])

    file_path = os.path.abspath(file_path)

    with open(file_path, 'wb') as f:

        while fileinfo['filesize']:

            content = conn.recv(20480)

            fileinfo['filesize'] -= len(content)

            f.write(content)

    print('接收完毕')

# client.py

import os

import json

import struct

import socket

# 发送信息

def my_send(sk, operate_info):

    b_optinfo = (json.dumps(operate_info)).encode('utf-8')

    num = struct.pack('i', len(b_optinfo))

    sk.send(num)

    sk.send(b_optinfo)

sk = socket.socket()

sk.connect(('127.0.0.1', 9000))

# [登录,注册,退出]

# 要进行的操作

operate_info = {'operate': 'upload', 'user': 'xiaoming'}

my_send(sk, operate_info)

# 选择一个文发送到server端

file_path = r'F:\电影\电影\荒野生存.mp4'

# 发送文件信息

file_name = os.path.basename(file_path)

file_size = os.path.getsize(file_path)

file_info = {'filename': file_name, 'filesize': file_size}

my_send(sk, file_info)

# server端接收写入

with open(file_path, 'rb') as f:

    while file_size:

        content = f.read(20480)

        file_size -= len(content)

        sk.send(content)

print('上传完毕')

sk.close()