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 多路复用非阻塞效率要高于非阻塞方式 """
1155
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
