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 多路复用非阻塞效率要高于非阻塞方式
"""