Python Socket请求网站获取数据

 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 += chunkchunk = sock.recv(1024)# print(response.decode())return responsedef 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:  # 非阻塞套接字捕获异常passrequest_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())breakexcept OSError:passresponse = b''while True:  # 不断地接收数据try:chunk = sock.recv(1024)  # 没有数据返回时会收到异常while chunk:  # 循环接收数据，因为一次接收不完整response += chunkchunk = sock.recv(1024)breakexcept BlockingIOError:  # 处理非阻塞异常pass# print(response.decode())return responsedef 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 = 80def 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 += chunkchunk = sock.recv(1024)# print(response.decode())return responsedef block_way():pool = ThreadPool(5)for i in range(10):pool.apply_async(blocking, args=(i,))pool.close()  # close()执行后不会有新的进程加入到poolpool.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 = 80def 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 += chunkchunk = sock.recv(1024)# print(response.decode())return responsedef block_way():pool = Pool(5)for i in range(10):pool.apply_async(blocking, args=(i,))pool.close()  # close()执行后不会有新的进程加入到poolpool.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 = 80def 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 += chunkchunk = sock.recv(1024)# print(response.decode())return responsedef 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 = 80sel = selectors.DefaultSelector()
flag = False  # 结束标志
num_list = [0] * 5class Crawler(object):def __init__(self,pn):self.pn = pnself.response = b''def req_connect(self):"""请求建立连接:return:"""sock = socket.socket()sock.setblocking(False)try:sock.connect((ACCESS_URL, ACCESS_PORT))  # 连接网站 ，发出一个HTTP请求except BlockingIOError:  # 非阻塞套接字捕获异常passsel.register(sock,selectors.EVENT_WRITE, self.conn_send)  # 监听socket，向服务端发送数据WRITEdef 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 flagchunk = sock.recv(1024)if chunk:self.response += chunkelse:# 没有数据可读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.datacallback(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 多路复用非阻塞效率要高于非阻塞方式"""