Python Socket请求网站获取数据

Python Socket请求网站获取数据

https://www.cnblogs.com/xiao-apple36/p/8673356.html
  1. 一 . 阻塞方式 
  2. 二. 非阻塞方式
  3. 三. 多线程方式
  4. 四. 多进程方式
  5. 五. 协程方式
  6. 六. IO多路复用

 Python Socket请求网站获取数据

—阻塞 I/O           ->收快递,快递如果不到,就干不了其他的活

—非阻塞I/0       ->收快递,不断的去问,有没有送到,有没有送到,…如果送到了就接收

—I/O多路复用      ->找个代理人(select), 去收快递。快递到了,就通知用户.  

一 . 阻塞方式 

blocking IO 会一直block 对应的进程,直到操作完成

客户端请求网站-阻塞实现(一次一次的请求)
import socket
import time
访问网站
ACCESS_URL = 'www.baidu.com'
端口
ACCESS_PORT = 80
socket阻塞请求网站
def blocking(pn):
sock = socket.socket()
sock.connect((ACCESS_URL, ACCESS_PORT)) # 连接网站 ,发出一个HTTP请求
request_url = 'GET {} HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n'.format('/s?wd={}'.format(pn))
sock.send(request_url.encode())
response = b''
chunk = sock.recv(1024)
while chunk: # 循环接收数据,因为一次接收不完整
response += chunk
chunk = sock.recv(1024)
# print(response.decode())
return response
def block_way():
for i in range(5):
blocking(i)
if name == 'main':
start = time.time()
block_way()
print('请求5次页面耗时{}'.format(time.time() - start))
"""
请求5次页面耗时2.4048924446105957
"""

二. 非阻塞方式

non-blcoking在kernel还没准备好数据的情况下,会立即返回(会抛出异常)

客户端请求网站-非阻塞实现
import socket
import time
访问网站
ACCESS_URL = 'www.baidu.com'
端口
ACCESS_PORT = 80
socket非阻塞请求网站(时间消耗在不断的while循环中,和阻塞的时间差不多)
def blocking(pn):
sock = socket.socket()
sock.setblocking(False) # 设置为非阻塞
try:
# connect连接需要一定时间,非阻塞发送完请求,立即返回,如果没有数据会报异常
sock.connect((ACCESS_URL, ACCESS_PORT)) # 连接网站 ,发出一个HTTP请求
except BlockingIOError: # 非阻塞套接字捕获异常
pass
request_url = 'GET {} HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n'.format('/s?wd={}'.format(pn))
while True: # 不断发送http请求
try:
sock.send(request_url.encode())
break
except OSError:
pass
response = b''
while True: # 不断地接收数据
try:
chunk = sock.recv(1024) # 没有数据返回时会收到异常
while chunk: # 循环接收数据,因为一次接收不完整
response += chunk
chunk = sock.recv(1024)
break
except BlockingIOError: # 处理非阻塞异常
pass
# print(response.decode())
return response
def block_way():
for i in range(5):
blocking(i)
if name == 'main':
start = time.time()
block_way()
print('请求5次页面耗时{}'.format(time.time() - start))
"""
请求5次页面耗时2.681565046310425
时间消耗在不断的while循环中,和阻塞的时间差不多
"""

三. 多线程方式

客户端请求网站-线程池实现
import socket
from multiprocessing.pool import ThreadPool
import time
访问网站
ACCESS_URL = 'www.baidu.com'
端口
ACCESS_PORT = 80
def blocking(pn):
sock = socket.socket()
sock.connect((ACCESS_URL, ACCESS_PORT)) # 连接网站 ,发出一个HTTP请求
request_url = 'GET {} HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n'.format('/s?wd={}'.format(pn))
sock.send(request_url.encode())
response = b''
chunk = sock.recv(1024)
while chunk: # 循环接收数据,因为一次接收不完整
response += chunk
chunk = sock.recv(1024)
# print(response.decode())
return response
def block_way():
pool = ThreadPool(5)
for i in range(10):
pool.apply_async(blocking, args=(i,))
pool.close() # close()执行后不会有新的进程加入到pool
pool.join() # join函数等待子进程结束
if name == 'main':
start = time.time()
block_way()
print('请求10次页面耗时{}'.format(time.time() - start))
"""
请求10次页面耗时1.1231656074523926
"""

四. 多进程方式

客户端请求网站-进程池实现
import socket
from multiprocessing import Pool
import time
访问网站
ACCESS_URL = 'www.baidu.com'
端口
ACCESS_PORT = 80
def blocking(pn):
"""
发送请求,接收数据
:param pn:
:return:
"""
sock = socket.socket()
sock.connect((ACCESS_URL, ACCESS_PORT)) # 连接网站 ,发出一个HTTP请求
request_url = 'GET {} HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n'.format('/s?wd={}'.format(pn))
sock.send(request_url.encode())
response = b''
chunk = sock.recv(1024)
while chunk: # 循环接收数据,因为一次接收不完整
response += chunk
chunk = sock.recv(1024)
# print(response.decode())
return response
def block_way():
pool = Pool(5)
for i in range(10):
pool.apply_async(blocking, args=(i,))
pool.close() # close()执行后不会有新的进程加入到pool
pool.join() # join函数等待子进程结束
if name == 'main':
start = time.time()
block_way()
print('请求10次页面耗时{}'.format(time.time() - start))
"""
请求10次页面耗时1.1685676574707031 略慢于线程池实现方式,因为进程相对于线程开销比较大
"""

五. 协程方式

客户端请求网站-协程实现
from gevent import monkey;monkey.patch_all() # 加补丁,实现非阻塞
import socket
import gevent
import time
访问网站
ACCESS_URL = 'www.baidu.com'
端口
ACCESS_PORT = 80
def blocking(pn):
"""
发送请求,接收数据
:param pn:
:return:
"""
sock = socket.socket()
sock.connect((ACCESS_URL, ACCESS_PORT)) # 连接网站 ,发出一个HTTP请求
request_url = 'GET {} HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n'.format('/s?wd={}'.format(pn))
sock.send(request_url.encode())
response = b''
chunk = sock.recv(1024)
while chunk: # 循环接收数据,因为一次接收不完整
response += chunk
chunk = sock.recv(1024)
# print(response.decode())
return response
def block_way():
tasks = [gevent.spawn(blocking,i) for i in range (10)] #启动协程
gevent.joinall(tasks) # 阻塞等待所有操作都执行完毕
if name == 'main':
start = time.time()
block_way()
print('请求10次页面耗时{}'.format(time.time() - start))
"""
请求10次页面耗时0.6231002807617188 效率高于线程方式,协程相当于单线程并发(微线程),开销小于线程
"""

六. IO多路复用

I/O多路复用就是通过一种机制,操作系统通过一个进程可以监视多个描述符,一旦某个描述符就绪(一般是读就绪或者写就绪),能够通知程序进行相应的读写操作。

客户端请求网站-I/O多路复用
import socket
import selectors
import time
访问网站
ACCESS_URL = 'www.baidu.com'
端口
ACCESS_PORT = 80
sel = selectors.DefaultSelector()
flag = False # 结束标志
num_list = [0] * 5
class Crawler(object):
def init(self,pn):
self.pn = pn
self.response = b''
def req_connect(self): """ 请求建立连接 :return: """ sock = socket.socket() sock.setblocking(False) try: sock.connect((ACCESS_URL, ACCESS_PORT)) # 连接网站 ,发出一个HTTP请求 except BlockingIOError: # 非阻塞套接字捕获异常 pass sel.register(sock,selectors.EVENT_WRITE, self.conn_send) # 监听socket,向服务端发送数据WRITE def conn_send(self,sock): """ 发送请求数据 :param sock: :return: """ # 取消上面注册监听的套接字 sel.unregister(sock) request_url = 'GET {} HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n'.format('/s?wd={}'.format(self.pn)) sock.send(request_url.encode()) # 当我们发送数据之后,就等接收数据 sel.register(sock,selectors.EVENT_READ, self.read) def read(self, sock): global flag chunk = sock.recv(1024) if chunk: self.response += chunk else: # 没有数据可读 print(self.response) sel.unregister(sock) num_list.pop() if not num_list: flag = True
事件循环
def loop():
while not flag:
events = sel.select() # 监听发生了变化的套接字
for key, mask in events:
callback = key.data
callback(key.fileobj)
if name == 'main':
start = time.time()
# print(num_list)
for i in range(5):
crawler = Crawler(i) # 实例
crawler.req_connect()
loop()
print('请求5次页面耗时{}'.format(time.time() - start))
"""
请求5次页面耗时0.5865745544433594 多路复用非阻塞效率要高于非阻塞方式
"""

Leave a Reply

Your email address will not be published. Required fields are marked *