如何实现两个python程序之间的文件或信息传输那？？
软件开发的架构
- 我们了解的涉及到两个程序之间通讯的应用大致可以分为两种：
- 第一种是应用类：qq、微信、网盘、优酷这一类是属于需要安装的桌面应用
- 第二种是web类：比如百度、知乎、博客园等使用浏览器访问就可以直接使用的应用
- 这些应用的本质其实都是两个程序之间的通讯。而这两个分类又对应了两个软件开发的架构～
1、CS架构
C/S即：Client与Server ，中文意思：客户端与服务器端架构，这种架构也是从用户层面（也可以是物理层面）来划分的。
这里的客户端一般泛指客户端应用程序EXE，程序需要先安装后，才能运行在用户的电脑上，对用户的电脑操作系统环境依赖较大。
2、BS架构
B/S即：Browser与Server,中文意思：浏览器端与服务器端架构，这种架构是从用户层面来划分的。
Browser浏览器，其实也是一种Client客户端，只是这个客户端不需要大家去安装什么应用程序，只需在浏览器上通过HTTP请求服务器端相关的资源（网页资源），客户端Browser浏览器就能进行增删改查。
3、一个程序如何在网络上找到另一个程序
首先，程序必须要启动，其次，必须有这台机器的地址，我们都知道我们人的地址大概就是国家\省\市\区\街道\楼\门牌号这样字。那么每一台联网的机器在网络上也有自己的地址，它的地址是怎么表示的呢？
就是使用一串数字来表示的，例如：100.4.5.6
3.1、IP地址
IP地址是指互联网协议地址（英语：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）。3.2、端口
"端口"是英文port的意译，可以认为是设备与外界通讯交流的出口。因此IP地址是用来确定具体的一台电脑或服务器，而端口是来确定具体程序的
4、数据传输的过程
4.1、osi七成模型
4.2、socket概念
理解socket
TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
站在python编程的角度上看，socket就是一个模块。我们通过调用模块中已经实现的方法建立两个进程之间的连接和通信。 也有人将socket说成ip+port，因为ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序。 所以我们只要确立了ip和port就能找到一个应用程序，并且使用socket模块来与之通信。
套接字（socket）的发展史
套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。
基于文件类型的套接字
- 套接字家族的名字：AF_UNIX
- unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信
基于网络类型的套接字
- 套接字家族的名字：AF_INET
- (还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)
tcp协议和udp协议
- TCP（Transmission Control Protocol）可靠的、面向连接的协议（eg:打电话）、传输效率低全双工通信（发送缓存&接收缓存）、面向字节流。使用TCP的应用：Web浏览器；电子邮件、文件传输程序。
- UDP（User Datagram Protocol）不可靠的、无连接的服务，传输效率高（发送前时延小），一对一、一对多、多对一、多对多、面向报文，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)。
套接字（socket）使用
1、基于tcp协议的socket
- tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端
1.1、server端
import socket #导入socket模块
sk = socket.socket() #实例化一个对象
sk.bind(('127.0.0.1',8898)) #把地址绑定到套接字
sk.listen() #监听链接
conn,addr = sk.accept() #接受客户端链接
ret = conn.recv(1024) #接收客户端信息
print(ret) #打印客户端信息
conn.send(b'hi') #向客户端发送信息，必须传一个bytes类型
conn.close() #关闭客户端套接字
sk.close() #关闭服务器套接字(可选)1.2、client端
import socket #导入socket模块
sk = socket.socket() # 创建客户套接字
sk.connect(('127.0.0.1',8898)) # 尝试连接服务器
sk.send(b'hello!') #发送消息，必须传一个bytes类型
ret = sk.recv(1024) # 接收消息)
print(ret) #打印消息
sk.close() # 关闭客户套接字基于tcp协议的socket注意事项：server和client端交互，有发必有收，收发必相等
问题及解决办法：
在重启server端时遇到如下报错：
解决办法：
在server端加入一行配置：
2、基于udp协议的socket
- udp是无链接的，启动服务之后可以直接接受消息，不需要提前建立链接
server端：
import socket
udp_sk = socket.socket(type=socket.SOCK_DGRAM) #创建一个基于udp协议的服务器的套接字
udp_sk.bind(('127.0.0.1',9000)) #绑定服务器套接字
msg,addr = udp_sk.recvfrom(1024) #接收消息
print(msg) #打印消息
udp_sk.sendto(b'hi',addr) # 发送bytes类型的消息，和客户端的ip地址
udp_sk.close() # 关闭服务器套接字client端：
import socket
ip_port=('127.0.0.1',9000) #连接server端
udp_sk=socket.socket(type=socket.SOCK_DGRAM) #指定建立基于udp协议的socket
udp_sk.sendto(b'hello',ip_port) #往server端发送bytes类型的消息和对方的IP地址
back_msg,addr=udp_sk.recvfrom(1024) #接收消息
print(back_msg.decode('utf-8'),addr) #打印消息基于udp协议的socket通讯说明：
- # udp的server不需要进行监听也不需要建立连接，在启动服务之后只能被动的等待客户端发送消息过来
- # 客户端发送消息的同时还会自带地址，消息回复的时候不仅需要发送消息，还需要把对方的地址填写上
基于tcp协议socket实现的qq聊天
1 import socket #
2 sk = socket.socket() #创建一个基于tcp协议的socket对象
3 sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #在重启server端时遇到报错：addres already in user报错时，加上这个配置（重用ip和端口）,跟操作系统的最大连接数有关
4 sk.bind(('127.0.0.1',8081)) #给server端绑定一个ip和端口
5 sk.listen() #监听
6 while True: #循环
7 conn,addr = sk.accept() #等待客户端连接（没有客户端连接就会一直停在这里，有客户端连接才会继续向下走），已经完成了三次握手建立了一个连接
8 while True:
9 ret = conn.recv(1024).decode('utf-8') #阻塞点（直到收到一个客户端发来的消息才会向下走）
10 print(ret) #打印接收的消息
11 if ret == 'bye':break
12 info = input('>>：') #输入消息
13 if info == 'bye':
14 conn.send(b'bye')
15 break
16 conn.send(info.encode('utf-8')) #发送消息，指定编码类型
17 conn.close() #关闭连接
18 sk.close() #关闭socket对象server端
1 import socket
2 sk = socket.socket() #创建一个socket对象
3 sk.connect(('127.0.0.1',8081)) #连接server端
4 while True: #循环
5 info = input('=>>：') #输入要发送的消息
6 if info == 'bye': #如果输入的消息是bye
7 sk.send(b'bye')
8 break #则退出循环
9 sk.send(info.encode('utf-8')) #发送消息，及消息的编码类型
10 ret = sk.recv(1024).decode('utf-8') #接收一个消息并解码
11 print(ret) #打印接收的消息
12 if ret.lower() == 'bye':
13 break
14 sk.close()client端
基于udp协议实现的qq聊天
1 import socket
2 sk = socket.socket(type=socket.SOCK_DGRAM) #DGRAM：datagram，建立一个基于udp的socket
3 sk.bind(('127.0.0.1',8080)) #绑定ip和端口
4 while 1: #循环
5 msg,addr = sk.recvfrom(1024) #接收消息
6 print(addr,':',msg.decode('utf-8')) #打印接收到的消息
7 info = input('server：').encode('utf-8') #输入要发送的消息
8 sk.sendto(info,addr) #发送消息,对方的ip地址
9 sk.close() #关闭连接server端
1 import socket
2 sk = socket.socket(type=socket.SOCK_DGRAM) #实例化一个基于udp协议的socket对象
3 ip_port = ('127.0.0.1',8080) #连接的地址
4 while 1: #循环
5 info = input('client1：') #输入要发送的消息
6 info = ('\033[32m来自client1的消息：%s\033[0m'%info).encode('utf-8')
7 sk.sendto(info,ip_port) #发送消息，对方的地址
8 ret,add = sk.recvfrom(1024) #接收消息
9 print(add,':',ret.decode('utf-8')) #打印接收的消息
10 sk.close() #关闭连接client端
基于udp协议实现的时间服务器
需求
写一个时间同步的服务器，服务端接收请求
按照client端发送的时间格式,将服务器时间转换成对应格式，发送给客户端
1 import time #导入时间模块和socket模块
2 import socket
3 sk = socket.socket(type=socket.SOCK_DGRAM) #实例化基于udp协议的socket对象
4 sk.bind(('127.0.0.1',9000)) #绑定端口和地址
5 while True: #循环
6 msg,addr = sk.recvfrom(1024) #接收消息
7 # msg 客户端发送给server端的时间格式 "%Y-%m-%d %H:%M-%S"
8 time_format = msg.decode('utf-8')
9 time_str = time.strftime(time_format)
10 sk.sendto(time_str.encode('utf-8'),addr) #发送消息
11 sk.close()server端
1 import time #导入时间模块和socket模块
2 import socket
3 sk = socket.socket(type = socket.SOCK_DGRAM) #实例化基于udp协议的socket对象
4 sk.sendto('%Y-%m-%d %H:%M:%S'.encode('utf-8'),('127.0.0.1',9000)) #发送消息
5 msg,addr = sk.recvfrom(1024) #接收消息
6 print(msg.decode('utf-8')) #打印消息
7 sk.close()client端
socket参数说明
socket.socket(family=AF_INET,type=SOCK_STREAM,proto=0,fileno=None)family | 地址系列应为AF_INET(默认值),AF_INET6,AF_UNIX,AF_CAN或AF_RDS。 （AF_UNIX 域实际上是使用本地 socket 文件来通信） |
type | 套接字类型应为SOCK_STREAM(默认值),SOCK_DGRAM,SOCK_RAW或其他SOCK_常量之一。 SOCK_STREAM 是基于TCP的，有保障的（即能保证数据正确传送到对方）面向连接的SOCKET，多用于资料传送。 SOCK_DGRAM 是基于UDP的，无保障的面向消息的socket，多用于在网络上发广播信息。 |
proto | 协议号通常为零,可以省略,或者在地址族为AF_CAN的情况下,协议应为CAN_RAW或CAN_BCM之一。 |
fileno | 如果指定了fileno,则其他参数将被忽略,导致带有指定文件描述符的套接字返回。 与socket.fromfd()不同,fileno将返回相同的套接字,而不是重复的。 这可能有助于使用socket.close()关闭一个独立的插座。 |
黏包现象
同时执行多条命令之后，得到的结果很可能只有一部分，在执行其他命令的时候又接收到之前执行的另外一部分结果，这种显现就是黏包。
1、使用基于tcp协议的socket实现的server端下发命令在clent端执行并将结果返回给server端
1 import socket
2 sk = socket.socket() #实例化基于tcp协议的socket对象
3 sk.bind(('127.0.0.1',8090)) #server端绑定IP和端口
4 sk.listen() #监听
5 conn,addr = sk.accept() #接收客户端的连接
6 while True: #循环
7 cmd = input('tcp_server:') #输入要执行的命令
8 conn.send(cmd.encode('gbk')) #发送输入的命令
9 ret = conn.recv(1024).decode('gbk') #接收返回结果
10 print(ret) #打印结果
11 conn.close() #关闭socket
12 sk.close() #关闭serverserver端
1 import socket
2 import subprocess #这里执行命令用到了subprocess模块
3 sk = socket.socket() #实例化基于tcp协议的socket对象
4 sk.connect(('127.0.0.1',8090)) #连接server端
5 while 1: #循环
6 cmd = sk.recv(1024).decode('gbk') #接收server端发来的消息
7 ret = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) #利用subprocess模块执行shell命令，shell命令的正确输出结果存到stdout=subprocess.PIPE中（只能取一次），错误的结果存到stderr=subprocess.PIPE中（只能取一次）
8 std_out = 'stdout :' + (ret.stdout.read()).decode('gbk') #定制输出结果
9 std_err = 'stderr :' + (ret.stderr.read()).decode('gbk') #定制输出结果
10 print(std_out) #打印输出结果
11 print(std_err)
12 sk.send(std_out.encode('gbk')) #返回输出结果
13 sk.send(std_err.encode('gbk'))
14 sk.close() #关闭连接client端
1 tcp_server:dir #执行dir命令的输出结果
2 stdout : 驱动器 D 中的卷是 文档
3 卷的序列号是 E2DD-0909
4
5 D:\my-python-scripts\my-python-all\day-016-网络编程\粘包现象 的目录
6
7 2018/10/20 13:16 <DIR> .
8 2018/10/20 13:16 <DIR> ..
9 2018/10/20 12:56 682 subprocess_test.py
10 2018/10/20 13:10 586 tcp_client.py
11 2018/10/20 13:06 392 tcp_server.py
12 2018/10/20 13:16 680 udp_client.py
13 2018/10/20 13:16 377 udp_server.py
14 2018/10/20 12:50 <DIR> __pycache__
15 5 个文件 2,717 字节
16 3 个目录 253,503,041,536 可用字节
17
18 tcp_server:ipconfig #执行ipconfig命令的输出结果（不正常）
19 stderr :
20 tcp_server:ls #执行ls命令时才输出ipconfig命令的结果
21 stdout :
22 Windows IP 配置
23
24
25 以太网适配器 以太网:
26
27 媒体状态 . . . . . . . . . . . . : 媒体已断开连接
28 连接特定的 DNS 后缀 . . . . . . . :
29
30 无线局域网适配器 本地连接* 2:
31
32 媒体状态 . . . . . . . . . . . . : 媒体已断开连接
33 连接特定的 DNS 后缀 . . . . . . . :
34
35 无线局域网适配器 本地连接* 13:
36
37 媒体状态 . . . . . . . . . . . . : 媒体已断开连接
38 连接特定的 DNS 后缀 . . . . . . . :
39
40 以太网适配器 以太网 2:
41
42 媒体状态 . . . . . . . . . . . . : 媒体已断开连接
43 连接特定的 DNS 后缀 . . . . . . . :
44
45 以太网适配器 VMware Network Adapter VMnet1:
46
47 连接特定的 DNS 后缀 . . . . . . . :
48 本地链接 IPv6 地址. . . . . . . . : fe80::518d:522d:528b:acfa%11
49 IPv4 地址 . . . . . . . . . . . . : 192.168.229.1
50 子网掩码 . . . . . . . . . . . . : 255.255.255.0
51 默认网关. . . . . . . . . . . . . :
52
53 以太网适配器 VMware Network Adapter VMnet8:
54
55 连接特定的 DNS 后缀 . . . . . . . :
56 本地链接 IPv6 地址. . . . . . . . : fe80::694d:2b8f:ab3a:9248%16
57 IPv4 地址 . . .
58
59
60
61 这就是黏包现象执行命令触发黏包现象
注：只有tcp协议会出现黏包现象（因为tcp是可靠的连接），udp永远不会出现黏包现象
黏包现象的发生原理
tcp协议的数据传递之tcp协议的拆包机制
当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。 MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。 大部分网络设备的MTU都是1500。如果本机的MTU比网关的MTU大，大的数据包就会被拆开来传送，这样会产生很多数据包碎片，增加丢包率，降低网络速度。
面向流通讯的特点和nagle算法
TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。 收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。 这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。 对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。 可靠黏包的tcp协议：tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。
tcp协议的特点和黏包现象的成因
发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据。
也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。
而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。
怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。socket数据传输过程中的用户态与内核态说明
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函数时，数据长度参数不受限制。而实际上，所指定的这段数据并不一定会一次性发送出去，如果这段数据比较长，会被分段发送，如果比较短，可能会等待和下一次数据一起发送。
发生黏包的两种情况
情况一：发送方的缓存机制
- 发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）
import socket
sk = socket.socket() #实例化基于tcp协议的socket对象
sk.bind(('127.0.0.1',9091)) #绑定ip和端口
sk.listen() #监听
conn,addr = sk.accept() #接收客户端连接
res1 = conn.recv(24) #接收24个字节
print(res1) #打印接收到的内容
conn.close() #关闭连接
sk.close() #关闭socketserver端
import socket
sk = socket.socket() #实力化基于tcp协议的socket对象
sk.connect(('127.0.0.1',9091)) #连接server端
sk.send(b'hello') #发送一次消息
sk.send(b'world') #发送两次消息
sk.close() #关闭连接
#tcp协议 优化算法，连续的 小的数据包 会被合并发送client端
情况二：接收方的缓存机制
- 接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）
import socket
sk = socket.socket() #实例化基于tcp协议的socket对象
sk.bind(('127.0.0.1',9091)) #绑定IP和端口
sk.listen() #监听
conn,addr = sk.accept() #接收客户端的连接
res1 = conn.recv(2) #第一次获取两个字节
res2 = conn.recv(10) #第二次获取是个字节
print(res1) #打印结果
print(res2)
conn.close() #关闭连接
sk.close()
#应用程序会有一个缓冲池的概念，就是将发来的包放在了内存中
结果为：
b'he'
b'llo world'server端
import socket
sk = socket.socket() #实例化基于tcp协议的socket对象
sk.connect(('127.0.0.1',9091)) #连接server端
sk.send(b'hello world') #发送消息
sk.close() #关闭连接client端
总结：
黏包现象只发生在tcp协议中：
1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。
2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的
解决黏包现象
解决方案一
问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。
import socket
sk = socket.socket() #实例化基于tcp协议的socket对象
sk.bind(('127.0.0.1',8081)) #绑定IP和端口
sk.listen() #监听
conn,addr = sk.accept() #接收客户端的连接
while 1: #循环
cmd = input('server:') #输入要发送的命令
if cmd == 'q': #如果输入的内容为q
conn.send(b'q') #发送q
break #并退出
conn.send(cmd.encode('gbk')) #否则则发送输入的命令
num = conn.recv(1024).decode('utf-8') #接收执行命令返回结果的长度
conn.send(b'ok') #返回OK
cmd_info = conn.recv(int(num)).decode('gbk') #接收返回结果
print(cmd_info) #打印结果
conn.close() #关闭连接
sk.close()server端
import socket
import subprocess #使用到subprocess模块来执行命令
sk = socket.socket() #实例化基于tcp协议的socket对象
sk.connect(('127.0.0.1',8081)) #连接server端的地址
while 1: #循环
cmd = sk.recv(1024).decode('utf-8') #接收命令
if cmd == 'q': #如果是q就退出
break
res = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) #执行命令并记录命令输出结果
std_out = res.stdout.read()
std_err = res.stderr.read()
sk.send(str(len(std_out)+len(std_err)).encode('utf-8')) #返回给server端命令结果的长度
sk.recv(1024) #接收ok字段
sk.send(std_out) #将命令的执行结果返回到server端
sk.send(std_err) #将命令的执行结果返回到server端
sk.close() #关闭连接client端
总结：
好处：确定了到底要发送多大的数据，要在文件中配置一个配置项，就是每一次recv的大小（buffer）
当我们要发送大量的数据的时候，要明确告诉对方要发送多大的数据，以便于接收方能够准确的接收所有数据
多用在文件传输过程中， 大文件的传输，一定是按照字节读，每次读取固定的字节
传输过程中：一边读一边传，接收端：一遍收一边写
send这个大文件之前，（假设大文件35672个字节），每次send4096个字节，35672-4096-4096...0
recv这个大文件，recv35672字节，recv（2048）35672-2048-2048-->0
不好处：多了一次网络交互
send sendto在超过一定范围的时候，都会报错，程序的内存管理
解决方案二
刚刚的方法，问题在于我们我们在发送
我们可以借助一个模块，这个模块可以把要发送的数据长度转换成固定长度的字节。这样客户端每次接收消息之前只要先接受这个固定长度字节的内容看一看接下来要接收的信息大小，那么最终接受的数据只要达到这个值就停止，就能刚好不多不少的接收完整的数据了。
struct模块
该模块可以把一个类型，如数字，转成固定长度的bytes（4个字节）
import struct
res = struct.pack('i',20490) #i代表：int，就是即将要把一个数字(20490)转换成一个固定长度的bytes类型
print(res,'....',len(res)) #打印结果及计算结果的长度，结果为：b'\nP\x00\x00' .... 4
num = struct.unpack('i',res)
print(num[0]) #获取到原内容，结果为：20490struct模块
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 struct #导入struct模块
import socket #导入socket模块
sk = socket.socket() #实例化基于tcp协议的socket对象
sk.bind(('127.0.0.1',8081)) #绑定ip和端口
sk.listen() #监听
conn,addr = sk.accept() #允许客户端连接
while 1: #循环
cmd = input('server:') #输入命令
if cmd == 'q':
conn.send(b'q')
break
conn.send(cmd.encode('gbk')) #发送命令
num = conn.recv(4) #接收报头
num = struct.unpack('i',num)[0] #获取报头内容
cmd_info = conn.recv(int(num)).decode('gbk') #接收命令返回结果
print(cmd_info) #打印结果
conn.close() #关闭连接
sk.close()server端（自定制报头）
import socket
import struct
import subprocess
sk = socket.socket() #实例化基于tcp协议的socket对象
sk.connect(('127.0.0.1',8081)) #连接服务端
while 1: #循环
cmd = sk.recv(1024).decode('utf-8') #接收命令
if cmd == 'q':
break
res = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) #命令的执行结果
std_out = res.stdout.read()
std_err = res.stderr.read()
len_num = len(std_out)+len(std_err) #确定命令的返回结果的长度
num_by = struct.pack('i',len_num) #将命令返回结果的长度通过struct模块定制为4个字节
sk.send(num_by) #发送“将命令返回结果的长度通过struct模块定制的4个字节”
sk.send(std_out) #发送命令的执行结果
sk.send(std_err)
sk.close() #关闭连接client端（自定制报头）
我们还可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个自己足够用了）
import socket,struct,json
import subprocess
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加
phone.bind(('127.0.0.1',8080))
phone.listen(5)
while True:
conn,addr=phone.accept()
while True:
cmd=conn.recv(1024)
if not cmd:break
print('cmd: %s' %cmd)
res=subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
err=res.stderr.read()
print(err)
if err:
back_msg=err
else:
back_msg=res.stdout.read()
headers={'data_size':len(back_msg)}
head_json=json.dumps(headers)
head_json_bytes=bytes(head_json,encoding='utf-8')
conn.send(struct.pack('i',len(head_json_bytes))) #先发报头的长度
conn.send(head_json_bytes) #再发报头
conn.sendall(back_msg) #在发真实的内容
conn.close()server端
from socket import *
import struct,json
ip_port=('127.0.0.1',8080)
client=socket(AF_INET,SOCK_STREAM)
client.connect(ip_port)
while True:
cmd=input('>>: ')
if not cmd:continue
client.send(bytes(cmd,encoding='utf-8'))
head=client.recv(4)
head_json_len=struct.unpack('i',head)[0]
head_json=json.loads(client.recv(head_json_len).decode('utf-8'))
data_len=head_json['data_size']
recv_size=0
recv_data=b''
while recv_size < data_len:
recv_data+=client.recv(1024)
recv_size+=len(recv_data)
print(recv_data.decode('utf-8'))
#print(recv_data.decode('gbk')) #windows默认gbk编码client端
定制报头实现一个大文件的上传和下载
1 import socket
2 import struct
3 import json
4 sk = socket.socket() #实例化基于tcp协议的socket对象
5 sk.bind(('127.0.0.1',9093)) #绑定ip和端口
6 sk.listen() #监听
7 buffer = 1024 #设置变量
8 conn,addr = sk.accept() #等待连接
9
10 head_len = conn.recv(4) #接收报头
11 head_len = struct.unpack('i',head_len)[0] #获取传输的大小
12 json_head = conn.recv(head_len).decode('utf-8') #接收文件
13 head = json.loads(json_head) #反序列化
14 filesize = head['filesize'] #获取文件大小
15 with open(head['filename'],'wb') as f: #已bytes类型写的方式打开文件
16 while filesize: #循环
17 if filesize >= buffer: #文件大小大于等于前面定义的变量
18 content = conn.recv(buffer) #接收1024个字节的文件内容
19 f.write(content) #将接收到的内容写入到文件中
20 filesize -= buffer #写入后将文件的总大小减去写入的大小
21 else:
22 content = conn.recv(filesize) #否则也是接收1024字节的文件内容
23 f.write(content) #写入到文件中
24 break #退出
25 conn.close() #关闭连接
26 sk.close()server端
import socket
import os
import json
import struct
sk = socket.socket() #实例化socket对象
sk.connect(('127.0.0.1',9093)) #连接server端
buffer = 1024 #设置变量
#发送文件
head = {'filepath':r'E:\视频\第09套：python全栈就业班第9期（加送，2018年最新录制，持续更新中）\Python全栈9期（第01部分）：基础+模块+面向对象+网络编程\day32',
'filename':r'04 python fullstack s9day32 struct模块补充.mp4',
'filesize':None} #定制报头信息
filepath = os.path.join(head['filepath'],head['filename']) #获取文件路径
filesize = os.path.getsize(filepath) #获取文件大小
head['filesize'] = filesize #添加head的文件大小的值
json_head = json.dumps(head) #序列化，字典转成了字符串
bytes_head = json_head.encode('utf-8') #字符串转bytes
head_len = len(bytes_head) #计算bytes_head的长度
pack_len = struct.pack('i',head_len) #使用struct模块将报头信息转换为4个字节大小
sk.send(pack_len) #先发报头的长度
sk.send(bytes_head) #在发送bytes类型的报头
with open(filepath,'rb') as f: #打开文件
while filesize: #循环
if filesize >= buffer:
content = f.read(buffer) #每次读出来的内容
sk.send(content) #将读出来的内容发送给server端
filesize -= buffer #做减法
else:
content = f.read(filesize) #读文件
sk.send(content) #将读出来的内容写入到server端
break #退出
sk.close() #关闭连接client端
socket的更多使用方法
服务端套接字函数
s.bind() 绑定(主机,端口号)到套接字
s.listen() 开始TCP监听
s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来
客户端套接字函数
s.connect() 主动初始化TCP服务器连接
s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
公共用途的套接字函数
s.recv() 接收TCP数据
s.send() 发送TCP数据
s.sendall() 发送TCP数据
s.recvfrom() 接收UDP数据
s.sendto() 发送UDP数据
s.getpeername() 连接到当前套接字的远端的地址
s.getsockname() 当前套接字的地址
s.getsockopt() 返回指定套接字的参数
s.setsockopt() 设置指定套接字的参数
s.close() 关闭套接字
面向锁的套接字方法
s.setblocking() 设置套接字的阻塞与非阻塞模式
s.settimeout() 设置阻塞套接字操作的超时时间
s.gettimeout() 得到阻塞套接字操作的超时时间
面向文件的套接字的函数
s.fileno() 套接字的文件描述符
s.makefile() 创建一个与该套接字相关的文件更多方法
官方文档对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方法
1 import socket #导入模块
2 sk = socket.socket() #实例化基于tcp协议的socket对象
3 sk.setblocking(False) #设置为非阻塞模式
4 sk.bind(('127.0.0.1',8080)) #绑定IP和端口
5 sk.listen() #监听
6 try:
7 conn,addr = sk.accept() #阻塞点，等待客户端连接（可以通过sk.setblocking(False) 设置为非阻塞模式）
8 except BlockingIOError: #如果设置为非阻塞你是会报BlockingIOError错误
9 pass
10 print('---------')
11 #以上代码的意思为：不等待进行连接，代码继续向下走使用setbloking设置套接字的阻塞与非阻塞模式
说明：使用setbloking将套接字的模式设置为非阻塞模式后所有该阻塞的地都不阻塞了
验证客户端连接的合法性
不依靠登陆认证，而是客户端和服务端的相互认证
import hmac #和hashlib的功能一样
h = hmac.new() #secret_key,你想进行加密的bytes
mw = h.digest() #拿到一个密文内容
hmac.compare_digest() #对比 密文和另外一个密文hmac模块
import hmac
import socket
import os
secret_key = b'ouyang' #secret_key
sk = socket.socket() #tcp连接
sk.bind(('127.0.0.1',9099)) #绑定ip和端口
sk.listen() #监听
def check_conn(conn):
msg = os.urandom(32) #随机获取32个字节
conn.send(msg) #发送这32个字节
h = hmac.new(secret_key,msg) #加密的bytes类型
digest = h.digest() #拿到加密之后的内容
client_digest = conn.recv(1024) #获取客户端的加密内容
return hmac.compare_digest(digest,client_digest) #对比两个加密内容
conn,addr = sk.accept()
res = check_conn(conn)
if res:
print('合法的客户端')
conn.close()
else:
print('不合法的客户端')
conn.close()
sk.close()server端
import socket
import hmac
secret_key = b'ouyang'
sk = socket.socket()
sk.connect(('127.0.0.1',9099))
msg = sk.recv(1024) #获取server端的消息
h = hmac.new(secret_key,msg) #加密
digest = h.digest() #获取加密后的内容
sk.send(digest) #将加密后的内容返回给server端
sk.close()client端
socketserver（并发）
使用socketserver实现tcp协议的qq聊天功能可以实现一个server可以和多个client端通讯
import socketserver
class MyServer(socketserver.BaseRequestHandler):
def handle(self):
while 1:
msg = self.request.recv(1024).decode('utf-8')
if msg == 'q':
self.request.close()
break
print(msg)
info = input('server:')
self.request.send(('server:'+info).encode('utf-8'))
# print(self.request.recv(1024).decode('utf-8')) #self.requst就相当于一个conn
if __name__ == '__main__':
server = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyServer)
server.serve_forever()server端
import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8080))
while 1:
msg = input('client:')
if msg == 'q':
sk.send(b'q')
break
sk.send(('client1:'+msg).encode('utf-8'))
ret = sk.recv(1024).decode('utf-8')
print(ret)
sk.close()client端
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
