一：进程间的通信
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编码