由于最近一直在研究基于机器学习的推荐系统，需要大量的数据来训练AI模型，但是在模型的测试验证过程中，苦于中文数据集的缺失(或者说根本没有，国人在这方面做得实在是太差了)，只能利用国外公开的推荐系统数据集，有著名的
MovieLens电影评分数据集
和
Del.icio.us链接推荐数据集
，虽然通过计算损失函数也能大致的评估推荐模型的优劣程度从而进行相应的优化，但是由于语言环境、文化等等的不同，国外人对某个电影的评分毕竟跟我们还是有一定差距的，在输出推荐结果时，即使给出的某个电影或者某个网站链接其相似度很高时，我仍然不确定这个推荐结果是否真的如损失函数计算的那样准确。所以，为了能拥有一个可以用于训练的中文的数据集，就有了本文所记录的豆瓣影评的抓取过程。
首先还是要分析一下要抓取的网站
豆瓣电影
,主要是通过搜索引擎或者浏览器的调试工具看看有没有可以利用的API，在没有找到任何api的前提下才开始分析网站的页面结构，找到可以提取的信息。
豆瓣开发者平台
，在
豆瓣电影
的文档中有获取电影，获取影评等等的详细接口，正当我以为接下来的数据采集将会变得非常简单之时，下面这张图还是让我冷静了下来
如果你在2015年之前注册过豆瓣的开发者，那么恭喜你,你可以通过豆瓣提供的API或者SDK获取你想获得的任何数据
电影信息获取
虽然APIKey是不可能拿到了，但是通过文档我仍然发现了一些GET请求并不需要AUTH认证，也就是说有没有APIKey并不影响使用。其中，对我们有用的就是获取
TOP250电影列表
的接口:
http://api.douban.com/v2/movie/top250
接口返回的格式大概如下:
此外，通过利用Chrome的调试工具，在豆瓣电影-分类 这个页面我发现了他们使用的一个JQuery接口,也是一个GET请求，不需要AUTH。
详细接口如下,可以通过更改start来迭代获取所有电影条目
https://movie.douban.com/j/new_search_subjects?sort =T&range=0,10&tags=&start=20
这个接口可以获取所有豆瓣上收录的电影，经过我的测试，start改为10000时，返回的数据就已经是空的了
影评信息获取
获取电影信息的方法有了，接下来就是要分析如何获取影评信息了。楚门的世界 ，我们找到了如下这几个详情页面,分别显示了针对这部电影的影评和短评信息
https://movie.douban.com/subject/1292064/reviews
https://movie.douban.com/subject/1292064/comments
照例先用调试工具看看有没有可以用的api接口后，发现这次并没有那么好运了，这个影评页面是由服务器渲染完成的。
没有了接口，我们来分析页面，依然通过调试工具:
评论列表: "//div[contains(@class,'review-list')]//div[contains(@class,'review-item')]"
评论ID: ".//div[@class='main-bd']//div[@class='review-short']/@data-rid"
作者头像: "./header[@class='main-hd']//a[@class='avator']//img/@src "
作者昵称: ".//header//a[@class='name']/text()"
推荐程度(评分): ".//header//span[contains(@class,'main-title-rating')]/@title"
影评标题: ".//div[@class='main-bd']//h2//a/text()"
影评摘要: ".//div[@class='main-bd']//div[@class='short-content']/text()"
影评详情页链接: ".//div[@class='main-bd']//h2//a/@href"
其中具体的评分我们不能直接拿到，而是只能拿到具体的文字描述,经过我的验证，具体如下对应关系如下:
'力荐' : 5 ,
'推荐' : 4 ,
'还行' : 3 ,
'较差' : 2 ,
'很差' : 1 ,
在后续的代码编写过程中，我们会根据这个对应关系将其转换为对应的评分信息
既然已经分析的差不多了，我们所需要的信息基本都有途径可以获得，那么接下来我们就开始具体的爬虫实现，我们采用Scrapy这个Python爬虫框架来帮我们简化爬虫的开发过程。Scrapy的安装以及VirtualEnv环境的搭建就不详细说了，其并不再本文的讨论范围之内，附上Scrapy的中文文档地址
创建项目工程
# 创建好的工程目录大致如下:
spiders: 爬虫文件夹,存放具体的爬虫代码，我们待会要编写的两个爬虫(电影信息和影评信息)就需要放在这个文件夹下
items.py: 模型类，所有需要结构化的数据都要预先在此文件中定义
middlewares.py: 中间件类，scrapy的核心之一，我们会用到其中的downloadMiddleware,
pipelines.py: 管道类，数据的输出管理，是存数据库还是存文件在这里决定
settings.py: 设置类，一些全局的爬虫设置，如果每个爬虫需要有自定义的地方，可以在爬虫中直接设置custom_settings属性
电影信息爬虫
由于电影信息的获取有API接口可以使用，所以此处页可以不采用爬虫来处理数据。
在spiders中新建一个movies.py的文件，定义我们的爬虫
由于我们爬取电影是通过api接口的形式获取，因此并不需要跟进解析，所以我们的爬虫直接继承Spider就可以了
class MovieSpider (Spider):
name = 'movie'
allow_dominas = ["douban.com" ]
custom_settings = {
"ITEM_PIPELINES" : {
'Douban.pipelines.MoviePipeline' : 300
"DEFAULT_REQUEST_HEADERS" : {
'accept' : 'application/json, text/javascript, */*; q=0.01' ,
'accept-encoding' : 'gzip, deflate' ,
'accept-language' : 'zh-CN,zh;q=0.8,en;q=0.6,zh-TW;q=0.4' ,
'referer' : 'https://mm.taobao.com/search_tstar_model.htm?spm=719.1001036.1998606017.2.KDdsmP' ,
'user-agent' : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.97 Safari/537.36' ,
'x-requested-with' : 'XMLHttpRequest' ,
"ROBOTSTXT_OBEY" :False
custom_setting中，ITEM_PIPELINES指定了获取数据后数据输出时使用的管道接口DEFAULT_REQUEST_HEADERS则是让我们的Spider伪装成一个浏览器，防止被豆瓣拦截掉。ROBOTSTXT_OBEY则是让我们的爬虫忽略ROBOTS.txt的警告
接下来通过start_request告诉爬虫要爬取的链接：
def start_requests(self):
url = '''https://movie.douban.com/j/new_search_subjects?sort=T&range=0,10&tags=&start={start}'''
requests = []
for i in range(500):
request = Request(url.format(start=i*20 ), callback=self.parse_movie)
requests.append(request)
return requests
由于我们之前分析网站的时候已经分析过了，start参数到10000时就获取不到数据了，所以此处直接用这个数字循环获得所有链接
接下来解析每个接口返回的内容:
def parse_movie (self, response):
jsonBody = json .loads (response.body)
subjects = jsonBody ['data' ]
movieItems = []
for subject in subjects :
item = MovieItem ()
item ['id' ] = int (subject['id' ])
item ['title' ] = subject ['title' ]
item ['rating' ] = float (subject['rate' ])
item ['alt' ] = subject ['url' ]
item ['image' ] = subject ['cover' ]
movieItems .append (item)
return movieItems
在request中，我们指定了一个parse_movie的方法来解析返回的内容，此处我们需要使用一个在items.py中定义的Item,具体Item如下:
定义Item
class MovieItem(scrapy.Item):
id = scrapy.Field()
title = scrapy.Field()
rating = scrapy.Field()
genres = scrapy.Field()
original_title = scrapy.Field()
alt = scrapy.Field()
image = scrapy.Field()
year = scrapy.Field()
items返回给Scrapy之后，Scrapy会调用我们之前在custom_setting中指定的Douban.pipelines.MoviePipeline来处理获取到的item，MoviePipeline定义在pipelines.py中，具体内容如下:
定义Pipeline
class MoviePipeline(object):
movieInsert = '''insert into movies(id,title,rating,genres,original_title,alt,image,year) values ('{id}','{title}','{rating}','{genres}','{original_title}','{alt}','{image}','{year}')'''
def process_item(self, item, spider):
id = item['id' ]
sql = 'select * from movies where id=%s' % id
self.cursor.execute(sql)
results = self.cursor.fetchall()
if len(results) > 0:
rating = item['rating' ]
sql = 'update movies set rating=%f' % rating
self.cursor.execute(sql)
else:
sqlinsert = self.movieInsert.format(
id =item['id' ],
title =pymysql.escape_string(item['title' ]),
rating =item['rating' ],
genres =item.get('genres' ),
original_title =item.get('original_title' ),
alt =pymysql.escape_string(item.get('alt' )),
image =pymysql.escape_string(item.get('image' )),
year =item.get('year' )
self.cursor.execute(sqlinsert)
return item
def open_spider(self, spider):
self.connect = pymysql.connect('localhost' ,'root' ,'******' ,'douban' , charset='utf8' , use_unicode=True )
self.cursor = self.connect.cursor()
self.connect.autocommit(True)
def close_spider(self, spider):
self.cursor.close()
self.connect.close()
在此Pipeline中，我们通过连接mysql数据库将每次获取到的item插入到具体的数据表中
在命令行下输入:
scrapy crawl movie
影评爬虫的难度要大很多了，因为获取电影信息我们是通过接口直接拿到的，这种接口返回的数据格式统一，基本不会出现异常情况，而且电影数量有限，很短时间就能爬取完毕，并不会触发豆瓣的防爬虫机制，而在影评爬虫的编写过程中，这些都会遇到。
class ReviewSpider (Spider) :
name ="review"
allow_domain = ['douban.com' ]
custom_settings = {
"ITEM_PIPELINES" : {
'Douban.pipelines.ReviewPipeline' : 300
"DEFAULT_REQUEST_HEADERS" : {
'connection' :'keep-alive' ,
'Upgrade-Insecure-Requests' :'1' ,
'DNT' :1 ,
'Accept' :'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8' ,
'Accept-Encoding' :'gzip, deflate, br' ,
'Accept-Language' :'zh-CN,zh;q=0.9,en;q=0.8,zh-TW;q=0.7' ,
'Cookie' :'bid=wpnjOBND4DA; ll="118159"; __utmc=30149280;' , 'user-agent' : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_5) AppleWebKit/537.36 (KHTML, like Gecko) '
'Chrome/67.0.3396.87 Safari/537.36' ,
"ROBOTSTXT_OBEY" : False,
# "DOWNLOAD_DELAY" : 1 ,
"RETRY_TIMES" : 9 ,
"DOWNLOAD_TIMEOUT" : 10
对比获取电影信息的爬虫，在custom_setting中多了几个设置：RETRY_TIMES：用来控制最大重试次数，因为豆瓣有反爬虫机制，当一个IP访问次数过多时就会限制这个IP访问，所以为了绕过这个机制，我们通过代理IP来爬取对应的页面，每爬取一个页面就更换一次IP，但是由于代理IP的质量参差不齐，收费的可能会好点，但还是会存在，为了避免出现因为代理连接不上导致某个页面被忽略掉，我们设置这个值，当重试次数大于设定的值时仍然没有获取到页面就会pass掉这个连接。如果你的代理IP质量不好，请增大此处的次数。DOWNLOAD_TIMEOUT: 下载超时时间，默认是60秒，此处修改为10秒是想让整体的爬取速度加快，因为RETRY_TIMES的缘故，需要RETRY的判定时间为1分钟，如果有很多这种有问题的页面，那么整个爬取的过程会十分漫长。DOWNLOAD_DELAY: 下载延迟，如果你使用代理IP之后还是会出现访问返回403的情况，请设置此值，因为某IP太频繁的访问页面会触发豆瓣的防爬虫机制。
def start_requests(self):
self.connect = pymysql.connect('localhost' ,'root' ,'******' ,'douban' , charset='utf8' , use_unicode=True )
self.cursor = self.connect.cursor()
self.connect.autocommit(True)
sql = "select id,current_page,total_page from movies"
self.cursor.execute(sql)
results = self.cursor.fetchall()
url_format = '''https://movie.douban.com/subject/{movieId}/reviews?start={offset}'''
for row in results:
movieId = row[0 ]
current_page = row[1 ]
total_page = row[2 ]
if current_page != total_page:
url = url_format.format(movieId=movieId, off set=current_page*20 )
request = Request(url, callback=self.parse_review, meta={'movieId' : movieId}, dont_filter=True )
yield request
照例，我们在start_request中告诉Scrapy要爬取的起始网址链接，通过我们之前的分析，影评页面的地址格式为:
https://movie.douban.com/subject/{movieId}/reviews?start ={off set}
而movieId,我们之前的爬虫已经将所有电影的信息抓取了下来，所以我们在此先通过查询数据库将所有的已抓取的电影信息获取到，取到其中的movieId，然后构造一个页面链接。
url = url_format.format(movieId=movieId, off set=current_page*20 )
因为抓取豆瓣影评的过程十分漫长，中间会出现各种各样的问题导致爬虫意外退出，因此我们需要一个机制让爬虫能从上次停止的地方继续爬取，current_page和total_page就是为此而服务的，在后面的数据解析过程中，每解析一个页面，就会将当期页面的页数存储下来，防止出现意外情况。
def parse_review(self, response):
movieId = response.request.meta['movieId' ]
review_list = response.xpath("//div[contains(@class,'review-list')]//div[contains(@class,'review-item')]" )
for review in review_list:
item = ReviewItem()
item['id'] = review.xpath(".//div[@class='main-bd'] //div[@class='review-short'] /@data-rid").extract()[0]
avator = review.xpath(".//header//a[@class='avator']/@href" ).extract()[0 ]
item['username'] = avator.split('/')[-2]
item['avatar'] = review.xpath("./header[@class='main-hd'] //a[@class='avator'] //img/@src").extract()[0]
item['nickname'] = review.xpath(".//header//a[@class='name'] /text()").extract()[0]
item['movieId'] = movieId
rate = review.xpath(".//header//span[contains(@class,'main-title-rating')]/@title" ).extract()
if len(rate)>0:
rate = rate[0 ]
item['rating'] = RATING_DICT.get(rate)
item['create_time'] = review.xpath(".//header//span[@class='main-meta'] /text()").extract()[0]
item['title'] = review.xpath(".//div[@class='main-bd'] //h2//a/text()").extract()[0]
item['alt'] = review.xpath(".//div[@class='main-bd'] //h2//a/@href").extract()[0]
summary = review.xpath(".//div[@class='main-bd']//div[@class='short-content']/text()" ).extract()[0 ]
item['summary'] = summary.strip().replace('\n', '').replace('\xa0(','')
yield item
current_page = response.xpath("//span[@class='thispage']/text()" ).extract()
total_page = response.xpath("//span[@class='thispage']/@data-total-page" ).extract()
paginator = response.xpath("//div[@class='paginator']" ).extract()
if len(paginator) == 0 and len(review_list):
sql = "update movies set current_page = 1, total_page=1 where id='%s'" % movieId
self.cursor.execute(sql)
elif len(paginator) and len(review_list):
current_page = int(current_page[0 ])
total_page = int(total_page[0 ])
sql = "update movies set current_page = %d, total_page=%d where id='%s'" % (current_page, total_page, movieId)
self.cursor.execute(sql)
if current_page != total_page:
url_format = '''https://movie.douban.com/subject/{movieId}/reviews?start={offset}'''
next_request = Request(url_format.format(movieId=movieId, off set=current_page*20 ),
callback =self.parse_review,
dont_filter =True , meta={'movieId' : movieId})
yield next_request
else:
yield response.request
接下来，分析解析函数，DoubanItem的数据获取就不额外介绍了，利用之前分析时用到的xpath语句可以很容易的定义到具体内容。
current_page = response.xpath("//span[@class='thispage']/text()" ).extract()
total_page = response.xpath("//span[@class='thispage']/@data-total-page" ).extract()
paginator = response.xpath("//div[@class='paginator']" ).extract()
上面基础代码的作用主要是为了获取影评页面的底部导航条
但是这个导航条会有两种情况获取不到:
1. 当某个电影的评论不足20条时，也就是只有一页评论。
2. 当触发了豆瓣的反爬虫的机制时，返回的页面并不是评论页面，而是一个验证页面，自然也找不到导航条
所以在下面的代码中，我通过这几个变量来判断了以上几种情况：
1. 情况1 时，不需要继续爬取剩下的评论，直接将current_page和total_page设置为1 保存到movie表即可
2. 情况2 时，由于此时触发了反爬虫机制，返回的页面没有我们的数据，如果我们直接忽略掉的话，会损失大量的数据（这种情况很常见），所以我们就干脆再试一次，返回request ，让Scrapy重新爬取这个页面，因为每次重新爬取都会换一个新的代理IP，所以我们有很大概率下次抓取就是正常的。此处有一点需要注意：因为Scrapy默认会过滤掉重复请求，所以我们需要在构造Request 的时候讲dont_filter参数设置为True ,让其不要过滤重复链接。
3. 正常情况时，通过xpath语法获取的下一页评论的链接地址然后构造一个request 交给Scrapy继续爬取
影评下载中间件
上面说过，抓取影评页面时需要通过使用代理IP的方式来达到绕过豆瓣的反爬虫机制，具体代理的设置就需要在DownloadMiddleware中设置
class DoubanDownloaderMiddleware (object ):
ip_list = None
@classmethod
def from_crawler (cls, crawler ):
s = cls()
crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)
return s
def process_request (self, request, spider ):
if self.ip_list is None or len (self.ip_list) == 0 :
response = requests.request('get' ,'http://api3.xiguadaili.com/ip/?tid=555688914990728&num=10&protocol=https' ).text
self.ip_list = response.split('\r\n' )
ip = random.choice(self.ip_list)
request.meta['proxy' ] = "https://" +ip
print ("当前proxy:%s" % ip)
self.ip_list.remove(ip)
return None
def process_response (self, request, response, spider ):
if response.status == 403 :
res = parse.urlparse(request.url)
res = parse.parse_qs(res.query)
url = res.get('r' )
if url and len (url) > 0 :
request = request.replace(url=res['r' ][0 ])
return request
return response
其中主要就要实现两个函数，process_request和process_response，前者是每次爬取页面前Scrapy会调用这个函数，后者则是每次爬取完页面之后调用。
影评Item
class ReviewItem(scrapy.Item):
id = scrapy.Field()
username = scrapy.Field()
nickname = scrapy.Field()
avatar = scrapy.Field()
movieId = scrapy.Field()
rating = scrapy.Field()
create_time = scrapy.Field()
title = scrapy.Field()
summary = scrapy.Field()
alt = scrapy.Field()
没啥好说的，想存啥就写啥
影评Pipeline
class ReviewPipeline(object):
reviewInsert = '''insert into reviews(id,username,nickname,avatar,summary,title,movieId,rating,create_time,alt) values ("{id}","{username}", "{nickname}","{avatar}", "{summary}","{title}","{movieId}","{rating}","{create_time}","{alt}")'''
def process_item(self, item, spider):
sql_insert = self.reviewInsert.format(
id =item['id' ],
username =pymysql.escape_string(item['username' ]),
nickname =pymysql.escape_string(item['nickname' ]),
avatar =pymysql.escape_string(item['avatar' ]),
summary =pymysql.escape_string(item['summary' ]),
title =pymysql.escape_string(item['title' ]),
rating =item['rating' ],
movieId =item['movieId' ],
create_time =pymysql.escape_string(item['create_time' ]),
alt =pymysql.escape_string(item['alt' ])
print("SQL:", sql_insert)
self.cursor.execute(sql_insert)
return item
def open_spider(self, spider):
self.connect = pymysql.connect('localhost' ,'root' ,'******' ,'douban' , charset='utf8' , use_unicode=True )
self.cursor = self.connect.cursor()
self.connect.autocommit(True)
def close_spider(self, spider):
self.cursor.close()
self.connect.close()
和之前的电影的pipeline类似，就是基本的数据库写操作。
scrapy crawl review
在我写完这篇文章时，影评的爬虫仍然还在爬取当中：
如果你觉得我的文章对你有帮助，请赞助一杯☕️
72
用户5790832290966
Python
105
techlead_krischang
Python
623
CeshirenTester
Python
