Python爬虫系统化学习(5)

Python爬虫系统化学习(5)

多线程爬虫,在之前的网络编程中,我学习过多线程socket进行单服务器对多客户端的连接，通过使用多线程编程，可以大大提升爬虫的效率。

Python多线程爬虫主要由三部分组成:线程的创建，线程的定义，线程中函数的调用。

线程的创建:多通过for循环调用进行,通过thread.start()唤醒线程,thread.join()等待线程自动阻塞

示例代码如下：

for i in range(1,6):
    thread=MyThread("thread"+str(i),list[i-1])
    thread.start()
    thread_list.append(thread)
for thread in thread_list:
    thread.join()

线程的定义:线程的定义使用了继承,通常定义线程中包含两个函数,一个是init初始化函数,在类创建时自动调用,另一个是run函数,在thread.start()函数执行时自动调用，示例代码如下:

class MyThread(threading.Thread):
    def __init__(self,name,link_s):
        threading.Thread.__init__(self)
        self.name=name
    def run(self):
        print('%s is in Process:'%self.name)
        #通过spider我们调用了爬虫函数
        spider(self.name,self.links)
        print('%s is out Process'%self.name)

线程中函数的调用是在run里面进行的,而多线程爬虫的重点就是将多线程与爬虫函数紧密结合起来,这就需要我们为爬虫们分布任务,也就是每个函数都要爬些什么内容。

首先我编写了个写文件,将贝壳找房的1-300页南京租房网址链接写入a.txt,代码如下：

zurl="https://nj.zu.ke.com/zufang/pg"
for i in  range(101,300):
    turl=url+str(i)+'\n'
    print(turl)
    with open ('a.txt','a+') as f:
        f.write(turl)

其次在main函数中将这些链接写入元组中

link_list=[]
with open('a.txt',"r") as f:
    file_list=f.readlines()
    for i in file_list:
        i=re.sub('\n','',i)
        link_list.append(i)

此后通过调用link_list[i]就可以为每个爬虫布置不同的任务了

max=len(link_list) #max为最大页数
page=0 #page为当前页数
def spider(threadName, link_range):
    global page
    global max
    while page<=max:
        i = page
        page+=1
        try:
            r = requests.get(link_list[i], timeout=20)
            soup = BeautifulSoup(r.content, "lxml")
            house_list = soup.find_all("div", class_="content__list--item")
            for house in house_list:
                global num
                num += 1
                house_name = house.find('a', class_="twoline").text.strip()
                house_price = house.find('span', class_="content__list--item-price").text.strip()
                info ="page:"+str(i)+"num:" + str(num) + threadName + house_name + house_price
                print(info)
        except Exception as e:
            print(threadName, "Error", e)

如此这些线程就可以异步的进行信息获取了，整体代码如下

#coding=utf-8
import re
import requests
import threading
import time
from bs4 import BeautifulSoup
page=0
num=0
link_list=[]
with open('a.txt',"r") as f:
    file_list=f.readlines()
    for i in file_list:
        i=re.sub('\n','',i)
        link_list.append(i)
max=len(link_list)
print(max)
class MyThread(threading.Thread):
    def __init__(self,name):
        threading.Thread.__init__(self)
        self.name=name
    def run(self):
        print('%s is in Process:'%self.name)
        spider(self.name)
        print('%s is out Process'%self.name)
max=len(link_list) #max为最大页数
page=0 #page为当前页数
def spider(threadName):
    global page
    global max
    while page<=max:
        i = page
        page+=1
        try:
            r = requests.get(link_list[i], timeout=20)
            soup = BeautifulSoup(r.content, "lxml")
            house_list = soup.find_all("div", class_="content__list--item")
            for house in house_list:
                global num
                num += 1
                house_name = house.find('a', class_="twoline").text.strip()
                house_price = house.find('span', class_="content__list--item-price").text.strip()
                info ="page:"+str(i)+"num:" + str(num) + threadName + house_name + house_price
                print(info)
        except Exception as e:
            print(threadName, "Error", e)
start = time.time()
for i in range(1,6):
    thread=MyThread("thread"+str(i))
    thread.start()
    thread_list.append(thread)
for thread in thread_list:
    thread.join()
end=time.time()
print("All using time:",end-start)

此外多线程爬虫还可以与队列方式结合起来，产生全速爬虫，速度会更快一点：具体完全代码如下：

#coding:utf-8
import threading
import time
import re
import requests
import queue as Queue
link_list=[]
with open('a.txt','r') as f:
   file_list=f.readlines()
   for each in file_list:
      each=re.sub('\n','',each)
      link_list.append(each)
class MyThread(threading.Thread):
   def __init__(self,name,q):
      threading.Thread.__init__(self)
      self.name=name
      self.q=q
   def run(self):
      print("%s is start "%self.name)
      crawel(self.name,self.q)
      print("%s is end "%self.name)
def crawel(threadname,q):
   while not q.empty():
      temp_url=q.get(timeout=1)
      try:
         r=requests.get(temp_url,timeout=20)
         print(threadname,r.status_code,temp_url)
      except Exception as e:
         print("Error",e)
         pass
if __name__=='__main__':
   start=time.time()
   thread_list=[]
   thread_Name=['Thread-1','Thread-2','Thread-3','Thread-4','Thread-5']
   workQueue=Queue.Queue(1000)
   #填充队列
   for url in link_list:
      workQueue.put(url)
   #创建线程
   for tname in thread_Name:
      thread=MyThread(tname,workQueue)
      thread.start()
      thread_list.append(thread)
   for t in thread_list:
      t.join()
   end=time.time()
   print("All using time:",end-start)
   print("Exiting Main Thread")

使用队列进行爬虫需要queue库,除去线程的知识,我们还需要队列的知识与之结合,上述代码中关键的队列知识有创建与填充队列,调用队列,持续使用队列3个，分别如下：

️：创建与队列：

workQueue=Queue.Queue(1000)
   #填充队列
   for url in link_list:
      workQueue.put(url)

️：调用队列：

thread=MyThread(tname,workQueue)

️：持续使用队列：

def crawel(threadname,q):
   while not q.empty():
      pass

使用队列的思想就是先进先出,出完了就结束。

多进程爬虫:一般来说多进程爬虫有两种组合方式:multiprocessing和Pool+Queuex

muiltprocessing使用方法与thread并无多大差异,只需要替换部分代码即可,分别为进程的定义与初始化,以及进程的结束。

️：进程的定义与初始化：

class Myprocess(Process):
    def __init__(self):
        Process.__init__(self)

️：进程的递归结束：设置后当父进程结束后,子进程自动会被终止

p.daemon=True

另外一种方法是通过Manager和Pool结合使用

manager=Manager()
workQueue=manager.Queue(1000)
for url in link_list:
    workQueue.put(url)
pool=Pool(processes=3)
for i in range(1,5):
    pool.apply_async(crawler,args=(workQueue,i))
pool.close()
pool.join()