通过scrapy，从模拟登录开始爬取知乎的问答数据

---

这篇文章将讲解如何爬取知乎上面的问答数据。

首先，我们需要知道，想要爬取知乎上面的数据，第一步肯定是登录，所以我们先介绍一下模拟登录：

先说一下我的思路：

1.首先我们需要控制登录的入口，重写start_requests方法。来控制到这个入口之后，使用callback回调函数来调用login函数.

2.在login函数中通过response.text获取到该页面的HTML代码，通过正则表达式提取到登录必需的xsrf值。

3.下面就是获取验证码了，这是一个难点，首先我们先观察在请求验证码时的url：

可以发现，在请求验证码时出现了一个r后面的随机数，所以我们需要生成一个随机数，并将该随机数作为参数传给请求验证码时的url；然后将该url交给scrapy下载器进行下载。

4.然后通过回调函数调用login_after_captcha ，在该函数中我们需要在请求验证码的url下载到验证码图片，让用户输入验证码并赋值给变量captcha。然后将xsrf、用户名、密码、验证码等参数存入postdata。我们就可以进行模拟登录了。

5.通过调用scrapy的FormRequest来进行模拟登录

6.模拟登录之后，调用check_login函数判断是否登录成功。

下面是模拟登录部分的源码：

def start_requests(self):  #控制登录入口，实现知乎的登录
     return [scrapy.Request('https://www.zhihu.com/#signin',headers=self.header,callback=self.login)]

def login(self,response):
    response_text=response.text
    xsrf_obj = re.match('.*name="_xsrf" value="(.*)".*', response_text,re.DOTALL)
    xsrf=""
    if xsrf_obj:
        xsrf=xsrf_obj.group(1)
    else:
        return ""

    if xsrf:
        post_data = {  # 传递的数据
            "_xsrf": xsrf,
            "phone_num": "你的账号",
            "password": "你的密码",
            "captcha":""
        }

        import time
        t = str(int(time.time() * 1000))
        captcha_url = "https://www.zhihu.com/captcha.gif?r={0}&type=login & lang=cn".format(t)

        yield scrapy.Request(captcha_url, headers=self.header, meta={"post_data": post_data},
                             callback=self.login_after_captcha)

def login_after_captcha(self, response):
    with open("captcha.jpg", "wb") as f:    #下载验证码图片
        f.write(response.body)  #这里必须为body
        f.close()

    from PIL import Image
    try:
        im = Image.open('captcha.jpg')
        im.show()
        im.close()
    except:
        pass

    captcha = input("输入验证码\n>")

    post_data = response.meta.get("post_data", {})
    post_url = "https://www.zhihu.com/login/phone_num"
    post_data["captcha"] = captcha      #将验证码的值传给post_data

    return [scrapy.FormRequest(
        url=post_url,
        formdata=post_data,
        headers=self.header,
        callback=self.check_login   #调用scrapy的FormRequest完成表单提交，，即模拟登录，登录之后调用check_login判断登录状态
    )]

def check_login(self, response):
    # 验证服务器的返回数据判断是否成功
    text_json = json.loads(response.text)  #response.text存放了登录成功或其他提示信息 的Unicode编码,
    # 我们将其加载为json格式。json格式中的msg(message字段存放了中文字符的登录提示信息)
    if "msg" in text_json and text_json["msg"] == "登录成功":
        for url in self.start_urls:
            yield scrapy.Request(url, dont_filter=True, headers=self.header)
            #在执行完check_login方法之后，因为我们在最后没有加callback函数，所以默认会调用parse方法

需要注意的是，每次在请求一个页面时都需要带上headers。因为headers中有一个重要的参数 User-Agent，我们需要指明User-Agent。如果不加上headers的话，那么在运行时会出现500的服务器错误，这是因为默认的User-Agent是你运行的python2或python3的User-Agent，服务器并不认识。所以，在爬取知乎的时候，在请求一个页面时必须加上headers

在完成了登录之后，下面就开始我们的爬取逻辑：

爬取知乎的question需要的字段，设计数据表：

爬取知乎的question需要的字段，设计数据表：

爬取的大致思路：

1.首先我们在parse方法中获取到登录之后的首页的所有url，然后过滤掉不是url的条目，然后再提取感兴趣的url。在这里可以进行一个判断，如果是我们感兴趣的url则执行回调函数parse_question，若不是感兴趣的url，那么就利用scrapy的深度优先遍历的特点进一步判断，如此重复。

2.在parse_question方法中则是对url页面中的数据解析。然后通过yield来调用回调函数解析该question对应的answer,并通过yield question_item传递给pipelines。

3.在pipelines中可以使用爬取到数据，比如存为json格式，存入数据库等等。

4.更多的解释会在源码中注解。

我们先看一下爬取的结果：

question表：

answer表：

下面是整个项目的源码：

目录结构：

zhihu.py

import scrapy
import re
import json
from scrapy.loader import ItemLoader
from ArticleSpider.items import ZhihuQuestionItem,ArticleItemLoader,ZhihuAnswerItem
import datetime

try:
import urlparse as parse
except:
from urllib import parse

class ZhihuSpider(scrapy.Spider):
name = 'zhihu'
allowed_domains = ['www.zhihu.com']
start_urls = ['http://www.zhihu.com/']

#question的第一页answer请求url
start_answer_url="https://www.zhihu.com/api/v4/questions/{0}/answers?include=data[*].is_normal,admin_closed_comment,reward_info,is_collapsed,annotation_action,annotation_detail,collapse_reason,is_sticky,collapsed_by,suggest_edit,comment_count,can_comment,content,editable_content,voteup_count,reshipment_settings,comment_permission,created_time,updated_time,review_info,relevant_info,question,excerpt,relationship.is_authorized,is_author,voting,is_thanked,is_nothelp,upvoted_followees;data[*].mark_infos[*].url;data[*].author.follower_count,badge[?(type=best_answerer)].topics&offset={1}limit={2}&sort_by=default"

header = {
    "Host": "www.zhihu.com",
    "Referer": "https://www.zhihu.com",
    'User-Agent': "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:57.0) Gecko/20100101 Firefox/57.0"
}

def parse(self, response):  #该函数的response.text是传过来的登录成功之后的html代码
    #提取出HTML页面中的所有url，并跟踪这些url进行进一步爬取（深度优先算法）
    #如果提取的url中格式为/question/xxx 就下载之后直接进入解析函数

    all_urls=response.css("a::attr(href)").extract()   #提取所有的url
    all_urls=[parse.urljoin(response.url,url) for url in all_urls]  #拼接特殊的URL
    all_urls=filter(lambda x:True if x.startswith("https") else False,all_urls) #使用匿名函数过滤掉不是url的条目
    for url in all_urls:
        match_obj=re.match("(.*zhihu.com/question/(\d+))($|/).*",url)  #提取感兴趣URL（question/id）
        if match_obj:   #如果提取到question相关的页面
            request_url=match_obj.group(1)   #提取url
            question_id=match_obj.group(2)    #提取question id
            yield scrapy.Request(request_url,headers=self.header,meta={"question_id":question_id},callback=self.parse_question)

        else:   #如果不是question相关的url，则进行深度优先算法的提取
            yield scrapy.Request(url,headers=self.header,callback=self.parse)
            pass

def parse_question(self,response):
    #获取到question的URL之后 ，调用该方法进行处理
    if "QuestionHeader-title" in response.text:  #处理新版本
        click_num=response.css(".NumberBoard-value::text").extract()[1]
        question_id = response.meta.get("question_id", "")  #获取question_id字典。
        item_loader = ItemLoader(item=ZhihuQuestionItem(), response=response)
        item_loader.add_css("title",".QuestionHeader-title::text") #标题
        item_loader.add_css("content",".QuestionHeader-detail")
        item_loader.add_value("url",response.url) #该页面的url
        item_loader.add_value("zhihu_id",question_id)
        item_loader.add_css("answer_num",".List-headerText span::text")#extract之后['10',' 个回答']  回答数
        item_loader.add_css("comments_num",".QuestionHeader-Comment button::text") #extract之后['1 条评论']
        item_loader.add_css("watch_user_num",".NumberBoard-value::text")#这里会提取关注数和被浏览数两个
        item_loader.add_value("click_num",click_num) #这里会提取关注数和被浏览数两个
        item_loader.add_css("topics",".QuestionHeader-topics .Popover div::text") #话题

        question_item=item_loader.load_item()

    else:
        #处理老版本页面的item提取
        question_id = response.meta.get("question_id", "")

        item_loader = ItemLoader(item=ZhihuQuestionItem(), response=response)
        item_loader.add_css("title", "#zh-question-title h2 a::text")
        item_loader.add_css("content", "#zh-question-detail")
        item_loader.add_value("url", response.url)
        item_loader.add_value("zhihu_id", question_id)
        item_loader.add_css("answer_num", "#zh-question-answer-num::text")
        item_loader.add_css("comments_num", "#zh-question-meta-wrap a[name='addcomment']::text")
        item_loader.add_css("topics", ".zm-tag-editor-labels a::text")

        question_item = item_loader.load_item()

    yield scrapy.Request(self.start_answer_url.format(question_id,0,20),headers=self.header,callback=self.parse_answer)
    yield question_item

def parse_answer(self,response):
    #由于返回的是json文件
    answer_json=json.loads(response.text)
    is_end=answer_json["paging"]["is_end"] #布尔类型
    next_url=answer_json["paging"]["next"]

    for answer in answer_json["data"]:
        answer_item=ZhihuAnswerItem()
        answer_item["zhihu_id"]=answer["id"]
        answer_item["url"]=answer["url"]
        answer_item["question_id"]=answer["question"]["id"]
        answer_item["author_id"]=answer["author"]["id"] if "id" in answer["author"] else None
        answer_item["content"]=answer["content"] if "content" in answer else None
        answer_item["praise_num"]=answer["voteup_count"]
        answer_item["comments_num"]=answer["comment_count"]
        answer_item["create_time"]=answer["created_time"]  #该网页返回给我们的int类型
        answer_item["update_time"]=answer["updated_time"]# 该网页返回给我们的int类型
        answer_item["crawl_time"]=datetime.datetime.now()  #  2017-12-22 22:30:47.061460

        yield answer_item

    if not is_end:  #如果不是最后一个回答url
        yield scrapy.Request(next_url,headers=self.header,callback=self.parse_answer)

def start_requests(self):  #控制登录入口，实现知乎的登录
     return [scrapy.Request('https://www.zhihu.com/#signin',headers=self.header,callback=self.login)]
    #在重写start_requests方法之后，scrapy首先会执行该方法，请求的页面是登录界面，请求头为上面我们定义的，然后因为
   #scrapy是异步处理的缘故，所以在执行完该方法之后，我们需要加一个callback回调函数，来调用登录方法，如果不加上callback
   #指明回调函数，那么scrapy默认会直接调用parse方法。

def login(self,response):
    response_text=response.text
    xsrf_obj = re.match('.*name="_xsrf" value="(.*)".*', response_text,re.DOTALL)
    xsrf=""
    if xsrf_obj:
        xsrf=xsrf_obj.group(1)
    else:
        return ""

    if xsrf:
        post_data = {  # 传递的数据
            "_xsrf": xsrf,
            "phone_num": "你的用户名",
            "password": "你的密码",
            "captcha":""
        }

        import time
        t = str(int(time.time() * 1000))
        captcha_url = "https://www.zhihu.com/captcha.gif?r={0}&type=login & lang=cn".format(t)

        yield scrapy.Request(captcha_url, headers=self.header, meta={"post_data": post_data},
                             callback=self.login_after_captcha)   #meta表示字典，里面存放了post_data。这里保证了是同一个session中的cookie

def login_after_captcha(self, response):
    with open("captcha.jpg", "wb") as f:    #下载验证码图片
        f.write(response.body)  #这里必须为body
        f.close()

    from PIL import Image
    try:
        im = Image.open('captcha.jpg')
        im.show()
        im.close()
    except:
        pass

    captcha = input("输入验证码\n>")

    post_data = response.meta.get("post_data", {})
    post_url = "https://www.zhihu.com/login/phone_num"
    post_data["captcha"] = captcha      #将验证码的值传给post_data

    return [scrapy.FormRequest(
        url=post_url,
        formdata=post_data,
        headers=self.header,
        callback=self.check_login   #调用scrapy的FormRequest完成表单提交，，即模拟登录，登录之后调用check_login判断登录状态
    )]

def check_login(self, response):
    # 验证服务器的返回数据判断是否成功
    text_json = json.loads(response.text)  #response.text存放了登录成功或其他提示信息 的Unicode编码,
    # 我们将其加载为json格式。json格式中的msg(message字段存放了中文字符的登录提示信息)
    if "msg" in text_json and text_json["msg"] == "登录成功":
        for url in self.start_urls:
            yield scrapy.Request(url, dont_filter=True, headers=self.header)
            #在执行完check_login方法之后，因为我们在最后没有加callback函数，所以默认会调用parse方法

common.py

import hashlib
import re

def get_purenum(text):
str_re = ".*?(\d+).*"  # 提取整数部分并返回int类型
text = re.match(str_re, text)
if text:
    return int(text.group(1))
else:
    return 0

items.py

import scrapy
from scrapy.loader.processors import MapCompose,TakeFirst,Join
from scrapy.loader import ItemLoader
import re
from ArticleSpider.util.common import get_purenum
import datetime
from ArticleSpider.settings import SQL_DATETIME_FORMAT,SQL_DATE_FORMAT

class ZhihuQuestionItem(scrapy.Item):
#入库前处理
#知乎question实体类
zhihu_id=scrapy.Field(

)
topics=scrapy.Field(

)
url=scrapy.Field()
title=scrapy.Field()
content=scrapy.Field()
create_time=scrapy.Field()
update_time=scrapy.Field()
answer_num=scrapy.Field()
comments_num=scrapy.Field()
watch_user_num=scrapy.Field()
click_num=scrapy.Field()
crawl_time=scrapy.Field()  #爬虫爬取的时间

def get_insertsql(self):
    insert_sql = "insert into zhihu_question(zhihu_id,topics,url,title,content," \
                 "answer_num,comments_num,watch_user_num,click_num,crawl_time) VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) ON DUPLICATE KEY UPDATE topics=VALUES(topics),content=VALUES(content),answer_num=values(answer_num), " \
                 "comments_num=values(comments_num),watch_user_num=values(watch_user_num),click_num=values(click_num)"

    zhihu_id = int("".join(self["zhihu_id"]))
    topics = ",".join(self["topics"])
    url = self["url"][0]
    title = "".join(self["title"])   # ItemLoader是list类型，在这里进行处理转为str类型或者int类型
    content = "".join(self["content"])
    answer_num = get_purenum("".join(self["answer_num"]))
    comments_num = get_purenum(self["comments_num"][0])
    watch_user_num = int(self["watch_user_num"][0])
    click_num = int(self["click_num"][0])
    crawl_time = datetime.datetime.now().strftime(SQL_DATETIME_FORMAT) #将时间格式化为我们在setting中指定的格式
    params = (zhihu_id, topics, url, title, content, answer_num, comments_num,
             watch_user_num, click_num, crawl_time)
    return insert_sql,params

class ZhihuAnswerItem(scrapy.Item):
#知乎回答item
zhihu_id=scrapy.Field()
url=scrapy.Field()
question_id=scrapy.Field()
author_id=scrapy.Field()
content=scrapy.Field()
praise_num=scrapy.Field()
comments_num=scrapy.Field()
create_time=scrapy.Field()
update_time=scrapy.Field()
crawl_time=scrapy.Field()

def get_insertsql(self):
    insert_sql = "insert into zhihu_answer(zhihu_id,url,question_id,author_id,content," \
                 "praise_num,comments_num,create_time,update_time,crawl_time) VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) ON DUPLICATE KEY UPDATE " \
                 "content=VALUES(content),praise_num=VALUES(praise_num),comments_num=VALUES(comments_num),update_time=VALUES(update_time)"

    # 调用datetime fromtimestamp方法将int 转为datetime类型(年月日时分秒都有)，然后再格式化为指定格式
    create_time = datetime.datetime.fromtimestamp(self["create_time"]).strftime(SQL_DATETIME_FORMAT)
    update_time = datetime.datetime.fromtimestamp(self["update_time"]).strftime(SQL_DATETIME_FORMAT)

    params=(self["zhihu_id"],self["url"],self["question_id"],self["author_id"],self["content"]
            ,self["praise_num"],self["comments_num"],create_time,update_time,self["crawl_time"].strftime(SQL_DATETIME_FORMAT))

 return insert_sql,params

pipelines.py

from scrapy.pipelines.images import ImagesPipeline
from scrapy.exporters import JsonItemExporter
import MySQLdb
from twisted.enterprise import adbapi
import MySQLdb.cursors

class ArticlespiderPipeline(object):
def process_item(self, item, spider):          #item中的values存放了tiems的所有属性
    return item

class JsonExporterPipeline(object):
#调用scrapy提供的JsonExporter导出json文件
def __init__(self):
    self.file=open('articleexport.json','wb')#打开文件.wb表示以二进制的方式
    self.exporter=JsonItemExporter(self.file,encoding="utf-8",ensure_ascii=False) #传递参数
    self.exporter.start_exporting()  #开始导出
def close_spider(self,spider):
    self.exporter.finish_exporting()   #停止导出
    self.file.close()                  #关闭文件
def process_item(self, item, spider):
    self.exporter.export_item(item)
    return item

class MysqlTwistedPipeline(object):
#若每一个网站写一个Pipeline,那么需要大数量的mysql的连接，显然是不合理的，所以
#在实际开发中，往往是插入不同的数据库使用不同的pipeline

# 通过Twisted框架提供的异步容器，将数据通过异步的方式存储到mysql中
def __init__(self,dbpool):
    self.dbpool=dbpool

@classmethod
def from_settings(cls,settings):
    dbparams=dict(
    host=settings["MYSQL_HOST"],
    db=settings["MYSQL_DBNAME"],
    user=settings["MYSQL_USER"],
    passwd=settings["MYSQL_PASSWORD"],
    charset="utf8",
    cursorclass=MySQLdb.cursors.DictCursor,
    use_unicode=True
    )
    dbpool=adbapi.ConnectionPool("MySQLdb",**dbparams)  #连接池
    return cls(dbpool)  #返回MysqlTwistedPipeline类的一个实例化对象

def process_item(self, item, spider):
    query=self.dbpool.runInteraction(self.do_insert,item) #异步的插入操作
    query.addErrback(self.handle_error,item,spider)  #处理异步插入的异常

def handle_error(self,failure,item,spider):
    print(failure)          #发生异常时直接输出异常信息

def do_insert(self,cursor,item):
    insert_sql,params=item.get_insertsql() #调用对应的item的get_insertsql方法，获取到不同的sql语句，和params元组
    cursor.execute(insert_sql,params)

setting.py

ITEM_PIPELINES = {
    'ArticleSpider.pipelines.ArticlespiderPipeline': 300,
    'ArticleSpider.pipelines.JsonExporterPipeline': 2 , #保存为Json文件
     # 'ArticleSpider.pipelines.MysqlPipeline': 3   #将数据同步存储到数据库
     'ArticleSpider.pipelines.MysqlTwistedPipeline':3 #将数据异步插入到数据库
}
MYSQL_HOST="localhost"
MYSQL_DBNAME="article_spider"
MYSQL_USER="root"
MYSQL_PASSWORD="751324"

SQL_DATETIME_FORMAT="%Y-%m-%d %H:%M:%S" #详细时间类型
SQL_DATE_FORMAT="%Y-%m-%d"   #日期类型

至此，通过scrapy从模拟登录到爬取问答数据的项目就完成了，模拟登录是在爬虫中非常重要的知识，在模拟登录成功之后，包括解析数据，将item 传入pipelines，数据表的创建，pipelines和items的配置，入库等也就变得很简单了；在这个项目中，在解析answer的数据时，我们采用的是json格式直接提取的，因为url直接给我们返回了json格式的文件，这样也就简化了我们解析数据的操作。