python-网络编程(socket)

你现在已经学会了写python代码，假如你写了两个python文件a.py和b.py，分别去运行，你就会发现，这两个python的文件分别运行的很好。但是如果这两个程序之间想要传递一个数据，你要怎么做呢？

这个问题以你现在的知识就可以解决了，我们可以创建一个文件，把a.py想要传递的内容写到文件中，然后b.py从这个文件中读取内容就可以了。

但是当你的a.py和b.py分别在不同电脑上的时候，你要怎么办呢？

类似的机制有计算机网盘，qq等等。我们可以在我们的电脑上和别人聊天，可以在自己的电脑上向网盘中上传、下载内容。这些都是两个程序在通信。

二.软件开发的架构

我们了解的涉及到两个程序之间通讯的应用大致可以分为两种：

第一种是应用类：qq、微信、网盘、优酷这一类是属于需要安装的桌面应用

第二种是web类：比如百度、知乎、博客园等使用浏览器访问就可以直接使用的应用

这些应用的本质其实都是两个程序之间的通讯。而这两个分类又对应了两个软件开发的架构～

1.C/S架构

C/S即：Client与Server ，中文意思：客户端与服务器端架构，这种架构也是从用户层面（也可以是物理层面）来划分的。

这里的客户端一般泛指客户端应用程序EXE，程序需要先安装后，才能运行在用户的电脑上，对用户的电脑操作系统环境依赖较大。

2.B/S架构

B/S即：Browser与Server,中文意思：浏览器端与服务器端架构，这种架构是从用户层面来划分的。

Browser浏览器，其实也是一种Client客户端，只是这个客户端不需要大家去安装什么应用程序，只需在浏览器上通过HTTP请求服务器端相关的资源（网页资源），客户端Browser浏览器就能进行增删改查。

 

 

 

三.网络基础

 

1.一个程序如何在网络上找到另一个程序？

首先，程序必须要启动，其次，必须有这台机器的地址，我们都知道我们人的地址大概就是国家省市区街道楼门牌号这样字。那么每一台联网的机器在网络上也有自己的地址，它的地址是怎么表示的呢？

就是使用一串数字来表示的，例如：100.4.5.6

P地址是指互联网协议地址（英语：Internet Protocol Address，又译为网际协议地址），是IP Address的缩写。IP地址是IP协议提供的一种统一的地址格式，它为互联网上的每一个网络和每一台主机分配一个逻辑地址，以此来屏蔽物理地址的差异。

IP地址是一个32位的二进制数，通常被分割为4个“8位二进制数”（也就是4个字节）。IP地址通常用“点分十进制”表示成（a.b.c.d）的形式，其中，a,b,c,d都是0~255之间的十进制整数。例：点分十进IP地址（100.4.5.6），实际上是32位二进制数（01100100.00000100.00000101.00000110）。

"端口"是英文port的意译，可以认为是设备与外界通讯交流的出口。

因此ip地址精确到具体的一台电脑，而端口精确到具体的程序。

2.osi七层模型

引子

须知一个完整的计算机系统是由硬件、操作系统、应用软件三者组成,具备了这三个条件，一台计算机系统就可以自己跟自己玩了（打个单机游戏，玩个扫雷啥的）

如果你要跟别人一起玩，那你就需要上网了，什么是互联网？

互联网的核心就是由一堆协议组成，协议就是标准，比如全世界人通信的标准是英语，如果把计算机比作人，互联网协议就是计算机界的英语。所有的计算机都学会了互联网协议，那所有的计算机都就可以按照统一的标准去收发信息从而完成通信了。

osi七层模型

人们按照分工不同把互联网协议从逻辑上划分了层级：

3.socket概念

socket层

理解socket

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

其实站在你的角度上看，socket就是一个模块。我们通过调用模块中已经实现的方法建立两个进程之间的连接和通信。
也有人将socket说成ip+port，因为ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序。
所以我们只要确立了ip和port就能找到一个应用程序，并且使用socket模块来与之通信

3.套接字（socket）的发展史

套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。 

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

基于网络类型的套接字家族

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

4.tcp协议和udp协议

TCP（Transmission Control Protocol）可靠的、面向连接的协议（eg:打电话）、传输效率低全双工通信（发送缓存&接收缓存）、面向字节流。使用TCP的应用：Web浏览器；电子邮件、文件传输程序。

UDP（User Datagram Protocol）不可靠的、无连接的服务，传输效率高（发送前时延小），一对一、一对多、多对一、多对多、面向报文，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)。

我知道说这些你们也不懂，直接上图。

四.套接字（socket）初使用

基于TCP协议的socket

tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端

server端 

#     第一次
# import socket
# import time
# sk = socket.socket()# 不传参数,默认使用基于网络类型的套接字, 协议 : TCP
#
# sk.bind(('192.168.12.104',18080))# 端口的范围是0-65535   但是 0-1023 这些你别用
# sk.listen()# 同时能接受的连接
#
# print(123)
# conn,addr = sk.accept()# 等待接受客户端的连接  阻塞等待
# print(456)
# print('conn:',conn)
# print('addr:',type(addr))
#
# time.sleep(20)
#
# conn.close()
# sk.close()


#    第二次   通信

import socket
import time
sk = socket.socket()# 我买一个新手机

sk.bind(('192.168.12.104',18080))#  我买一个手机卡

sk.listen()# 开机

print(123)
conn,addr = sk.accept()# 等待朋友给我打电话


msg_r = conn.recv(10)# 接受数据,接受10个字节
#print(msg_r)
print(msg_r.decode('utf-8'),addr)


conn.close()# 挂断电话
sk.close() # 关机

                      

client端                               

# import socket
# import time
# sk = socket.socket()
#
# sk.connect(('192.168.12.104',18080))# 连接
#
# time.sleep(20)
#
# sk.close()



#    第二次      通信
import socket
import time
sk = socket.socket()

sk.connect(('192.168.12.104',18080))# 连接
#sk.send(b'sss')
sk.send('中文'.encode('utf-8'))

sk.close()

问题：有的同学在重启服务端时可能会遇到   

解决方法：

#加入一条socket配置，重用ip和端口
import socket
from socket import SOL_SOCKET,SO_REUSEADDR
sk = socket.socket()
sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
sk.bind(('127.0.0.1',8898))  #把地址绑定到套接字
sk.listen()          #监听链接
conn,addr = sk.accept() #接受客户端链接
ret = conn.recv(1024)   #接收客户端信息
print(ret)              #打印客户端信息
conn.send(b'hi')        #向客户端发送信息
conn.close()       #关闭客户端套接字
sk.close()        #关闭服务器套接字(可选)

上面聊天聊一次就关闭了,如何做的一直聊天呢,加个循环就可以啦

server端 

import socket

sk = socket.socket()# 默认参数  使用基于网络类型的套接字,TCP协议
sk.bind(('127.0.0.1',65534))# 回环地址
sk.listen()
while 1:
    conn,addr = sk.accept()# 接电话

    while 1:
        msg_r = conn.recv(1024).decode('utf-8')
        print(msg_r)
        if msg_r == 'q':
            break
        msg_s = input('>>>')
        conn.send(msg_s.encode('utf-8'))
        if msg_s == 'q':
            break

    conn.close()
sk.close()

client端   

import socket

sk = socket.socket()
sk.connect(('127.0.0.1',65534))
while 1:
    msg_s = input('>>>')
    sk.send(msg_s.encode('utf-8'))
    if msg_s == 'q':
        break
    msg_r = sk.recv(1024).decode('utf-8')
    if msg_r == 'q':
        break
    print(msg_r)

sk.close()

基于UDP协议的socket

udp是无链接的，启动服务之后可以直接接受消息，不需要提前建立链接

简单使用                                                                                               

server端                              

# import socket
# #
# # sk = socket.socket(type=socket.SOCK_DGRAM)# udp协议
# #
# # sk.bind(('127.0.0.1',8090))

# # # 收发
# # msg_r,addr = sk.recvfrom(1024)# 接收来自于哪里的消息
# # print(msg_r.decode('utf-8'))

# # # sk.sendto()# 发给谁的消息

# # sk.close()


# 聊天室程序　　一直收发
#
# import socket
#
# sk = socket.socket(type=socket.SOCK_DGRAM)# udp协议
# sk.bind(('127.0.0.1',8090))
#
# # 收发
# while 1:
#     msg_r,addr = sk.recvfrom(1024)# 接收来自于哪里的消息
#     print(msg_r.decode('utf-8'),addr)
#     msg_s = input(('>>>'))
#     sk.sendto(msg_s.encode('utf-8'),addr)# 发给谁的消息
#
# sk.close()

client端 

import socket

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


while 1:
    msg_s = input('>>>')
    sk.sendto(msg_s.encode('utf-8'),('127.0.0.1',8090))
    msg_r,addr = sk.recvfrom(1024)
    print(msg_r.decode('utf-8'))

sk.close()

                           

 署名聊天UDP

import socket

sk = socket.socket(type=socket.SOCK_DGRAM)# udp协议
sk.bind(('127.0.0.1',8090))

# 收发
while 1:
    msg_r,addr = sk.recvfrom(1024)# 接收来自于哪里的消息
    print(msg_r.decode('utf-8'))
    msg_s = input(('>>>'))
    sk.sendto(msg_s.encode('utf-8'),addr)# 发给谁的消息

sk.close()

import socket

sk = socket.socket(type=socket.SOCK_DGRAM)# udp协议


name = input('请输入您的名字:')
# 收发
while 1:
    msg_s = input(('>>>'))
    info = name + ' : ' + msg_s
    sk.sendto(info.encode('utf-8'), ('127.0.0.1',8090))  # 发给谁的消息
    msg_r,addr = sk.recvfrom(1024)# 接收来自于哪里的消息
    print(msg_r.decode('utf-8'))


sk.close()

 自定义类继承socket

import socket


class MySocket(socket.socket):# 继承自 socket文件中的socket类,此时socket就是父类
    def __init__(self,encoding='utf-8'):
        self.encoding = encoding
        super(MySocket, self).__init__(type=socket.SOCK_DGRAM)#  执行父类socket中的__init__方法

    def my_sendto(self,msg,addr):
        return self.sendto(msg.encode(self.encoding),addr)# 调用父类中的sendto方法

    def my_recvfrom(self,num):
        msg_r,addr = self.recvfrom(num)# 调用父类的recvfrom方法
        return msg_r.decode(self.encoding),addr

socket参数的详解

socket.socket(family=AF_INET,type=SOCK_STREAM,proto=0,fileno=None)

创建socket对象的参数说明：

小文件的上传和下载

import socket
import json

sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()

conn,addr = sk.accept()


# 通信

str_dic = conn.recv(9090).decode('utf-8')
dic = json.loads(str_dic)
# dic = {'opt':menu.get(num),'filename':filename,'content':content}
if dic['opt'] == 'upload':
    # 上传
    filename = '1' + dic['filename']
    with open(filename,'w',encoding='utf-8') as f:
        f.write(dic['content'])



elif dic['opt'] == 'download':
    # 下载
    pass





conn.close()
sk.close()

import socket
import os
import json

sk = socket.socket()
sk.connect_ex(('127.0.0.1',8080))# 带返回值,如果出错,不会报错,会返回错误的编码
# sk.connect()# 会直接报错    两个都是连接服务器的功能

menu = {'1':'upload','2':'download'}
for k,v in menu.items():
    print(k,v)

num = input('请输入功能选项:')

if num == '1':
    # 上传功能
    # {你要执行的功能, 文件名, 文件内容}
    dic = {'opt':menu.get(num),'filename':None,'content':None}
    file_path = input('请输入一个文件的绝对路径>>>')
    # 'D:/showCode/python/Show/GoodCode/复习/01 基础回顾/03 网络编程/socket/UDP/ser_.py'
    filename = os.path.basename(file_path)
    with open(file_path,'r',encoding='utf-8') as f:
        content = f.read()

    dic['filename'] = filename
    dic['content'] = content
    # print(dic)
    str_dic = json.dumps(dic)
    sk.send(str_dic.encode('utf-8'))




elif num == '2':
    # 下载功能
    pass
else:
    print('错误')





sk.close()

  

五.黏包

黏包现象

让我们基于tcp先制作一个远程执行命令的程序（命令ls -l ; lllllll ; pwd）

执行命令

res=subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE)

的结果的编码是以当前所在的系统为准的，如果是windows，那么res.stdout.read()读出的就是GBK编码的，在接收端需要用GBK解码

且只能从管道里读一次结果

注意

注意

import os
import subprocess


# r = os.popen('ipconfig')

r = subprocess.Popen('ls',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)

# subprocess.Popen(cmd,shell=True,subprocess.stdout,subprocess.stderr)
# cmd : 代表系统命令
# shell = True   代表这条命令是 系统命令,告诉操作系统,将cmd当成系统命令去执行
# stdout   是执行完系统命令之后,用于保存结果的一个管道
# stderr   是执行完系统命令之后,用于保存错误结果的一个管道
stdout = r.stdout.read().decode('gbk')
stderr = r.stderr.read().decode('gbk')
print('正确的返回结果:',stdout)
print('错误的返回结果:',stderr)
print('错误的返回结果:',stderr)

# 客户端发送要执行命令
# 服务器执行,执行完将结果返回给客户端
# 客户端拿到结果呈现到用户眼前

import socket

sk = socket.socket()

sk.connect_ex(('127.0.0.1',8080))
while 1:
    cmd = input('请输入一个命令>>>')
    sk.send(cmd.encode('utf-8'))

    result = sk.recv(102400).decode('gbk')

    print(result)


sk.close()

import socket
import subprocess

sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()

conn,addr = sk.accept()
while 1:
    cmd = conn.recv(1024).decode('utf-8')
    r = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
    stdout = r.stdout.read()
    stderr = r.stderr.read()
    if stderr:
        conn.send(stderr)
    else:
        conn.send(stdout)

conn.close()
sk.close()

# dir

同时执行多条命令之后，得到的结果很可能只有一部分，在执行其他命令的时候又接收到之前执行的另外一部分结果，这种显现就是黏包。

tcp演示黏包

import socket
sk = socket.socket()

sk.bind(('127.0.0.1',8888))
sk.listen()

conn,addr = sk.accept()

conn.send(b'hello')
conn.send(b'world')

conn.close()
sk.close()

import socket
sk = socket.socket()

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

msg1 = sk.recv(1024)
print('msg1:',msg1)

msg2 = sk.recv(1024)

print('msg2:',msg2)

sk.close()

UDP演示粘包

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

sk.bind(('127.0.0.1',8888))
while 1:
    msg1 = sk.recvfrom(5)
    print('msg1:',msg1)

    msg2 = sk.recvfrom(1024)
    print('msg2:',msg2)

sk.close()

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

while 1:
    sk.sendto(b'hello',('127.0.0.1',8888))
    sk.sendto(b'world',('127.0.0.1',8888))

sk.close()

注意：只有TCP有粘包现象，UDP永远不会粘包

黏包成因

TCP协议中的数据传递

1、tcp协议的拆包机制

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。 
MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。 大部分网络设备的MTU都是1500。
如果本机的MTU比网关的MTU大，大的数据包就会被拆开来传送，这样会产生很多数据包碎片，增加丢包率，降低网络速度。

2、面向流的通信特点和Nagle算法

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。
收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。
这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。 
对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。 
可靠黏包的tcp协议：tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

 基于tcp协议特点的黏包现象成因 

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，

通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

UDP不会发生黏包

UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。 
不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。
即面向消息的通信是有消息保护边界的。 对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），也可以被发送，
udp协议会帮你封装上消息头发送过去。 不可靠不黏包的udp协议：udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y;x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠。

补充说明:

用UDP协议发送时，用sendto函数最大能发送数据的长度为：65535- IP头(20) – UDP头(8)＝65507字节。用sendto函数发送数据时，如果发送数据长度大于该值，则函数会返回错误。（丢弃这个包，不进行发送） 

    用TCP协议发送时，由于TCP是数据流协议，因此不存在包大小的限制（暂不考虑缓冲区的大小），这是指在用send函数时，数据长度参数不受限制。而实际上，所指定的这段数据并不一定会一次性发送出去，如果这段数据比较长，会被分段发送，如果比较短，可能会等待和下一次数据一起发送

会发生黏包的两种情况

情况一 发送方的缓存机制

发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）

情况二 接收方的缓存机制

接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包） 

总结

黏包现象只发生在tcp协议中：

1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。

2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

黏包的解决方案

解决方案一

问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来接收完所有数据。

#大文件的传输
# import socket
# import os
# import json
# sk = socket.socket()
# sk.connect(("127.0.0.1",8001))
# menu = {"1":"upload","2":"download"}
# for k,v in menu.items():
#     print(k,v)
# num = input("请输入功能选项:")
# if num == "1":
#     dic = {"opt":menu.get(num),"filename":None,"filesize":None}
#     file_path = input("请输入一个绝对路径:")# 文件的绝对路径
#     filename = os.path.basename(file_path)# 文件名字
#     filesize = os.path.getsize(file_path)# 获取用户输入的路径中文件的大小
#
#     dic["filename"] = filename
#     dic["filesize"] = filesize
#     str_dic = json.dumps(dic)
#     sk.send(str_dic.encode("utf-8"))# 将被填充完成的字典先发送给服务器
#     sk.recv(1024)# 为什么要有一个recv？
#     #  因为上边send字典时，如果程序执行过快，可能会马上执行到下边的send(content)
#     #  此时有可能会发生粘包，所以在此中间加一个recv,为了避免粘包
#     with open(file_path,"rb") as f:
#         while filesize:
#             content = f.read(1024)
#             sk.send(content)
#             filesize -= len(content)
#
# elif num == "2":
#     pass

#大文件的传输
# import socket
# import json
# sk = socket.socket()
# sk.bind(("127.0.0.1",8001))
# sk.listen()
# conn,addr = sk.accept()
# str_dic = conn.recv(100).decode("utf-8")
# conn.send(b'ok')
# # str_dic = {"opt":menu.get(num),"filename":None,"filesize":None}
# dic = json.loads(str_dic)
# if dic["opt"] == "upload":
#     filename = "1"+ dic["filename"]
#     with open(filename,"ab") as f:
#         while dic['filesize']:
#             content = conn.recv(1024)
#             f.write(content)
#             dic['filesize'] -= len(content)
#
# elif dic["opt"] == "download":
#     pass
#
# conn.close()
# sk.close()

存在的问题：
程序的运行速度远快于网络传输速度，所以在发送一段字节前，先用send去发送该字节流长度，这种方式会放大网络延迟带来的性能损耗

解决方案进阶

刚刚的方法，问题在于我们我们在发送

我们可以借助一个模块，这个模块可以把要发送的数据长度转换成固定长度的字节。这样客户端每次接收消息之前只要先接受这个固定长度字节的内容看一看接下来要接收的信息大小，那么最终接受的数据只要达到这个值就停止，就能刚好不多不少的接收完整的数据了。

struct模块

该模块可以把一个类型，如数字，转成固定长度的bytes

>>> struct.pack('i',1111111111111)

struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个是范围,最大21亿多

import json,struct
#假设通过客户端上传1T:1073741824000的文件a.txt

#为避免粘包,必须自定制报头
header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T数据,文件路径和md5值

#为了该报头能传送,需要序列化并且转为bytes
head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并转成bytes,用于传输

#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
head_len_bytes=struct.pack('i',len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度

#客户端开始发送
conn.send(head_len_bytes) #先发报头的长度,4个bytes
conn.send(head_bytes) #再发报头的字节格式
conn.sendall(文件内容) #然后发真实内容的字节格式

#服务端开始接收
head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式
x=struct.unpack('i',head_len_bytes)[0] #提取报头的长度

head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式
header=json.loads(json.dumps(header)) #提取报头

#最后根据报头的内容提取真实的数据,比如
real_data_len=s.recv(header['file_size'])
s.recv(real_data_len)

使用struct解决黏包 

借助struct模块，我们知道长度数字可以被转换成一个标准大小的4字节数字。因此可以利用这个特点来预先发送数据长度。

import socket
import os
import json
import struct
sk = socket.socket()
sk.connect(("127.0.0.1",8001))
menu = {"1":"upload","2":"download"}
for k,v in menu.items():
    print(k,v)
num = input("请输入功能选项:")
if num == "1":
    dic = {"opt":menu.get(num),"filename":None,"filesize":None}
    file_path = input("请输入一个绝对路径:")# 文件的绝对路径
    # E:Python S14day32实现大文件的传输11.mp4
    filename = os.path.basename(file_path)# 文件名字
    filesize = os.path.getsize(file_path)# 获取用户输入的路径中文件的大小
    dic["filename"] = filename
    dic["filesize"] = filesize
    str_dic = json.dumps(dic)
    len_dic = len(str_dic)# 获取到字典的长度，是一个int类型的数据   46   146
    b_len_dic = struct.pack('i',len_dic)# 用一个4bytes的数据表示字典的长度

    sk.send(b_len_dic + str_dic.encode("utf-8"))# 将bytes类型的字典的长度 + bytes类型的字典的内容，一起发送给服务器


    #  因为上边send字典时，如果程序执行过快，可能会马上执行到下边的send(content)
    #  此时有可能会发生粘包，所以在此中间加一个recv,为了避免粘包
    with open(file_path,"rb") as f:
        while filesize:
            content = f.read(1024)
            sk.send(content)
            filesize -= len(content)

elif num == "2":
    pass

import socket
import json
import struct
sk = socket.socket()
sk.bind(("127.0.0.1",8001))
sk.listen()
conn,addr = sk.accept()
b_len_dic = conn.recv(4)
len_dic = struct.unpack('i',b_len_dic)[0]# 获取到int类型字典的长度，
# unpack得到的是一个元组，要取下标为0的位置
str_dic = conn.recv(len_dic).decode('utf-8')
# str_dic = {"opt":menu.get(num),"filename":None,"filesize":None}
dic = json.loads(str_dic)
if dic["opt"] == "upload":
    filename = "1"+ dic["filename"]
    with open(filename,"ab") as f:
        while dic['filesize']:
            content = conn.recv(1024)
            f.write(content)
            dic['filesize'] -= len(content)

elif dic["opt"] == "download":
    # 客户端发来一个字典要执行的功能，以及客户端自己的绝对路径
    # 服务器要返回这个绝对路径中所有文件及文件夹
    # 客户端自己选择进入到哪一层目录下
    # 服务器都要返回对应目录下所有文件及文件夹
    # 客户随时选择某一个目录下的某一个文件进行下载


    # 客户端发送来一个字典，包含了要进行的操作，要下载的文件的绝对路径，
    # 根据绝对路径去读取文件内容
    # 一边读，一遍发
    pass

conn.close()
sk.close()

切换目录

#  切换目录
import socket
import os

sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
conn,addr = sk.accept()

def send_data(conn,path):
    '''你给我一个目录，我把目录发给client'''
    lis_dir = os.listdir(path)
    str_dir = '--'.join(lis_dir)
    conn.send(str_dir.encode('utf-8'))

abs_path = conn.recv(1024).decode('utf-8')# 获取用户输入的绝对路径
current_dir = abs_path + '/'# 以下再处理，都要根据当前路径去处理，无论是返回上一层，还是进入下一层
send_data(conn,current_dir)# 把用户输入的路径下的所有文件及文件夹返回给客户端

# C:/Program Files (x86)/Common Files
while 1:
    cmd = conn.recv(1024).decode('utf-8')
    if cmd == '..':
        current_dir = current_dir.split('/')[:-2]
        current_dir = '/'.join(current_dir)+'/'
        # if 如果当前是C盘：
        #     就返回给客户端告诉说没有上一层了！
        send_data(conn, current_dir)
    else:
        filename = cmd.split(' ')[1]# 获取用户输入的文件名字
        current_dir += filename + '/'# 将文件名字添加到当前路径下，组成一个完整的新路径
        if os.path.isdir(current_dir):# 如果客户输入的文件名字是一个文件夹
            send_data(conn, current_dir)
        else:# 如果不是一个文件夹
            conn.send(b'bu shi wen jian jia')




# conn.close()
# sk.close()

import socket
import os

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

abs_path = input('请输入您的根目录:')
sk.send(abs_path.encode('utf-8'))
current_dir = sk.recv(1024).decode('utf-8')
print(current_dir.split('--'))

while 1:
    cmd = input('请输入>>>')
    # cd + 文件夹      ..
    if cmd == '..':
        sk.send(cmd.encode('utf-8'))
        current_dir = sk.recv(1024).decode('utf-8')
        print(current_dir.split('--'))
    if cmd == 'cd':
        filename = input('请输入一个文件夹名：')
        sk.send((cmd+' '+filename).encode('utf-8'))
        current_dir = sk.recv(1024).decode('utf-8')
        print(current_dir.split('--'))








sk.close()