一：进程间的通信
1.本地进程间的通信
- 消息传递（管道，FIFO，消息队列）
- 同步（互斥量，条件变量，读写锁，文件和写记录锁，信号量）
- 共享内存（匿名的和具名的）
- 远程过程调用
2.网络进程间的通信
网络上的进程对得唯一区分，这样才能进行网络间的通信，比如QQ，微信聊天等等。而可以唯一区分的是进程的ip地址（互联网协议地址），协议，端口（设备与外界通讯的出口）。Python进行网络编程，就是在Python程序本身这个进程内，连接别的服务器进程的通信端口进行通信。
二：软件开发的架构
1.B/S架构（浏览器端、服务器端）
2.C/S架构（客户端、服务器端）
2.1 socket套接字就是，应用程序通过套接字向网络发出请求或者应答网络请求，使主机间或者计算机间的程序可以相互通信。应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。
2.2 socket（）函数
socket.socket([family[,type[,proto]]])
- family: 套接字家族可以用AF_UNIX（基于文件类型的套接字家族）或者AF_INET（基于网络类型的套接字家族）
- type: 套接字类型可以根据是面向连接的还是非连接分为
SOCK_STREAM或SOCK_DGRAM - protocol: 一般不填默认为0.
1 import socket 2 socket.socket(socket_family,socket_type,protocal=0) 3 socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。 4 5 获取tcp/ip套接字 6 tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 7 8 获取udp/ip套接字 9 udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 10 11 由于 socket 模块中有太多的属性。我们在这里破例使用了'from module import *'语句。使用 'from socket import *',我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。 12 例如tcpSock = socket(AF_INET, SOCK_STREAM)
2.3 我们学习socket（套接字）就是为了完成C/S架构
2.4 套接字工作流程
2.5 socket对象（内建）方法
| 函数 | 描述 |
|---|---|
| 服务器端套接字 | |
| s.bind() | 绑定地址（host,port）到套接字， 在AF_INET下,以元组（host,port）的形式表示地址。**** |
| s.listen() | 开始TCP监听。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。 |
| s.accept() | 被动接受TCP客户端连接,(阻塞式)等待连接的到来 |
| 客户端套接字 | |
| s.connect() | 主动初始化TCP服务器连接，。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。 |
| s.connect_ex() | connect()函数的扩展版本,出错时返回出错码,而不是抛出异常 |
| 公共用途的套接字函数 | |
| s.recv() | 接收TCP数据，数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。 |
| s.send() | 发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。 |
| s.sendall() | 完整发送TCP数据，完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。 |
| s.recvform() | 接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。 |
| s.sendto() | 发送UDP数据，将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。 |
| s.close() | 关闭套接字 |
| s.getpeername() | 返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。 |
| s.getsockname() | 返回套接字自己的地址。通常是一个元组(ipaddr,port) |
| s.setsockopt(level,optname,value) | 设置给定套接字选项的值。 |
| s.getsockopt(level,optname[.buflen]) | 返回套接字选项的值。 |
| s.settimeout(timeout) | 设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()） |
| s.gettimeout() | 返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。 |
| s.fileno() | 返回套接字的文件描述符。 |
| s.setblocking(flag) | 如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。 |
| s.makefile() | 创建一个与该套接字相关连的文件 |
三：OSI七层模型
每层运行常见的物理设备
应用层 python应用
传输层 udp/tcp
网络层 ip 路由器属于网络层
数据链路层 arp（地址解析协议） arp通过ID找地址（map）
交换机：广播 单播 组播
物理层 网卡 双绞线
四：TCP协议和UDP协议
想要学会socket编程就得明白一些网络协议 ，所谓协议就是一些固定的标准，开发基于网络通信的软件必须遵守网络协议。
IP协议规定了IP地址的格式
- IP地址是一台机器在一个网络内唯一的标识
- 子网掩码也是IP
- IP地址与子网掩码做按位与运算，得到的结果是网段
- 网关IP 两个局域网之间的两台机器访问公网IP是通过网关访问的
TCP/IP协议族包括运输层、网络层、链路层。
tcp：面向字节流的 面向连接的协议 可靠的 效率低 全双工 三次握手 四次挥手*
udp:面向数据包的 不可靠的 不需要连接就可以发消息 单第一个消息一定是客户端发的
tcp三次握手和四次挥手
总结：
- 客户端的connect在三次握手的第二个次返回，而服务器端的accept在三次握手的第三次返回。
- 主动断开连接 ：FIN_WAIT_1
- 被动断开连接： FIN_WAIT_2
- 马上断开连接： TIME_WAIT
- 四次挥手断开连接原则：
- 记住一条原则：谁先发起客户端请求，谁先断开连接
- 但是在大并发情况下，大部分都是服务端先断开连接，不会保留连接。因为每一分钟都有很多人在访问
五：套接字（socket）的使用
1.基于TCP协议的套接字
TCP服务器端
import socket ss=socket() #创建出服务器端的套接字 ss.bind() #把地址绑定到套接字上 ss.listen() #监听链接 inf_loop: #服务器无限循环 cs=ss.accept() #接受客户端连接 comm_loop: cs.recv()/cs.send()#接受发送对话 cs.close() #关闭客户端套接字 ss.close() #关闭服务器端套接字（可选）
TCP客户端
cs=sorted() #创建客户端套接字 cs.connect() #尝试连接服务器 conmm_loop: #通讯无限循环 cs.send/cs.recv() #接受发送 cs.close()
实验过程中遇到的问题：
解决方法：
加入一条socket配置，重用ip和端口
import socket from socket import SOL_SOCKET,SO_REUSEADDR sk=socket.socket() sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是他，在bind前加 ********* sk.listen() conn,addr=sk.accept() #接受客户端链接 ret=conn.recv(1024) #接收客户端发来的信息 print(ret) #把信息打印出来 conn.send(b'ninuihih') conn.close()#关闭客户端套接字 sk.close() #关闭服务器套接字（可选）
2.基于UDP协议的套接字（无链接的，不需要提前建立连接）
UDP的服务器端
ss.socket() ss.bind()#绑定服务器套接字 inf_loop: cs=ss.recvfrom()/ss.sendto() ss.close()
UDP的客户端
cs.socket() comm_loop: cs.sendto()/cs.recvfrom() cs.close
六：黏包现象
1.只有tcp有，udp没有
2.黏包问题：同时执行多条命令之后，得到的结果很可能只有一部分，再执行其他命令的时候又接收到之前执行的另一部分结果，
3.黏包问题的原因：
黏包问题的成因：因为应用程序所看到的数据是一个整体，或者是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此tcp协议是面向流的协议，更容易发生黏包现象。TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。
而udp是面向消息的协议，每个udp段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据。
4.解决黏包问题：
- 在发送消息之前就告诉对方消息有多大
- 自定义协议的概念
- struct模块将要发送的数据大小固定化，无论如何就发四个字节
5.会发生黏包问题的两种情况
情况一：发送端需要等缓冲区满才能发送出去，造成黏包
server端
from socket import * ip_port=('127.0.0.1',8080) tcp_socket_server=socket(AF_INET,SOCK_STREAM) tcp_socket_server.bind(ip_port) tcp_socket_server.listen(5) conn,addr=tcp_socket_server.accept() data1=conn.recv(10) data2=conn.recv(10) print('------->>',data1.decode('utf-8')) print('----->>',data2.decode('utf-8')) conn.close()
client端
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)
s.send('hello'.encode('utf-8'))
s.send('eggo2'.encode('utf-8'))
情况二：接收方不及时接受缓冲区的包，造成多个包接受。
server：
from socket import * ip_port=('127.0.0.1',8080) tcp_socket_server=socket(AF_INET,SOCK_STREAM) tcp_socket_server.bind(ip_port) tcp_socket_server.listen(5) conn,addr=tcp_socket_server.accept() data1=conn.recv(2) #一次没有收完整 data2=conn.recv(10) #下次收的时候，会先收取旧的数据，再接收新的数据。 print('=======>',data1.decode('utf-8')) print('=======>',data2.decode('utf-8')) conn.close()
client：
import socket BUFSIZE=1024 ip_port=('127.0.0.1',8080) s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(ip_port) s.send('hello_egg'.encode('utf-8'))
6.黏包问题的总结：
- 黏包问题只会发生在tcp
- 从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。
- 实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的
7.黏包问题的解决方案
因为接收端不知道发送端将要发送的数据的字节流的长度，所以才会产生黏包问题。所以我们需要在发送信息之前就确定一个机制（将自己发送的数据的自己留让接收端提前知晓）。
此方法还存在一些问题，需要进阶
server
import socket,subprocess ip_port=('127.0.0.1',8080) s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind(ip_port) s.listen(5) while True: conn,addr=s.accept() print('客户端',addr) while True: msg=conn.recv(1024) if not msg:break res=subprocess.Popen(msg.decode('utf-8'),shell=True, stdin=subprocess.PIPE, stderr=subprocess.PIPE, stdout=subprocess.PIPE) err=res.stderr.read() if err: ret=err else: ret=res.stdout.read() data_length=len(ret) conn.send(str(data_length).encode('utf-8')) data=conn.recv(1024).decode('utf-8') if data == 'recv_ready': conn.sendall(ret) conn.close()
client
import socket,time s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(('127.0.0.1',8080)) while True: msg=input('>>: ').strip() if len(msg) == 0:continue if msg == 'quit':break s.send(msg.encode('utf-8')) length=int(s.recv(1024).decode('utf-8')) s.send('recv_ready'.encode('utf-8')) send_size=0 recv_size=0 data=b'' while recv_size < length: data+=s.recv(1024) recv_size+=len(data) print(data.decode('utf-8'))
使用struct解决黏包
借助struct模块，我们知道长度数字可以被转换成一个标准大小的4字节数字。因此可以利用这个特点来预先发送数据长度。
struct模块的用处：
- 按照指定格式将Python数据转换为字符串,该字符串为字节流,如网络传输时,不能传输int,此时先将int转化为字节流,然后再发送;
- 按照指定格式将字节流转换为Python指定的数据类型;
- 处理二进制数据,如果用struct来处理文件的话,需要用’wb’,’rb’以二进制(字节流)写,读的方式来处理文件;
- 处理c语言中的结构体;
struct模块中的函数
关于struct的用法：
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 header_bytes=bytes(json.dump(header),encoding='utf-8') #序列化并转为bytes，用yu传输 #为了让客户知道报头的长度，用struct将报头长度这个数字转为固定长度：四字节 header_len_bytes=struct.pack('i',len(header_bytes)) #这四个字节里只包含了一个数字，该数字是报头的长度 #客户端开始发送 conn.send(header_len_bytes) #先发报头的长度 conn.send(header_bytes) #再发报头的字节格式 conn.sendall('文件内容') #然后发真实内容的字节格式 #服务器端开始接收 header_len_bytes=s.recv(4) #先收报头四个bytes ，得到报头长的的字节格式 x=struct.unpack('i',header_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模块，长度数字转化为标准大小的四字节数字。
server端：
#自定制报头 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() conn.send(struct.pack('i', len(back_msg))) # 先发back_msg的长度 conn.sendall(back_msg) # 在发真实的内容 conn.close()
client端：
import socket,time,struct s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(('127.0.0.1',8080)) while True: msg=input('>>: ').strip() if len(msg) == 0:continue if msg == 'quit':break s.send(msg.encode('utf-8')) l=s.recv(4) x=struct.unpack('i',l)[0] print(type(x),x) # print(struct.unpack('I',l)) r_s=0 data=b'' while r_s < x: r_d=s.recv(1024) data+=r_d r_s+=len(r_d) # print(data.decode('utf-8')) print(data.decode('gbk')) #windows默认gbk编码