python - 网络编程
Python 提供了两个访问网络服务的方式
底层网络接口socket,这个模块提供了访问BSD Socket的接口,在所有现代 Unix 系统、Windows、macOS 和其他一些平台上可用。
用于简化网络服务端编写的类 socketserver
什么是socket
socket又称 套接字,应用程序通常通过"套接字"向网络发出请求或者应答网络请求,使主机间或者一台计算机上的进程间可以通讯
Python TCP | UDP使用socket的通信过程
套接字对象的创建
# socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)
"""
family:
AF_INET :一对 (host, port) 被用于 AF_INET 地址族
host: '127.0.0.1' or 'vn.asdadasaa.com'
port: 为一个整数,代表主机上的端口号
AF_INET6:一个四元组 (host, port, flowinfo, scopeid)
flowinfo代表了 C 库 struct sockaddr_in6 中的 sin6_flowinfo
scopeid 代表了 C 库 struct sockaddr_in6 中的 sin6_scope_id
上面的两个参数都可以省略
AF_UNIX: unix操作系统的通信方式,其它不祥
...
type:
SOCK_STREAM: 基于TCP连接的套接字
SOCK_DGRAM : 基于UDP连接的套接字
...
proto: 一般不写
fileno: 如果存在这个参数,则上面的默认参数将 不 会存在
"""
class socket(_socket.socket):
"""A subclass of _socket.socket adding the makefile() method."""
__slots__ = ["__weakref__", "_io_refs", "_closed"]
def __init__(self, family=-1, type=-1, proto=-1, fileno=None):
# For user code address family and type values are IntEnum members, but
# for the underlying _socket.socket they're just integers. The
# constructor of _socket.socket converts the given argument to an
# integer automatically.
if fileno is None:
if family == -1:
family = AF_INET
if type == -1:
type = SOCK_STREAM
if proto == -1:
proto = 0
_socket.socket.__init__(self, family, type, proto, fileno)
self._io_refs = 0
self._closed = False
tcp是基于链接的,必须先启动服务端,然后再启动客户端去连接服务端
下面是基于TCP协议的socket
import socket
# server端
sk = socket.socket() # 创建服务端socket对象
sk.bind(('localhost', 8081)) # 把地址,端口绑定到socket对象
sk.listen() # 监听连接
conn, addr = sk.accept() # 接受客户端连接
# 这里 收/发 数据都是可以的
str = '连接成功'.encode('utf-8')
conn.send(str) # 向客户端发生信息
conn.close() # 关闭客户端连接
sk.close() # 关闭服务端socket对象
import socket
# client 端
sk = socket.socket() # 创建客户端socket对象
sk.connect(('localhost', 8081)) # 尝试连接服务器
# 这里 收/发 数据都是可以的
res = sk.recv(1024).decode() # 接受服务端发生的数据
print(res)
sk.close() # 关闭客户端的ocket对象
这上面的代码多次运行可能会出现端口占用的错误
OSError: [Errno 98] Address already in use
解决方案(仅在测试环境添加下面):
from socket import SOL_SOCKET,SO_REUSEADDR
sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #加在bind前加
udp是无链接的,启动服务之后可以直接接受消息,不需要提前建立链接
下面是基于udp协议的socket
import socket
# server端
sk = socket.socket(type=socket.SOCK_DGRAM) # 创建服务端socket对象
sk.bind(('127.0.0.1',8000)) # 把地址,端口绑定到socket对象
msg, addr = sk.recvfrom(1024) # 接收 UDP 数据,返回值是(data,address)
# 其中 data 是包含接收数据的字符串,address 是发送数据的套接字地址
print(msg, addr)
sk.sendto(b'Hi', addr) # 发送 UDP 数据,将数据发送到套接字
# addr 是形式为(ipaddr,port)的元组,指定远程地址。返回值是发送的字节数
sk.close()
import socket
# client端
ip_port = ('localhost', 8000)
sk = socket.socket(type=socket.SOCK_DGRAM)
sk.sendto(b'Hi Server', ip_port)# 发送 UDP 数据,将数据发送到套接字
# ip_port 是形式为(ipaddr,port)的元组,指定远程地址。返回值是发送的字节数
back_msg, addr = sk.recvfrom(1024)# 接收 UDP 数据,返回值是(back_msg,addr)
# 其中 back_msg 是包含接收数据的字符串,addr 是发送数据的套接字地址
print(back_msg.decode(), addr)
sk.close()
黏包:先看下面代码所出现的现象
import socket
# server端
sk = socket.socket()
sk.bind(('localhost', 8081))
sk.listen()
conn, addr = sk.accept()
conn.send(b'hello, ')
conn.send(b'world')
conn.close()
sk.close()
import socket
# client端
sk = socket.socket()
sk.connect(('localhost', 8081))
res = sk.recv(1024).decode()
print(res, '<====1====>') # hello, world <====1====>
res = sk.recv(1024).decode()
print(res, '<====2====>') # <====2====>
sk.close()
由上面的结果不难可以看到 在client端第一次接受到结果为server端两次发送的结果,而在client端第二次接受数据时,却没有了,这就被我们成为黏包。
同时执行多条代码时,得到的结果很可能只有一部分结果,在执行其它代码的时候又接收到之前执行的另外一部分结果,这种显现就是黏包。
黏包现象
# tcp协议在发送数据时,会出现黏包现象.
(1)数据粘包是因为在客户端/服务器的发送端和接收端都会有一个数据缓冲区,缓冲区用来临时保存数据,默认空间都设置较大。
在收发数据频繁时,由于tcp传输消息的无边界特点,不清楚应该截取多少长度,导致客户端/服务器端,都有可能把多条数据当成是一条数据进行截取,造成黏包
(2)发送方引起的粘包是由TCP协议本身造成的,TCP为提高传输效率,发送方往往要收集到足够多的数据后才发送一个数据包。
若连续几次发送的数据都很少,通常TCP会根据优化算法把这些数据合成一包后在发送,这样接收方就收到了粘包数据。
(3)接收方引起的粘包是由于接收方用户进程不及时接收数据,从而导致粘包现象。
这是因为接收方先把收到的数据放在系统接缓冲区,用户进程从该缓冲区取数据,
若下一个数据包到达时,上一个数据包尚未被用户进程取走,则系统可能把多条数据当成是一条数据进行截取
# 总结: TCP协议是面向连接的无边界协议
黏包现象一:
在发送端,由于在缓冲区两个数据小,发送的时间隔短,TCP会根据优化算法把这些数据合成一个发送
黏包现象二:
在接收端,由于在缓冲区没及时接受数据,截取数据时把多次发送的数据截取成一条,形成了黏包
黏包对比:tcp和udp
#tcp协议:
缺点:接收时数据之间无边界,有可能粘合几条数据成一条数据,造成黏包
优点:不限制数据包的大小,稳定传输不丢包
#udp协议:
优点:接收时候数据之间有边界,传输速度快,不黏包
缺点:限制数据包的大小(受带宽路由器等因素影响),传输不稳定,可能丢包
#tcp和udp对于数据包来说都可以进行拆包和解包,理论上来讲,无论多大都能分次发送
但是tcp一旦发送失败,对方无响应(对方无回执),tcp可以选择再发,直到对应响应完毕为止
而udp一旦发送失败,是不会询问对方是否有响应的,如果数据量过大,易丢包
解决黏包问题
#解决黏包场景:
应用场景在实时通讯时,需要阅读此次发的消息是什么
#不需要解决黏包场景:
下载或者上传文件的时候,最后要把包都结合在一起,黏包无所谓.
黏包的解决方案 struct 模块
该模块可以把一个类型,如数字,转成固定长度的bytes
# struct模块的基本使用
import struct
# 'i' format requires -2147483648 <= number <= 2147483647
# 这里的i代表整型 int
struct.pack('i', 1234) # b'\xd2\x04\x00\x00'
len(struct.pack('i', 1234)) # 4
struct.unpack('i' ,b'\xd2\x04\x00\x00') #(1234,)
import socket
import struct
# server端
sk = socket.socket()
sk.bind(('localhost', 8080))
sk.listen()
conn, addr = sk.accept()
for i in range(1, 11):
string = '这是第{}次发送的数据'.format(i).encode()
# 第一次发送数据的长度
len_bytes = struct.pack('i', len(string))
conn.send(len_bytes)
# 第二次发送真实的数据
conn.send(string)
conn.close()
sk.close()
import socket
import struct
# client端
sk = socket.socket()
sk.connect(('localhost', 8080))
for i in range(10):
# 第一次接受到的数据为服务器接发送的长度
len_bytes = sk.recv(4)
length = struct.unpack('i', len_bytes)[0]
# 第二次接受到的数据为真实的数据
res = sk.recv(length).decode()
print(res)
sk.close()
socketserver模块 (后续剖析)
import socketserver
# server端
class MyServer(socketserver.BaseRequestHandler):
def handle(self) -> None:
self.request.send('连接上了....'.encode())
for i in range(10):
msg = self.request.recv(1024).decode().replace('发送', '接收')
print(msg)
server = socketserver.ThreadingTCPServer(('127.0.0.1', 8081), MyServer)
server.serve_forever()
import socket,time
with socket.socket() as sk:
sk.connect(('localhost', 8081))
res = sk.recv(1024).decode()
print(res)
for i in range(10):
time.sleep(2)
msg = '[客户端]这是我发的第{}条消息'.format(i)
sk.send(msg.encode())
socket的更多方法介绍(了解)
服务端套接字函数
s.bind() 绑定(主机,端口号)到套接字
s.listen() 开始TCP监听
s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来
客户端套接字函数
s.connect() 主动初始化TCP服务器连接
s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
(等价于:异常处理+connect 一旦网络不通,作用:返回错误号而不是直接报错)
公共用途的套接字函数
s.recv() 接收TCP数据
s.send() 发送TCP数据,send返回值是发送的[字节数量],这个值可能小于要发送的string字节数
s.sendall() 发送TCP数据,sendall返回值是None,发送string所有数据
'''
# 下面两个代码等价:
#sendall => sock.sendall('Hello world\n')
#send => buffer = 'Hello world\n'
while buffer:
n = sock.send(buffer)
buffer = buffer[n:] (切片)
'''
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() 创建一个与该套接字相关的文件
更多方法