多线程爬取豆瓣top250的源码奉上，有个疑点请教各位大佬

念羁情

最近学习多进程和多线程爬虫以提升效率。多进程基本搞懂了，多线程这块也差不多，不过在用多线程爬取豆瓣电影排行榜的时候，开了三个解析线程，每个线程解析第一页的速度都远远快于后面的页，百思不得其解，忘高手指点。源码奉上，基本的注释也都加了，数据存储在一个excel表格中，表格如图（这里添加不了图片？算了，表格内容就是A-O列第一行分别为排名,片名,年份,国家,导演,编剧,主演,类型,片长,又名,评分,评分人数,主题,详情页,图片链接）。

代码如下，可以复制过去直接运行。看出问题所在，可以微信加我，10块钱红包

1. #多线程爬取豆瓣top250
   
2. import re
   
3. import  requests
   
4. import  time
   
5. from bs4 import  BeautifulSoup
   
6. from openpyxl import load_workbook as lw
   
7. import threading
   
8. from queue import  Queue
   
9. 
   
10. #采集线程类
    
11. class CrawlThread(threading.Thread):
    
12.     def __init__(self,thread_name,page_queue,html_queue):
    
13.         super(CrawlThread, self).__init__()
    
14.         self.thread_name = thread_name
    
15.         self.page_queue = page_queue
    
16.         self.html_queue = html_queue
    
17.     def run(self):
    
18.         print('———%s开始工作———' % self.thread_name)
    
19.         while not CRAWL_EXIT:
    
20.             page = self.page_queue.get()
    
21.             print('—%s开始爬取第%s页-' % (self.thread_name,page))
    
22.             url = 'https://movie.douban.com/top250?start=' + str((page-1) * 25) + '&filter='
    
23.             html = requests.get(url).text
    
24.             self.html_queue.put((page,html))#页面队列中，将html页面和页码组成元祖存入页面队列中
    
25.             print('—%s爬取第%s页完毕—' % (self.thread_name,page))
    
26.         print('———%s工作完毕———' % self.thread_name)
    
27. 
    
28. #解析线程类
    
29. class ParseThread(threading.Thread):
    
30.     def __init__(self,thread_name,html_queue,sheet):
    
31.         super(ParseThread, self).__init__()
    
32.         self.thread_name = thread_name
    
33.         self.html_queue = html_queue
    
34.         self.sheet = sheet
    
35.     def run(self):
    
36.         print('******%s开始工作******' % self.thread_name)
    
37.         while not PARSE_EXIT:
    
38.             item = self.html_queue.get()#页面队列中取出页码和页面数据
    
39.             page,html = item[0],item[1]
    
40.             print('【%s开始解析第%s页】' % (self.thread_name,page))
    
41.             time1 = time.time()
    
42.             result = self.parse(html)
    
43.             for each in result:  # 填表及保存图片
    
44.                 # 爬取的每条数据根据排名存入对应的行，因此多线程并发写入该文件不会引起混乱，该操作不需要加锁
    
45.                 row = int(each[0]) + 1
    
46.                 self.sheet['A%s' % row].value = str(each[0])
    
47.                 # sheet['A%s' % row].value = each[0]#这行为什么报错呢？匪夷所思！！！
    
48.                 self.sheet['B%s' % row].value = each[1]
    
49.                 self.sheet['C%s' % row].value = each[2]
    
50.                 self.sheet['D%s' % row].value = each[3]
    
51.                 self.sheet['E%s' % row].value = each[4]
    
52.                 self.sheet['F%s' % row].value = each[5]
    
53.                 self.sheet['G%s' % row].value = each[6]
    
54.                 self.sheet['H%s' % row].value = each[7]
    
55.                 self.sheet['I%s' % row].value = each[8]
    
56.                 self.sheet['J%s' % row].value = each[9]
    
57.                 self.sheet['K%s' % row].value = each[10]
    
58.                 self.sheet['L%s' % row].value = each[11]
    
59.                 self.sheet['M%s' % row].value = each[12]
    
60.                 self.sheet['N%s' % row].value = each[13]
    
61.                 self.sheet['O%s' % row].value = each[14]
    
62.             time2 = time.time()
    
63.             print('【%s解决掉第%s页，耗时%s秒】' % (self.thread_name,page,int(time2-time1)))
    
64.         print('******%s工作完毕******' % self.thread_name)
    
65.     def parse(self,html):
    
66.         soup = BeautifulSoup(html, 'lxml')
    
67.         # 以下定义存放各类数据的空列表
    
68.         ranks = []
    
69.         names = []
    
70.         years = []
    
71.         countrys = []
    
72.         directors = []
    
73.         scriptwriters = []
    
74.         stars = []
    
75.         types = []
    
76.         runtimes = []
    
77.         themes = []
    
78.         detail_links = []
    
79.         pic_srcs = []
    
80.         other_names = []
    
81.         scores = []
    
82.         num_of_rating_person = []
    
83.         other_name_pattern = re.compile(r'<span class="pl">又名:</span>(.+?)<br/>', re.S)  # 影片又名用正则提取
    
84.         # 年份，国家，类型用正则提取。这里由于是从bs解析返回的网页文档中获取数据，因此其格式与requests直接获取的网页内容
    
85.         # 有区别， 因此正则表达式与豆瓣top250_bs4_1中该处的正则有所区别
    
86.         year_country_type_pattern = re.compile(r'<br/>\s*?(.*?)\s*?</p>')
    
87.         for li in soup.ol.find_all('li'):
    
88.             ranks.append(li.find('em').string)  # 提取排名
    
89.             names.append(li.find('img')['alt'])  # 提取片名，从图片链接的属性中提取
    
90.             try:  # 提取主题
    
91.                 themes.append(li.find('span', attrs={'class': 'inq'}).text)
    
92.             except AttributeError:
    
93.                 themes.append('无')
    
94.             scores.append(li.find('span', attrs={'class': 'rating_num'}).text)  # 提取评分
    
95.             div = li.find('div', attrs={'class': 'star'})  # 提取评分人数
    
96.             num_of_rating_person.append(div.find_all('span', attrs={'class': ''})[1].text)
    
97.             year_country_type = re.search(year_country_type_pattern, li.prettify()).group(1).split('/')  # 提取年份，国家，类型
    
98.             # 因为67条，上映年份列了好几个，都是用‘/’来分隔，因此年份只取第一个（0），而国家和类型则用倒序索引提取（-2，-1）
    
99.             years.append(year_country_type[0].strip())
    
100.             countrys.append(year_country_type[-2].strip())
     
101.             types.append(year_country_type[-1].strip())
     
102. 
     
103.             detail_link = li.find('a')['href']  # 提取详情页链接
     
104.             detail_links.append(detail_link)
     
105.             detail_html = requests.get(detail_link).text  # 进入详情页提取其他内容
     
106.             soup2 = BeautifulSoup(detail_html, 'lxml')
     
107.             pic_srcs.append(soup2.find('img', attrs={'title': '点击看更多海报'})['src'])  # 提取图片链接
     
108.             # 提取导演0、编剧1、主演2；纪录片可能没有编剧和主演，因此加判断
     
109.             director_scriptwriter = soup2.find_all('span', attrs={'class': 'attrs'})
     
110.             if len(director_scriptwriter) == 3:
     
111.                 directors.append(director_scriptwriter[0].text)
     
112.                 scriptwriters.append(director_scriptwriter[1].text)
     
113.                 stars.append(director_scriptwriter[2].text)
     
114.             else:
     
115.                 directors.append(director_scriptwriter[0].text)
     
116.                 scriptwriters.append('无')
     
117.                 stars.append('无')
     
118. 
     
119.             runtimes.append(soup2.find('span', attrs={'property': 'v:runtime'}).text)  # 提取片长
     
120. 
     
121.             try:  # 提取又名。又名内容不在标签里，故借助正则提取。有些影片没有给出又名，故需加一个异常处理。
     
122.                 other_name = re.search(other_name_pattern, detail_html).group(1)
     
123.                 other_names.append(other_name)
     
124.             except AttributeError:
     
125.                 other_names.append('无')
     
126.             # 通过zip返回结果
     
127.         return zip(ranks, names, years, countrys, directors, scriptwriters, \
     
128.                    stars, types, runtimes, other_names, scores, num_of_rating_person, themes, detail_links, pic_srcs)
     
129.         # for each in zip(ranks,names,years,countrys,directors,scriptwriters,\
     
130.         #                 stars,types,runtimes,other_names,scores,num_of_rating_person,themes,detail_links,pic_srcs):
     
131.         #     print(each)
     
132. 
     
133. # 采集线程退出信号
     
134. CRAWL_EXIT = False
     
135. # 解析线程退出信号
     
136. PARSE_EXIT = False
     
137. def main():
     
138.     page_queue = Queue(10)#页码队列，供采集线程爬取页面
     
139.     html_queue = Queue()#爬取的页面放入页面队列，供解析线程解析页面并处理数据
     
140.     for page in range(1,7):#例如爬取1-6页
     
141.         page_queue.put(page)
     
142.     crawl_thread_names = ['采集线程%s号' % i for i in range(1,4)]#定义3个采集线程的名字
     
143.     parse_thread_names = ['解析线程%s号' % i for i in range(1,4)]#定义3个解析线程的名字
     
144.     crawl_list = []#实例化后的采集线程存入该列表
     
145.     parse_list = []#实例化后的解析线程存入该列表
     
146. 
     
147.     wb = lw('豆瓣top250_2.xlsx')#爬取的数据存入此Excel表格
     
148.     sheet = wb['Sheet1']#该sheet对象作为参数传给解析线程，以供解析线程写入数据
     
149. 
     
150.     #启动采集线程
     
151.     for thread_name in crawl_thread_names:
     
152.         crawl_thread = CrawlThread(thread_name,page_queue,html_queue)
     
153.         crawl_thread.start()
     
154.         crawl_list.append(crawl_thread)
     
155.     #启动解析线程
     
156.     for thread_name in parse_thread_names:
     
157.         parse_thread = ParseThread(thread_name,html_queue,sheet)
     
158.         parse_thread.start()
     
159.         parse_list.append(parse_thread)
     
160. 
     
161.     #等待page_queue队列为空，等待采集线程工作完毕后全部退出工作(join)。
     
162.     while not page_queue.empty():
     
163.         pass
     
164.     print('\npage_queue为空\n')
     
165.     global  CRAWL_EXIT
     
166.     CRAWL_EXIT = True
     
167.     for crawl_thread in crawl_list:
     
168.         crawl_thread.join()
     
169.     print('——————采集线程全部结束工作——————')
     
170. 
     
171.     # 等待page_queue队列为空，等待解析线程工作完毕后全部退出工作(join)。
     
172.     while not html_queue.empty():
     
173.         pass
     
174.     print('\nhtml_queue为空\n')
     
175.     global PARSE_EXIT
     
176.     PARSE_EXIT = True
     
177.     for parse_thread in parse_list:
     
178.         parse_thread.join()
     
179.     print('——————解析线程全部结束工作——————')
     
180. 
     
181.     #保存excel
     
182.     wb.save('豆瓣top250_2.xlsx')
     
183. 
     
184. if __name__ == '__main__':
     
185.     time_start = time.time()
     
186.     main()
     
187.     time_end = time.time()
     
188.     print('总耗时%s秒' % (time_start - time_end))

复制代码

念羁情

微信1324726119可加我，可以多交流。

念羁情

完整测试了下，刚才那个表述有问题。应该是，每个线程最后一个页面耗时很短。比如爬取10个页面，开5个线程，情况如下图。
C:\Users\念羁情\Desktop\截图00.png