python---网络编程
Posted 笨笨侠
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python---网络编程相关的知识，希望对你有一定的参考价值。
一、软件开发的架构
1： C/S架构
Client与Server 客户端与服务器端，这里的客户端一般泛指客户端应用EXE，程序需要先安装后，才能运行在用户的电脑上，对用户的电脑操作系统环境依赖较大。
2： B/S架构
Browser与Server 浏览器端与服务器端。
Browser浏览器，其实也是一种Client客户端，只是这个客户端不需要去安装什么应用程序，只需在浏览器上通过HTTP请求服务器端相关的资源。
二、网络基础
IP地址：指互联网协议地址。
IP地址是IP协会提供的一种统一的地址格式，它为互联网上的每一个网络和每一台主机分配一个逻辑地址，以此来屏蔽物理地址的差异。
IP地址是一个32位的二进制数，通常被分割为4个‘8位二进制数’。
IP地址通常用“点分十进制”表示（a,b,c,d）的形式，其中，a,b,c,d都是0~255之间的十进制整数。
端口可以认为是设备与外界通讯交流的出口。
因此IP地址可以精确到具体的一台电脑，而端口精确到具体的程序。
通过子网掩码，我们就能判断，任意两个IP地址是否处在同一个子网络。方法是将两个IP地址与子网掩码分别进行AND运算（两个位数都是1，则结果1，反之0），然后比较结果是否相同，如果是的话，就表示它们在同一个子网络中，否则就不是。
总结一下，IP协议的作用主要有两个：一个是为每一台计算机分配IP地址，另一个是确定哪些地址在同一个子网络。
TCP协议
TCP---传输控制协议，提供的是面向连接、可靠的字节流服务。当客户与服务器彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传输到另一端。
可靠的、面向连接的协议（eg:打电话）、传输效率低全双工通信（发送缓存&接收缓存）、面向字节流。使用TCP的应用：Web浏览器；电子邮件、文件传输程序。
TCP是因特网中的传输层协议，使用三次握手协议建立连接。当主动方发出SYN连接请求后，等待对方回答SYN+ACK[1]，并最终对对方的 SYN 执行 ACK 确认。这种建立连接的方法可以防止产生错误的连接。[1] TCP三次握手的过程如下： 客户端发送SYN（SEQ=x）报文给服务器端，进入SYN_SEND状态。 服务器端收到SYN报文，回应一个SYN （SEQ=y）ACK(ACK=x+1）报文，进入SYN_RECV状态。 客户端收到服务器端的SYN报文，回应一个ACK(ACK=y+1）报文，进入Established状态。 三次握手完成，TCP客户端和服务器端成功地建立连接，可以开始传输数据了。
建立一个连接需要三次握手，而终止一个连接要经过四次握手，这是由TCP的半关闭（half-close）造成的。 (1) 某个应用进程首先调用close，称该端执行“主动关闭”（active close）。该端的TCP于是发送一个FIN分节，表示数据发送完毕。 (2) 接收到这个FIN的对端执行 “被动关闭”（passive close），这个FIN由TCP确认。 注意：FIN的接收也作为一个文件结束符（end-of-file）传递给接收端应用进程，放在已排队等候该应用进程接收的任何其他数据之后，因为，FIN的接收意味着接收端应用进程在相应连接上再无额外数据可接收。 (3) 一段时间后，接收到这个文件结束符的应用进程将调用close关闭它的套接字。这导致它的TCP也发送一个FIN。 (4) 接收这个最终FIN的原发送端TCP（即执行主动关闭的那一端）确认这个FIN。[1] 既然每个方向都需要一个FIN和一个ACK，因此通常需要4个分节。 注意： (1) “通常”是指，某些情况下，步骤1的FIN随数据一起发送，另外，步骤2和步骤3发送的分节都出自执行被动关闭那一端，有可能被合并成一个分节。[2] (2) 在步骤2与步骤3之间，从执行被动关闭一端到执行主动关闭一端流动数据是可能的，这称为“半关闭”（half-close）。 (3) 当一个Unix进程无论自愿地（调用exit或从main函数返回）还是非自愿地（收到一个终止本进程的信号）终止时，所有打开的描述符都被关闭，这也导致仍然打开的任何TCP连接上也发出一个FIN。 无论是客户还是服务器，任何一端都可以执行主动关闭。通常情况是，客户执行主动关闭，但是某些协议，例如，HTTP/1.0却由服务器执行主动关闭。[2]
UDP协议
UDP---用户数据报协议，是一个简单的面向数据报的运输层协议。UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快。
不可靠的、无连接的服务，传输效率高（发送前时延小），一对一、一对多、多对一、多对多、面向报文，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)。
互联网协议按照功能不同分为osi七层或tcp/ip五层或tcp/ip四层
每层运行常见的物理设备
传输层——> 四层交换机、四层的路由器
网络层——>路由器、三层交换机
数据链路层——>网桥、以太网交换机、网卡
物理层——>中继器、集线器、双绞线
每层运行常见的协议
应用层——>。。。
传输层——>TCP与UDP协议
网络层——>ip协议
数据链路层——>arp协议 （通过ip找mac地址）
物理层——>。。。
交换机：广播 单播 组播
ip协议：ip地址的格式
# ip地址 一台机器在一个网络内唯一的标识
# 子网掩码 ip地址与子网掩码做按位与运算，得到的结果是网段
# 网关ip 局域网内的机器访问公网ip，就通过网关访问
三、socket
Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
socket和file的区别：
1：file模块是针对某个指定文件进行打开、读写、关闭
2：socket模块是针对服务器端和客户端socket进行打开、读写、关闭
基于文件类型的套接字家族
套接字家族的名字：AF_UNIX
unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信
基于网络类型的套接字家族
套接字家族的名字：AF_INET
(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)
基于TCP协议的socket
tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端
import 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\') #向客户端发送信息 conn.close() #关闭客户端套接字 sk.close() #关闭服务器套接字(可选)
import socket sk = socket.socket() # 创建客户套接字 sk.connect((\'127.0.0.1\',8898)) # 尝试连接服务器 sk.send(b\'hello!\') ret = sk.recv(1024) # 对话(发送/接收) print(ret) sk.close() # 关闭客户套接字
tcp实现与多个客户端通信，必须结束一个客户端，才能到下一个客户端。
#服务器端 import socket #tcp协议 sk = socket.socket() # 创建一个socket对象 sk.bind((\'127.0.0.1\',8080)) # 给server端绑定一个ip和端口 sk.listen() while True: conn,addr = sk.accept() while True: msg = conn.recv(1024).decode(\'utf-8\') # 阻塞，直到收到一个客户端发来的消息 print(msg) if msg == \'bye\':break info = input(\'>>>\') if info == \'bye\': conn.send(b\'bye\') break conn.send(info.encode(\'utf-8\')) # 发消息 conn.close() # 关闭连接 sk.close() # 关闭socket对象，如果不关闭，还能继续接收 #客户端1 import socket sk = socket.socket() sk.connect((\'127.0.0.1\',8080)) while True: msg = input(\'>>>\') if msg == \'bye\': sk.send(b\'bye\') break sk.send(msg.encode(\'utf-8\')) ret = sk.recv(1024).decode(\'utf-8\') if ret == \'bye\':break print(ret) sk.close() #客户端2 import socket sk = socket.socket() sk.connect((\'127.0.0.1\',8080)) while True: msg = input(\'client2:>>>\') if msg == \'bye\': sk.send(b\'bye\') break sk.send((\'client2 :\'+msg).encode(\'utf-8\')) ret = sk.recv(1024).decode(\'utf-8\') if ret == \'bye\':break print(ret) sk.close()
基于udp协议的socket
#服务器端 import socket sk = socket.socket(type=socket.SOCK_DGRAM) #DGRAM datagram sk.bind((\'127.0.0.1\',8080)) #只有服务端有的 msg,addr = sk.recvfrom(1024) print(msg.decode(\'utf-8\')) sk.sendto(b\'bye\',addr) sk.close() # udp的server 不需要进行监听也不需要建立连接 # 在启动服务之后只能被动的等待客户端发送消息过来 # 客户端发送消息的同时还会 自带地址信息 # 消息回复的时候 不仅需要发送消息，还需要把对方的地址填写上 #客户端 import socket sk = socket.socket(type=socket.SOCK_DGRAM) ip_port = (\'127.0.0.1\',8080) sk.sendto(b\'hello\',ip_port) ret,addr = sk.recvfrom(1024) print(ret.decode(\'utf-8\')) sk.close() # client端不需要connect 因为UDP协议是不需要建立连接的 # 直接了解到对方的ip和端口信息就发送数据就行了 # sendto和recvfrom的使用方法是完全和server端一致的 # client端不需要connect 因为UDP协议是不需要建立连接的 # 直接了解到对方的ip和端口信息就发送数据就行了 # sendto和recvfrom的使用方法是完全和server端一致的
#服务器端 import socket sk = socket.socket(type=socket.SOCK_DGRAM) sk.bind((\'127.0.0.1\',8080)) while True: msg,addr = sk.recvfrom(1024) print(addr) print(msg.decode(\'utf-8\')) info = input(\'>>>\').encode(\'utf-8\') sk.sendto(info,addr) sk.close() #客户端1 import socket sk = socket.socket(type=socket.SOCK_DGRAM) ip_port = (\'127.0.0.1\',8080) while True: info = input(\'tiger ：\') info = (\'\\033[34m来自tiger的消息 ：%s\\033[0m\'%info).encode(\'utf-8\') sk.sendto(info,ip_port) msg,addr = sk.recvfrom(1024) print(msg.decode(\'utf-8\')) sk.close() #客户端2 import socket sk = socket.socket(type=socket.SOCK_DGRAM) ip_port = (\'127.0.0.1\',8080) while True: info = input(\'二哥 ：\') info = (\'\\033[32m来自二哥的消息 ：%s\\033[0m\'%info).encode(\'utf-8\') sk.sendto(info,ip_port) msg,addr = sk.recvfrom(1024) print(msg.decode(\'utf-8\')) sk.close()
#服务器端 import time import socket sk = socket.socket(type=socket.SOCK_DGRAM) sk.bind((\'127.0.0.1\',8090)) while True: strf,addr = sk.recvfrom(1024) strf = strf.decode(\'utf-8\') res = time.strftime(strf).encode(\'utf-8\') sk.sendto(res,addr) sk.close() #客户端 import socket sk = socket.socket(type=socket.SOCK_DGRAM) addr = (\'127.0.0.1\',8090) info = input(\'>>>\').encode(\'utf-8\') sk.sendto(info,addr) ret,addr = sk.recvfrom(1024) print(ret.decode(\'utf-8\')) sk.close()
服务端套接字函数
s.bind() 绑定（主机，端口号）到套接字
s.listen() 开始TCP监听
s.accept() 被打接收TCP客户的连接，出错时返回出错码，而不是抛出异常
客户端套接字函数
s.connect() 主动初始化TCP服务器连接
s.connect_ex() connect()函数的扩展版本，出错时返回出错码，而不是抛出异常
公共用途的套接字函数
s.recv() 接收TCP数据
s.send() 发送TCP数据（send在待发数据量大于几端缓存区剩余空间时，数据丢失，不会发完）
s.sendall() 发送完整的TCP数据（本质就是循环调用send,sendall在待发数据量大于几端缓存区剩余空间时，数据不丢失，循环调用send直到发完）
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() 创建一个与该套接字相关的文件
四、黏包
黏包：同时执行多条命令之后，得到的结果很可能只有一部分，在执行其他命令的时候又接收到之前执行的另外一部分结果，这种显现就是黏包。
只有TCP有黏包现象，UDP永远不会黏包：
1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。
2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少个字节的数据所造成的。
用UDP协议发送时，用sendto函数最大能发送数据的长度为：65535- IP头(20) – UDP头(8)＝65507字节。用sendto函数发送数据时，如果发送数据长度大于该值，则函数会返回错误。（丢弃这个包，不进行发送）
用TCP协议发送时，由于TCP是数据流协议，因此不存在包大小的限制（暂不考虑缓冲区的大小），这是指在用send函数时，数据长度参数不受限制。而实际上，所指定的这段数据并不一定会一次性发送出去，如果这段数据比较长，会被分段发送，如果比较短，可能会等待和下一次数据一起发送。发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。
会发生黏包的两种情况:
1、发送方的缓存机制
发送端需要等缓冲区满才发送出去，造成黏包（发送数据时间间隔很短，数据量很小，会合到一起，产生黏包）
import socket 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() 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()
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(\'egg\'.encode(\'utf-8\'))
2、接收方的缓存机制
接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生黏包）
import socket 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()
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\'))
黏包的解决方案
方案一
import socket sk = socket.socket() sk.bind((\'127.0.0.1\',8080)) sk.listen() conn,addr = sk.accept() while True: cmd = input(\'>>>\') if cmd == \'q\': conn.send(b\'q\') break conn.send(cmd.encode(\'gbk\')) num = conn.recv(1024).decode(\'utf-8\') # 2048 conn.send(b\'ok\') res = conn.recv(int(num)).decode(\'gbk\') print(res) conn.close() sk.close()
import socket import subprocess sk = socket.socket() sk.connect((\'127.0.0.1\',8080)) while True: cmd = sk.recv(1024).decode(\'gbk\') 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() sk.send(str(len(std_out)+len(std_err)).encode(\'utf-8\')) #2000 sk.recv(1024) # ok sk.send(std_out) sk.send(std_err) sk.close() # 好处：确定了我到底要接收多大的数据 # 要在文件中配置一个配置项 ： 就是每一次recv的大小 buffer = 4096 # 当我们要发送大数据的时候 ，要明确的告诉接收方要发送多大的数据，以便接收方能够准确的接收到所有数据 # 多用在文件传输的过程中 # 大文件的传输 一定是按照字节读 每一次读固定的字节 # 传输的过程中 一边读一边传 接收端 一边收一边写 # 不好的地方：多了一次交互 # send sendto 在超过一定范围的时候 都会报错 # 程序的内存管理
方案二
借用struct模块，该模块可以把一个类型，如数字，转成固定长度的bytes。我们知道长度数字可以被转换成一个标准大小的4字节数字。因此可以利用这个特点来预先发送数据长度。
发送时：
先发送struct转换好的数据长度4字节；再发送数据。
接收时：
先接受4个字节使用struct转换成数字来获取要接收的数据长度；再按照长度接收数据。
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()
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编码
也可以把报头坐车字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，再用struct将序列化后的数据长度打包成4个字节。
发送时：
先发报头长度；再编码报头内容然后发送；最后发真实内容。
接收时：
先接收报头长度，用struct取出来；根据取出的长度收取报头内容，然后解码，反序列化；最后从反序列化的结果中取出待取数据的详细信息，最后去取真实的数据内容。
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))以上是关于python---网络编程的主要内容，如果未能解决你的问题，请参考以下文章