百木园-与人分享,
就是让自己快乐。

python - 网络编程

Python 提供了两个访问网络服务的方式
底层网络接口socket,这个模块提供了访问BSD Socket的接口,在所有现代 Unix 系统、Windows、macOS 和其他一些平台上可用。
用于简化网络服务端编写的类 socketserver

什么是socket
socket又称 套接字,应用程序通常通过\"套接字\"向网络发出请求或者应答网络请求,使主机间或者一台计算机上的进程间可以通讯

Python TCP | UDP使用socket的通信过程
TCP|UDP

套接字对象的创建

# 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() 创建一个与该套接字相关的文件

更多方法

来源:https://www.cnblogs.com/EdenWu/p/14510300.html
图文来源于网络,如有侵权请联系删除。

未经允许不得转载:百木园 » python - 网络编程

相关推荐

  • 暂无文章