2019 年 01 月 04 日 16:32:17 更新了新的 Chrome 镜像 将 Python 版本升级到了 3.7 Note: 推荐使用结尾提供的 Docker 镜像进行二次打包运行代码 各位小伙伴儿的采集日常是不是被 JavaScript 的各种点击事件折腾的欲仙欲死啊？好不容易找到个 Selenium+Chrome 可以解决问题！ 但是另一个 ▄█▀█● 的事实摆在面前，服务器都特么没有 GUI 啊·· 好吧！咱们要知难而上！决不能被这个点小困难打倒······· 然而摆在面前的事实是···· 他丫的各种装不上啊！坑爹啊！ 那么我来拯救你们于水火之间了！ 服务器如下：

1
2
3
4
5
6
7
8
9
10
11

[root@spider01 ~]# hostnamectl
   Static hostname: spider01
         Icon name: computer-vm
           Chassis: vm
        Machine ID: 1c4029c4e7fd42498e25bb75101f85b6
           Boot ID: f5a67454b94b454fae3d75ef1ccab69f
    Virtualization: kvm
  Operating System: CentOS Linux 7 (Core)
       CPE OS Name: cpe:/o:centos:centos:7
            Kernel: Linux 3.10.0-514.6.2.el7.x86_64
      Architecture: x86-64

安装 Chromeium:

1
2
3
4

## 安装yum源
[root@spider01 ~]# sudo yum install -y epel-release
## 安装Chrome
[root@spider01 ~]# yum install -y chromium

去这个地方：https://sites.google.com/a/chromium.org/chromedriver/downloads 下载 ChromeDriver 驱动放在/usr/bin/目录下： 完成结果如下：

1
2
3

[root@spider01 ~]# ll /usr/bin/ | grep chrom
-rwxrwxrwx. 1 root root   7500280 11月 29 17:32 chromedriver
lrwxrwxrwx. 1 root root        47 11月 30 09:35 chromium-browser -> /usr/lib64/chromium-browser/chromium-browser.sh

安装 XVFB：

1
2

[root@spider01 ~]# yum install Xvfb -y
[root@spider01 ~]# yum install xorg-x11-fonts* -y

新建在/usr/bin/ 一个名叫 xvfb-chromium 的文件写入以下内容：

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

[root@spider01 ~]# cat /usr/bin/xvfb-chromium
#!/bin/bash

_kill_procs() {
  kill -TERM $chromium
  wait $chromium
  kill -TERM $xvfb
}

# Setup a trap to catch SIGTERM and relay it to child processes
trap _kill_procs SIGTERM

XVFB_WHD=${XVFB_WHD:-1280x720x16}

# Start Xvfb
Xvfb :99 -ac -screen 0 $XVFB_WHD -nolisten tcp &
xvfb=$!

export DISPLAY=:99

chromium --no-sandbox --disable-gpu$@ &
chromium=$!

wait $chromium
wait $xvfb

更改软连接：

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

## 更改Chrome启动的软连接
[root@spider01 ~]# ln -s /usr/lib64/chromium-browser/chromium-browser.sh /usr/bin/chromium


[root@spider01 ~]# rm -rf /usr/bin/chromium-browser

[root@spider01 ~]# ln -s /usr/bin/xvfb-chromium /usr/bin/chromium-browser

[root@spider01 ~]# ln -s /usr/bin/xvfb-chromium /usr/bin/google-chrome

[root@spider01 ~]# ll /usr/bin/ | grep chrom*
-rwxrwxrwx. 1 root root   7500280 11月 29 17:32 chromedriver
lrwxrwxrwx. 1 root root        47 11月 30 09:47 chromium -> /usr/lib64/chromium-browser/chromium-browser.sh
lrwxrwxrwx. 1 root root        22 11月 30 09:48 chromium-browser -> /usr/bin/xvfb-chromium
-rwxr-xr-x. 1 root root     73848 12月  7 2016 chronyc
lrwxrwxrwx. 1 root root        22 11月 30 09:48 google-chrome -> /usr/bin/xvfb-chromium
-rwxrwxrwx. 1 root root       387 11月 29 18:16 xvfb-chromium

来瞅瞅能不能用哦：

1
2
3
4
5
6
7
8
9
10
11

>>> from selenium import webdriver
>>> options = webdriver.ChromeOptions()
>>> options.add_argument('--headless')
>>> options.add_argument('--no-sandbox')
>>> options.add_argument('--disable-extensions')
>>> options.add_argument('--disable-gpu')
>>> driver = webdriver.Chrome(options=options)
>>> driver.get("http://www.baidu.com")
>>> driver.find_element_by_xpath("./*//input[@id='kw']").send_keys("哎哟卧槽")
>>> driver.find_element_by_xpath("./*//input[@id='su']").click()
>>> driver.page_source

No problem！！！！ 好了部署完了！当然 Docker 这么火贼适合懒人了！来来 看这儿 Docker 版的 妥妥滴！

1

docker pull thsheep/python:3.7-debian-chrome

做好了 Python3.7 和 Chrome 集成 需要自己使用 Dockerfile 来重新打包安装你需要的 Python 包。

Note: 请按照以下方式初始化 Webdriver！！！！！！！！

1
2
3
4
5
6
7
8
9

from selenium import webdriver

options = webdriver.ChromeOptions()
options.add_argument('--headless')
options.add_argument('--no-sandbox')
options.add_argument('--disable-extensions')
options.add_argument('--disable-gpu')

driver = webdriver.Chrome(options=options)

否则会出现无法初始化 Webdriver 的情况

顺便一提！！！！这个玩意儿从事 Web 测试工作的小伙伴可以用！！！！！！！！

下面是 Dockerfile 文件：

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 python:3.7-stretch

ENV DBUS_SESSION_BUS_ADDRESS=/dev/null

#============================================
# Google Chrome
#============================================
RUN wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add - && \
echo "deb http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google-chrome.list && \
apt-get update -qqy && \
apt-get -qqy install google-chrome-stable unzip&& \
rm /etc/apt/sources.list.d/google-chrome.list && \
rm -rf /var/lib/apt/lists/* /var/cache/apt/*

#==================
# Chrome driver
# CHROME_DRIVER_VERSION 需要根据上面安装的Chrome版本来设置（最好设置成最新版本）
# http://chromedriver.chromium.org/downloads 版本号在这页面上查看
#==================
ARG CHROME_DRIVER_VERSION=2.45
RUN wget -O /tmp/chromedriver.zip https://chromedriver.storage.googleapis.com/$CHROME_DRIVER_VERSION/chromedriver_linux64.zip && \
rm -rf /opt/selenium/chromedriver && \
unzip /tmp/chromedriver.zip -d /opt/selenium && \
rm /tmp/chromedriver.zip && \
mv /opt/selenium/chromedriver /opt/selenium/chromedriver-$CHROME_DRIVER_VERSION && \
chmod 755 /opt/selenium/chromedriver-$CHROME_DRIVER_VERSION && \
ln -fs /opt/selenium/chromedriver-$CHROME_DRIVER_VERSION /usr/bin/chromedriver

RUN google-chrome-stable --version

微博登录限制了错误次数···加上 Cookie 大批账号被封需要从 Cookie 池中 剔除被封的账号··· 需要使用代理··· 无赖百度了大半天都是特么的啥玩意儿？？？结果换成了 Google 手到擒来 分分钟解决（那么问题来了？百度除了卖假药还会干啥？） Selenium+Chrome 认证代理不能通过 options 处理。只能换个方法使用扩展解决 原文地址：https://stackoverflow.com/questions/29983106/how-can-i-set-proxy-with-authentication-in-selenium-chrome-web-driver-using-pyth#answer-30953780 （Stack Overflow 这是个好地方啊） 走你！

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

# -*- coding: utf-8 -*-
# @Time    : 2017/11/15 9:50
# @Author  : 哎哟卧槽
# @Site    :
# @File    : pubilc.py
# @Software: PyCharm

import string
import zipfile

def create_proxyauth_extension(proxy_host, proxy_port,
                               proxy_username, proxy_password,
                               scheme='http', plugin_path=None):
    """代理认证插件

    args:
        proxy_host (str): 你的代理地址或者域名（str类型）
        proxy_port (int): 代理端口号（int类型）
        proxy_username (str):用户名（字符串）
        proxy_password (str): 密码 （字符串）
    kwargs:
        scheme (str): 代理方式 默认http
        plugin_path (str): 扩展的绝对路径

    return str -> plugin_path
    """


    if plugin_path is None:
        plugin_path = 'vimm_chrome_proxyauth_plugin.zip'

    manifest_json = """
    {
        "version": "1.0.0",
        "manifest_version": 2,
        "name": "Chrome Proxy",
        "permissions": [
            "proxy",
            "tabs",
            "unlimitedStorage",
            "storage",
            "<all_urls>",
            "webRequest",
            "webRequestBlocking"
        ],
        "background": {
            "scripts": ["background.js"]
        },
        "minimum_chrome_version":"22.0.0"
    }
    """

    background_js = string.Template(
    """
    var config = {
            mode: "fixed_servers",
            rules: {
              singleProxy: {
                scheme: "${scheme}",
                host: "${host}",
                port: parseInt(${port})
              },
              bypassList: ["foobar.com"]
            }
          };

    chrome.proxy.settings.set({value: config, scope: "regular"}, function() {});

    function callbackFn(details) {
        return {
            authCredentials: {
                username: "${username}",
                password: "${password}"
            }
        };
    }

    chrome.webRequest.onAuthRequired.addListener(
                callbackFn,
                {urls: ["<all_urls>"]},
                ['blocking']
    );
    """
    ).substitute(
        host=proxy_host,
        port=proxy_port,
        username=proxy_username,
        password=proxy_password,
        scheme=scheme,
    )
    with zipfile.ZipFile(plugin_path, 'w') as zp:
        zp.writestr("manifest.json", manifest_json)
        zp.writestr("background.js", background_js)

    return plugin_path

使用方法：

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

from selenium import webdriver
from common.pubilc import create_proxyauth_extension

proxyauth_plugin_path = create_proxyauth_extension(
    proxy_host="XXXXX.com",
    proxy_port=9020,
    proxy_username="XXXXXXX",
    proxy_password="XXXXXXX"
)


co = webdriver.ChromeOptions()
# co.add_argument("--start-maximized")
co.add_extension(proxyauth_plugin_path)


driver = webdriver.Chrome(executable_path="C:\chromedriver.exe", chrome_options=co)
driver.get("http://ip138.com/")
print(driver.page_source)

无认证代理：

1
2
3
4
5

options = webdriver.ChromeOptions()
options.add_argument('--proxy-server=http://ip:port')
driver = webdriver.Chrome(executable_path="C:\chromedriver.exe", chrome_options=0ptions)
driver.get("http://ip138.com/")
print(driver.page_source)

以上完毕 So Easy

整个系统: 采集系统：

PS：此文章为小白提供，大佬请绕道！！！！ 首先特别感谢大才哥给我提供这个平台，未来我希望把java这个版块的内容补全。 今天要讲的是数据类型，最最最基础的内容~ java标识符、数据类型、关键字 开始我们先看下如何注释java代码。 标识符：类名，方法名，变量。 有三种方式分别为 //表示注释一行代码 / 表示注释一行或者多行代码 (从上面到下面都是注释的代码） / 下面还有一种注释方式叫做文档注释。 / 通常这样表示 */ 文档注释一般写在代码开头用来简述你所做程序的具体内容，在这之前我们首先看一下javadoc命令，我先编写一个简答的代码： package com.briup.chap02; / @author Twinkle @version 1.0 It’s a text file / public class PrimitiveType{ public static void main(String[] args){ byte b = 123; byte b1 = 300; } } 我们javadoc -d 生成目录 编译文件 编译成功后，我们打开刚刚生成doc里打开index.html看一下，大概是这样的： 类概要 类： Student 说明： It’s a text file 这样我们就可以看出文档注释的意义了，他可以显示在你编译出来文档的说明里，但有人会发现为啥我们编写出来的author没有出来呀？ 因为他的最前面有一个@，我们需要编写的时候把它加上去才能显示出来，现在我们来试一下， —javadoc -d bin/doc-author -version src/PrimitiveType.java，这样作者和版本信息就出来了 一.类名 这边我们要记住一些代码的基本格式： 类名的写法：Student（前面首字母要大写） 方法和变量的写法：genderItem（前面单词小写，后面单词开头要大写） 常量写法：MAX_PAGE（常量大写，中间一般加下划线） 二.关键字 关键字其实就是电脑里面已经定义好的有特殊意义的标识符，像int,for，double什么的都是关键字。具体意思请百度一下～ 三.数据类型 数据类型是这篇文章的重点，我们来看下这些基本的数据类型 类型 二进制位 例 范围 byte 8位 11111111～01111111 -2^7~2^7-1 short 16位 16个二进制代码 -2^15~2^15-1 int 32位 32个二进制代码 -2^31~2^31-1 long 64位 64个二进制代码 -2^63~2^63-1 浮点型: float 32位 32个二进制代码 double 64位 64个二进制代码 布尔型： boolean 只有false和true两种类型。 具体解释一下为什么会有这么多类型呢？而且二进制位为什么还不一样？ 类型多的原因是因为有些数值本身就很小，传递给大的数据类型的话，虽然可以进去，但是有些二进制位就空闲了，占用了多余的内存却没有什么作用，所以才会有这么多的类型。 我们知道编程最终的目的是我们把代码传递给硬件，通过硬件来工作，但是呢，硬件只识别二进制代码，所以java会有一个把它的代码转化为二进制代码的过渡，上面的二进制位就是二进制码的数目，我们要想看他的范围有多大，可以这样算，二进制的第一位为标志符，通俗一点讲就是正负号，后面还有n位的话它的范围就是-|2^n|～|2^n-1| 如果我们定义的类型超出这个范围的话(也就是盆子里已经装满了东西如果再加），java就会报错，超出指定的范围，所以当我们定义数据类型的时候要搞清楚各数据类型的范围。 还有一个特殊的数据类型：char (‘字符’) char的具体位数要结合unicode编码。问题又来了,unicode编码又是什么鬼！unicode编码是一个字符集，里面包含了中，日，韩，三种文字，我们可以通过char的方法来打印出字符:char(‘u\unicode编码’)，unicode表具体百度一下哈～ 数据类型转换： 显式转换：也就是强制转换 隐式转换：由JVM虚拟机自行转换 数据类型的强制转换：int a = (强制转换类型)b 转换规则:从存储范围大的类型到存储范围小的类型。 具体规则为：double→float→long→int→short(char)→byte byte b =10; byte a = (int) b; 如果我们把int类型的b转换给byte类型的a的话，会出现溢出现象，所以会报错。 所以正确强制转换的方式为～～： byte b = 10; int（或者更大的类型） a =(int) b; java基本的数据类型就讲到这里啦~ *--可能发布的内容有点混乱，我会尽快把前面的补齐~有疑问的话可以到大才哥的群里找我哈~

对于 Scrapy 处理 Ajax 处理方式当然是同家兄弟 Splash 比较靠谱！ 但是 Splash 有个很坑爹的毛病就是负载承受相对较小·· 一不留神就 GG 了·········· 然后也就没有然后了~~！ 所以准备给 Splash 做一个负载均衡；后端放一大堆的 Splash 这样总不会 GG 了吧。 就算其中一个 GG 了还有其它的可替代不是？ 废话不多少开整·· 环境是基于： CentOS 7.3 Docker 17.06.2-ce Splash 3.0 HAproxy 1.7.9 （CentOS 大家可以将 yum 切换为阿里云的 yum 源 Docker 同理）

阿里 yum 源： http://mirrors.aliyun.com/help/centos 照葫芦画瓢做一遍（你是 CentOS7 啊！！！！不要选成其他版本了）

注意以下只需要在你需要运行 splash 的机器上安装即可

阿里 Docker 源：

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

# step 1: 安装必要的一些系统工具

sudo yum install -y yum-utils device-mapper-persistent-data lvm2

# Step 2: 添加软件源信息

sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# Step 3: 更新并安装 Docker-CE

sudo yum makecache fast
sudo yum -y install docker-ce

# Step 4: 开启Docker服务

sudo service docker start

安装 Docker 加速器：

1

curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://8050f360.m.daocloud.io

重启 Docker：

1

systemctl restart docker

这样可以极快的速度拉取镜像。 获取 splash 最新的 docker 镜像：

1

docker pull scrapinghub/splash:master

关闭所有机器防火墙 firewalld(网络安全的环境关闭，不安全的环境请放行端口，自行百度):

1
2
3

systemctl disable firewalld

systemctl stop firewalld

创建 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

# 存放过滤规则文件的目录

[root@localhost ~]# mkdir filters

# 存放JavaScript文件目录

[root@localhost ~]# mkdir js-profiles

# 存放lua模块的目录

[root@localhost ~]# mkdir lua_modules

# 存放代理文件的目录

[root@localhost ~]# mkdir proxy-profiles

# 创建完成如下：

[root@localhost ~]# pwd
/root
[root@localhost ~]# ll
total 4
drwxr-xr-x. 2 root root   25 Sep 26 03:00 filters
drwxr-xr-x. 2 root root    6 Sep 25 21:08 js-profiles
drwxr-xr-x. 2 root root    6 Sep 25 21:08 lua_modules
drwxr-xr-x. 2 root root   32 Sep 25 21:08 proxy-profiles
[root@localhost ~]#

启动 Splash：

1

docker run -d -p 8050:8050 --memory=5.0G --restart=always  --name splash       -v /root/proxy-profiles:/etc/splash/proxy-profiles       -v /root/js-profiles:/etc/splash/js-profiles       -v /root/lua_modules:/etc/splash/lua_modules       -v /root/filters:/etc/splash/filters       scrapinghub/splash:master --maxrss 4500

docker run 启动一个容器 -d 后台启动 -p 8050:8050 将容器的 8050 端口和物理机的 8050 端口绑定（可以从 8050 端口访问容器服务应用） —memory=5.0G 容器最大使用内存为 5.0GB，超出这个限制会被主进程杀死（使用 free -mg 查看并酌情设置你的内存使用） —restart=always 容器退出后无条件重启（满了 5GB 被杀死，然后重启 释放内存） —name splash 容器的名字叫 splash（可以忽略） -v ** 三个-v 参数是将宿主机的目录挂载进容器，便于容器能够直接访问挂载目录中的内容 scrapinghub/splash:master 用于启动容器的镜像 —maxrss 4500 Splash 最大内存使用为 4500MB

查看容器是否启动：

1
2
3
4

[root@localhost ~]# docker ps -a
CONTAINER ID        IMAGE                       COMMAND                  CREATED             STATUS              PORTS                              NAMES
1b34f7933095        scrapinghub/splash:master   "python3 /app/bin/..."   4 hours ago         Up 4 hours          5023/tcp, 0.0.0.0:8050->8050/tcp   splash
[root@localhost ~]#

访问 Splash 是否正常工作：

请注意：以上操作只需要在你需要运行 splash 的机器上安装即可

安装 HAproxy 实现负载均衡：

安装 zlib-devel（HAproxy 使用 gzip 功能）：

1

yum install zlib-devel -y

安装 HAproxy：

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

# 个人喜好 源码放在这个目录
[root@localhost examples]# cd /usr/local/src/

# 安装wget
[root@localhost src]#yum install wget -y

# 下载HAproxy安装包
[root@localhost src]# wget http://www.haproxy.org/download/1.7/src/haproxy-1.7.9.tar.gz

# 解压
[root@localhost src]# tar -zxvf haproxy-1.7.9.tar.gz

# 进入目录
[root@localhost src]# cd haproxy-1.7.9

# 编译
[root@localhost src]# make TARGET=linux2628 PREFIX=/usr/local/haproxy-1.7.9 USE_ZLIB=yes

# 安装
[root@localhost src]# make install

# 拷贝启动文件到目录
[root@localhost src]# cp /usr/local/sbin/haproxy /usr/sbin/

# 测试版本
[root@localhost src]# haproxy -v

# 拷贝启动文件到启动目录
[root@localhost src]# cp examples/haproxy.init /etc/init.d/haproxy

# 赋予可执行权限
[root@localhost src]# chmod 755 /etc/init.d/haproxy

# 创建配置文件目录
[root@localhost src]# mkdir /etc/haproxy

# 创建数据目录
[root@localhost src]# mkdir /var/lib/haproxy

# 创建运行文件目录
[root@localhost src]# mkdir /var/run/haproxy

# 设置日志
[root@localhost src]# vim /etc/rsyslog.conf
# 第15行  $ModLoad imudp #打开注释
# 第16行  $UDPServerRun 514 #打开注释
# 第74行  local3.* /var/log/haproxy.log #local3的路径

# 创建日志文件
[root@localhost src]# touch /var/log/haproxy.log

# 设置权限
[root@localhost src]#  chown -R haproxy.haproxy /var/log/haproxy.log

# 启动日志服务
[root@localhost src]# systemctl restart rsyslog.service

配置 HAproxy Conf：

1

[root@localhost src]# vim /etc/haproxy/haproxy.cfg

写入以下内容：

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

# HAProxy 1.7 config for Splash. It assumes Splash instances are executed
# on the same machine and connected to HAProxy using Docker links.
global
    # raise it if necessary
    maxconn 512
    # required for stats page
    stats socket /tmp/haproxy

userlist users
    user user insecure-password userpass

defaults
    log global
    mode http

    # remove requests from a queue when clients disconnect;
    # see https://cbonte.github.io/haproxy-dconv/1.7/configuration.html#4.2-option%20abortonclose
    option abortonclose

    # gzip can save quite a lot of traffic with json, html or base64 data
    # compression algo gzip
    compression type text/html text/plain application/json

    # increase these values if you want to
    # allow longer request queues in HAProxy
    timeout connect 3600s
    timeout client 3600s
    timeout server 3600s


# visit 0.0.0.0:8036 to see HAProxy stats page
listen stats
    bind *:8036
    mode http
    stats enable
    stats hide-version
    stats show-legends
    stats show-desc Splash Cluster
    stats uri /
    stats refresh 10s
    stats realm Haproxy\ Statistics
    stats auth    admin:adminpass


# Splash Cluster configuration
# 代理服务器监听全局的8050端口
frontend http-in
    bind *:8050
    # 如果你需要开启Splash的访问认证
    # 则注释default_backend splash-cluster
    # 并放开其余default_backend splash-cluster 之上的其余注释
    # 账号密码为user  userpass
    # acl auth_ok http_auth(users)
    # http-request auth realm Splash if !auth_ok
    # http-request allow if auth_ok
    # http-request deny

    # acl staticfiles path_beg /_harviewer/
    # acl misc path / /info /_debug /debug

    # use_backend splash-cluster if auth_ok !staticfiles !misc
    # use_backend splash-misc if auth_ok staticfiles
    # use_backend splash-misc if auth_ok misc
    default_backend splash-cluster


backend splash-cluster
    option httpchk GET /
    balance leastconn

    # try another instance when connection is dropped
    retries 2
    option redispatch
    # 将下面IP地址替换为你自己的Splash服务IP和端口
    # 按照以下格式一次增加其余的Splash服务器
    server splash-0 10.10.1.41:8050 check maxconn 5 inter 2s fall 10 observe layer4
    server splash-1 10.10.1.42:8050 check maxconn 5 inter 2s fall 10 observe layer4
    server splash-2 10.10.1.32:8050 check maxconn 5 inter 2s fall 10 observe layer4

backend splash-misc
    balance roundrobin
    # 将下面IP地址替换为你自己的Splash服务IP和端口
    # 按照以下格式一次增加其余的Splash服务器
    server splash-0 10.10.1.41:8050 check fall 15
    server splash-1 10.10.1.42:8050 check fall 15
    server splash-2 10.10.1.32:8050 check fall 15

启动 HAproxy：

1
2
3
4
5
6
7
8

# 启动HAproxy
[root@localhost src]# /etc/init.d/haproxy start
Restarting haproxy (via systemctl):                        [  OK  ]

# 如果出现错误则使用：
[root@localhost examples]# systemctl status haproxy.service

# 查看报错

查看 HAproxy 状态： 用户名和密码为： admin adminpass

查看 HAproxy 负载是否生效：

完美！！！收工！！ 注意：HAproxy 这台服务器没有安装 Splash 服务，是负载到其余安装有 Splash 的服务器上提供的服务器哦！

大家好，我还是小四毛，不是崔老师！！！！崔老师在隔壁，哈哈哈。

写了一个从网上抓取代理 IP，然后构建代理 IP 池的脚本，放在了这里：https://github.com/xiaosimao/IP_POOL

以后应该还会有很多的改动， 欢迎有兴趣的同学 star，以便及时可以收到改动的通知。

目前是从以下几个网站获取 IP：66ip，xicidaili，data5u，proxydb。

具体的使用方法文档在 readme.md 中， 欢迎交流。

如果你需要从别的网站获得， 那么可以在配置文件中进行相关的配置即可， 如果实在不想自己写，也可以提 issue 给我，我会看情况更新到代码中。

一般情况下，只要配置一下配置项就可以从新的网站获取 IP，最大限度减少写代码的时间。

免费的 ip，质量不敢保证，目前测试的目标网站为百度和https://httpbin.org/get， 还是获得了一些通过测试的 IP，下面是截图。

HTTP 2xx 范围内的状态码表明了“客户端发送的请求已经被服务器接受并且被成功处理了”。 HTTP/1.1 200 OK 是 HTTP 请求成功后的标准响应，当你在浏览器中打开某个网站后,你通常会得到一个 200 状态码。HTTP/1.1 206 状态码表示的是“客户端通过发送范围请求头Range抓取到了资源的部分数据” 这种请求通常用来:

• 学习http头和状态
• 解决网路问题
• 解决大文件下载问题
• 解决CDN和原始HTTP服务器问题
• 使用工具例如lftp,wget,telnet测试断电续传
• 测试将一个大文件分割成多个部分同时下载

测试

查看服务器是否支持 HTTP 206：

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

curl -I https://raw.githubusercontent.com/Germey/LaravelGeetest/master/README.md
HTTP/1.1 200 OK
Content-Security-Policy: default-src 'none'; style-src 'unsafe-inline'
Strict-Transport-Security: max-age=31536000
X-Content-Type-Options: nosniff
X-Frame-Options: deny
X-XSS-Protection: 1; mode=block
ETag: "b29f4639b76cd7f94a4b36b05be6c85acfe478f1"
Content-Type: text/plain; charset=utf-8
Cache-Control: max-age=300
X-Geo-Block-List:
X-GitHub-Request-Id: 850A:16D2:30128BA:3341504:59BBC946
Content-Length: 8709
Accept-Ranges: bytes
Date: Fri, 15 Sep 2017 12:36:31 GMT
Via: 1.1 varnish
Connection: keep-alive
X-Served-By: cache-nrt6123-NRT
X-Cache: HIT
X-Cache-Hits: 1
X-Timer: S1505478991.145862,VS0,VE1
Vary: Authorization,Accept-Encoding
Access-Control-Allow-Origin: *
X-Fastly-Request-ID: ee23d80d2ba507ec0a70c880a075df0d2671aa4d
Expires: Fri, 15 Sep 2017 12:41:31 GMT
Source-Age: 8

其中有两个我们比较关注的请求头： Accept-Ranges: bytes：该响应头表明服务器支持 Range 请求，以及服务器所支持的单位是字节。同时服务器支持断点续传，以及支持同时下载文件的多个部分，也就是说下载工具可以利用范围请求加速下载该文件。Accept-Ranges: none 响应头表示服务器不支持范围请求。 Content-Length: 8709 ：Content-Length 响应头表明了响应实体的大小,也就是真实的图片文件的大小是 8709 字节 (8.7K)。

发送

利用 CURL 可以指定请求范围。 获取前 500 字节：

1

curl --header "Range: bytes=0-500" https://raw.githubusercontent.com/Germey/LaravelGeetest/master/README.md

后 500 字节：

1

curl --header "Range: bytes=-500" https://raw.githubusercontent.com/Germey/LaravelGeetest/master/README.md

从 500 - 1000 字节：

1

curl --header "Range: bytes=500-1000" https://raw.githubusercontent.com/Germey/LaravelGeetest/master/README.md

从 500 - 末尾字节：

1

curl --header "Range: bytes=500-" https://raw.githubusercontent.com/Germey/LaravelGeetest/master/README.md

开启

大部分web服务器都原生支持字节范围请求. Apache 2.x用户可以在httpd.conf中尝试 mod_headers:

1

Header set Accept-Ranges bytes

大家好，我是四毛, 不是崔老师。

恩，今天的内容很短, 主要都写在了 README.md 里面。

写了一个将爬虫基本步骤都封装起来的小框架，地址在https://github.com/xiaosimao/AiSpider， 欢迎 Star。

写的很基础，很简单，大道至简（对，其实就是不会写）。

最近也在学一些设计模式的东西。

欢迎有兴趣的同学共同研究，readme.md 中有我的微信（加的时候麻烦注明一下来自静觅），提出存在的问题和你的想法，这样大家可以共同讨论，共同进步。

BE A SPIDERMAN。

Neo4j是一个世界领先的开源图形数据库，由 Java 编写。图形数据库也就意味着它的数据并非保存在表或集合中，而是保存为节点以及节点之间的关系。 Neo4j 的数据由下面几部分构成：

• 节点
• 边
• 属性

Neo4j 除了顶点（Node）和边（Relationship），还有一种重要的部分——属性。无论是顶点还是边，都可以有任意多的属性。属性的存放类似于一个 HashMap，Key 为一个字符串，而 Value 必须是基本类型或者是基本类型数组。 在Neo4j中，节点以及边都能够包含保存值的属性，此外：

• 可以为节点设置零或多个标签（例如 Author 或 Book）
• 每个关系都对应一种类型（例如 WROTE 或 FRIEND_OF）
• 关系总是从一个节点指向另一个节点（但可以在不考虑指向性的情况下进行查询）

具体介绍可以参考：https://www.w3cschool.cn/neo4j。

Neo4j的特点

• 它拥有简单的查询语言 Neo4j CQL
• 它遵循属性图数据模型
• 它通过使用 Apache Lucence 支持索引
• 它支持 UNIQUE 约束
• 它包含一个用于执行 CQL 命令的 UI：Neo4j 数据浏览器
• 它支持完整的 ACID（原子性，一致性，隔离性和持久性）规则
• 它采用原生图形库与本地 GPE（图形处理引擎）
• 它支持查询的数据导出到 Json 和 XLS 格式
• 它提供了 REST API，可以被任何编程语言（如 Java，Spring，Scala 等）访问
• 它提供了可以通过任何 UI MVC 框架（如 Node JS ）访问的 Java 脚本
• 它支持两种 Java API：Cypher API 和 Native Java API 来开发 Java 应用程序

Neo4j安装

可以到官网直接下载安装包安装即可，链接：https://neo4j.com/download/。

Neo4j CQL命令

Neo4j 的 CQL 是非常重要的命令，类似于 SQL 语句，具体的用法可以参考：https://www.w3cschool.cn/neo4j/neo4j_cql_introduction.html。

Py2Neo用法

Py2Neo 是用来对接 Neo4j 的 Python 库，接下来对其详细介绍。

相关链接

• 官方文档：http://py2neo.org/v3/index.html
• GitHub：https://github.com/technige/py2neo

安装方法

使用 Pip 安装即可：

1

pip3 install py2neo

Node & Relationship

Neo4j 里面最重要的两个数据结构就是节点和关系，即 Node 和 Relationship，可以通过 Node 或 Relationship 对象创建，实例如下：

1
2
3
4
5
6

from py2neo import Node, Relationship

a = Node('Person', name='Alice')
b = Node('Person', name='Bob')
r = Relationship(a, 'KNOWS', b)
print(a, b, r)

运行结果：

1

(alice:Person {name:"Alice"}) (bob:Person {name:"Bob"}) (alice)-[:KNOWS]->(bob)

这样我们就成功创建了两个 Node 和两个 Node 之间的 Relationship。 Node 和 Relationship 都继承了 PropertyDict 类，它可以赋值很多属性，类似于字典的形式，例如可以通过如下方式对 Node 或 Relationship 进行属性赋值，接着上面的代码，实例如下:

1
2
3
4

a['age'] = 20
b['age'] = 21
r['time'] = '2017/08/31'
print(a, b, r)

运行结果：

1

(alice:Person {age:20,name:"Alice"}) (bob:Person {age:21,name:"Bob"}) (alice)-[:KNOWS {time:"2017/08/31"}]->(bob)

可见通过类似字典的操作方法就可以成功实现属性赋值。 另外还可以通过 setdefault() 方法赋值默认属性，例如：

1
2

a.setdefault('location', '北京')
print(a)

运行结果：

1

(alice:Person {age:20,location:"北京",name:"Alice"})

可见没有给 a 对象赋值 location 属性，现在就会使用默认属性。 但如果赋值了 location 属性，则它会覆盖默认属性，例如：

1
2
3

a['location'] = '上海'
a.setdefault('location', '北京')
print(a)

运行结果：

1

(alice:Person {age:20,location:"上海",name:"Alice"})

另外也可以使用 update() 方法对属性批量更新，接着上面的例子实例如下：

1
2
3
4
5
6

data = {
    'name': 'Amy',
    'age': 21
}
a.update(data)
print(a)

运行结果：

1

(alice:Person {age:21,location:"上海",name:"Amy"})

可以看到这里更新了 a 对象的 name 和 age 属性，没有更新 location 属性，则 name 和 age 属性会更新，location 属性则会保留。

Subgraph

Subgraph，子图，是 Node 和 Relationship 的集合，最简单的构造子图的方式是通过关系运算符，实例如下：

1
2
3
4
5
6
7

from py2neo import Node, Relationship

a = Node('Person', name='Alice')
b = Node('Person', name='Bob')
r = Relationship(a, 'KNOWS', b)
s = a | b | r
print(s)

运行结果：

1

({(alice:Person {name:"Alice"}), (bob:Person {name:"Bob"})}, {(alice)-[:KNOWS]->(bob)})

这样就组成了一个 Subgraph。 另外还可以通过 nodes() 和 relationships() 方法获取所有的 Node 和 Relationship，实例如下：

1
2

print(s.nodes())
print(s.relationships())

运行结果：

1
2

frozenset({(alice:Person {name:"Alice"}), (bob:Person {name:"Bob"})})
frozenset({(alice)-[:KNOWS]->(bob)})

可以看到结果是 frozenset 类型。 另外还可以利用 & 取 Subgraph 的交集，例如：

1
2
3

s1 = a | b | r
s2 = a | b
print(s1 & s2)

运行结果：

1

({(alice:Person {name:"Alice"}), (bob:Person {name:"Bob"})}, {})

可以看到结果是二者的交集。 另外我们还可以分别利用 keys()、labels()、nodes()、relationships()、types() 分别获取 Subgraph 的 Key、Label、Node、Relationship、Relationship Type，实例如下：

1
2
3
4
5
6

s = a | b | r
print(s.keys())
print(s.labels())
print(s.nodes())
print(s.relationships())
print(s.types())

运行结果：

1
2
3
4
5

frozenset({'name'})
frozenset({'Person'})
frozenset({(alice:Person {name:"Alice"}), (bob:Person {name:"Bob"})})
frozenset({(alice)-[:KNOWS]->(bob)})
frozenset({'KNOWS'})

另外还可以用 order() 或 size() 方法来获取 Subgraph 的 Node 数量和 Relationship 数量，实例如下：

1
2
3
4

from py2neo import Node, Relationship, size, order
s = a | b | r
print(order(s))
print(size(s))

运行结果：

1
2

2
1

Walkable

Walkable 是增加了遍历信息的 Subgraph，我们通过 + 号便可以构建一个 Walkable 对象，例如：

1
2
3
4
5
6
7
8
9

from py2neo import Node, Relationship

a = Node('Person', name='Alice')
b = Node('Person', name='Bob')
c = Node('Person', name='Mike')
ab = Relationship(a, "KNOWS", b)
ac = Relationship(a, "KNOWS", c)
w = ab + Relationship(b, "LIKES", c) + ac
print(w)

运行结果：

1

(alice)-[:KNOWS]->(bob)-[:LIKES]->(mike)<-[:KNOWS]-(alice)

这样我们就形成了一个 Walkable 对象。 另外我们可以调用 walk() 方法实现遍历，实例如下：

1
2
3
4

from py2neo import walk

for item in walk(w):
    print(item)

运行结果：

1
2
3
4
5
6
7

(alice:Person {name:"Alice"})
(alice)-[:KNOWS]->(bob)
(bob:Person {name:"Bob"})
(bob)-[:LIKES]->(mike)
(mike:Person {name:"Mike"})
(alice)-[:KNOWS]->(mike)
(alice:Person {name:"Alice"})

可以看到它从 a 这个 Node 开始遍历，然后到 b，再到 c，最后重新回到 a。 另外还可以利用 start_node()、end_node()、nodes()、relationships() 方法来获取起始 Node、终止 Node、所有 Node 和 Relationship，例如：

1
2
3
4

print(w.start_node())
print(w.end_node())
print(w.nodes())
print(w.relationships())

运行结果：

1
2
3
4

(alice:Person {name:"Alice"})
(alice:Person {name:"Alice"})
((alice:Person {name:"Alice"}), (bob:Person {name:"Bob"}), (mike:Person {name:"Mike"}), (alice:Person {name:"Alice"}))
((alice)-[:KNOWS]->(bob), (bob)-[:LIKES]->(mike), (alice)-[:KNOWS]->(mike))

可以看到本例中起始和终止 Node 都是同一个，这和 walk() 方法得到的结果是一致的。

Graph

在 database 模块中包含了和 Neo4j 数据交互的 API，最重要的当属 Graph，它代表了 Neo4j 的图数据库，同时 Graph 也提供了许多方法来操作 Neo4j 数据库。 Graph 在初始化的时候需要传入连接的 URI，初始化参数有 bolt、secure、host、http_port、https_port、bolt_port、user、password，详情说明可以参考：http://py2neo.org/v3/database.html#py2neo.database.Graph。 初始化的实例如下：

1
2
3
4

from py2neo import Graph
graph_1 = Graph()
graph_2 = Graph(host="localhost")
graph_3 = Graph("http://localhost:7474/db/data/")

另外我们还可以利用 create() 方法传入 Subgraph 对象来将关系图添加到数据库中，实例如下：

1
2
3
4
5
6
7
8

from py2neo import Node, Relationship, Graph

a = Node('Person', name='Alice')
b = Node('Person', name='Bob')
r = Relationship(a, 'KNOWS', b)
s = a | b | r
graph = Graph(password='123456')
graph.create(s)

这里必须确保 Neo4j 正常运行，其密码为 123456，这里调用 create() 方法即可完成图的创建，结果如下： 另外我们也可以单独添加单个 Node 或 Relationship，实例如下：

1
2
3
4
5
6
7
8

from py2neo import Graph, Node, Relationship

graph = Graph(password='123456')
a = Node('Person', name='Alice')
graph.create(a)
b = Node('Person', name='Bob')
ab = Relationship(a, 'KNOWS', b)
graph.create(ab)

运行结果如下： 另外还可以利用 data() 方法来获取查询结果：

1
2
3
4
5

from py2neo import Graph

graph = Graph(password='123456')
data = graph.data('MATCH (p:Person) return p')
print(data)

运行结果：

1

[{'p': (e0d0f96:Person {name:"Alice"})}, {'p': (cfe57d0:Person {name:"Bob"})}]

这里是通过 CQL 语句实现的查询，输出结果即 CQL 语句的返回结果，是列表形式。 另外输出结果还可以直接转化为 DataFrame 对象，实例如下：

1
2
3
4
5
6

from py2neo import Graph
from pandas import DataFrame
graph = Graph(password='123456')
data = graph.data('MATCH (p:Person) return p')
df = DataFrame(data)
print(df)

运行结果：

1
2
3

                   p
0  {'name': 'Alice'}
1    {'name': 'Bob'}

另外可以使用 find_one() 或 find() 方法进行 Node 的查找，可以利用 match() 或 match_one() 方法对 Relationship 进行查找：

1
2
3
4
5
6
7

from py2neo import Graph

graph = Graph(password='123456')
node = graph.find_one(label='Person')
print(node)
relationship = graph.match_one(rel_type='KNOWS')
print(relationship)

运行结果：

1
2

(c7402c7:Person {age:21,name:"Alice"})
(c7402c7)-[:KNOWS]->(e2c42fc)

如果想要更新 Node 的某个属性可以使用 push() 方法，例如：

1
2
3
4
5
6
7
8

from py2neo import Graph, Node

graph = Graph(password='123456')
a = Node('Person', name='Alice')
node = graph.find_one(label='Person')
node['age'] = 21
graph.push(node)
print(graph.find_one(label='Person'))

运行结果：

1

(a90a763:Person {age:21,name:"Alice"})

如果想要删除某个 Node 可以使用 delete() 方法，例如：

1
2
3
4
5
6
7

from py2neo import Graph

graph = Graph(password='123456')
node = graph.find_one(label='Person')
relationship = graph.match_one(rel_type='KNOWS')
graph.delete(relationship)
graph.delete(node)

在删除 Node 时必须先删除其对应的 Relationship，否则无法删除 Node。 另外我们也可以通过 run() 方法直接执行 CQL 语句，例如：

1
2
3
4
5

from py2neo import Graph

graph = Graph(password='123456')
data = graph.run('MATCH (p:Person) RETURN p LIMIT 5')
print(list(data))

运行结果：

1

[('p': (b6f61ff:Person {age:20,name:"Alice"})), ('p': (cc238b1:Person {age:20,name:"Alice"})), ('p': (b09e672:Person {age:20,name:"Alice"}))]

NodeSelector

Graph 有时候用起来不太方便，比如如果要根据多个条件进行 Node 的查询是做不到的，在这里更方便的查询方法是利用 NodeSelector，我们首先新建如下的 Node 和 Relationship，实例如下：

1
2
3
4
5
6
7
8
9
10
11

from py2neo import Graph, Node, Relationship

graph = Graph(password='123456')
a = Node('Person', name='Alice', age=21, location='广州')
b = Node('Person', name='Bob', age=22, location='上海')
c = Node('Person', name='Mike', age=21, location='北京')
r1 = Relationship(a, 'KNOWS', b)
r2 = Relationship(b, 'KNOWS', c)
graph.create(a)
graph.create(r1)
graph.create(r2)

运行结果： 在这里我们用 NodeSelector 来筛选 age 为 21 的 Person Node，实例如下：

1
2
3
4
5
6

from py2neo import Graph, NodeSelector

graph = Graph(password='123456')
selector = NodeSelector(graph)
persons = selector.select('Person', age=21)
print(list(persons))

运行结果：

1

[(d195b2e:Person {age:21,location:"广州",name:"Alice"}), (eefe475:Person {age:21,location:"北京",name:"Mike"})]

另外也可以使用 where() 进行更复杂的查询，例如查找 name 是 A 开头的 Person Node，实例如下：

1
2
3
4
5
6

from py2neo import Graph, NodeSelector

graph = Graph(password='123456')
selector = NodeSelector(graph)
persons = selector.select('Person').where('_.name =~ "A.*"')
print(list(persons))

运行结果：

1

[(bcd8072:Person {age:21,location:"广州",name:"Alice"})]

在这里用了正则表达式匹配查询。 另外也可以使用 order_by() 进行排序：

1
2
3
4
5
6

from py2neo import Graph, NodeSelector

graph = Graph(password='123456')
selector = NodeSelector(graph)
persons = selector.select('Person').order_by('_.age')
print(list(persons))

运行结果：

1

[(e3fc3d7:Person {age:21,location:"广州",name:"Alice"}), (da0179d:Person {age:21,location:"北京",name:"Mike"}), (cafa16e:Person {age:22,location:"上海",name:"Bob"})]

前面返回的都是列表，如果要查询单个节点的话，可以使用 first() 方法，实例如下：

1
2
3
4
5
6

from py2neo import Graph, NodeSelector

graph = Graph(password='123456')
selector = NodeSelector(graph)
person = selector.select('Person').where('_.name =~ "A.*"').first()
print(person)

运行结果：

1

(ea81c04:Person {age:21,location:"广州",name:"Alice"})

更详细的内容可以查看：http://py2neo.org/v3/database.html#cypher-utilities。

OGM

OGM 类似于 ORM，意为 Object Graph Mapping，这样可以实现一个对象和 Node 的关联，例如：

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

from py2neo.ogm import GraphObject, Property, RelatedTo, RelatedFrom


class Movie(GraphObject):
    __primarykey__ = 'title'

    title = Property()
    released = Property()
    actors = RelatedFrom('Person', 'ACTED_IN')
    directors = RelatedFrom('Person', 'DIRECTED')
    producers = RelatedFrom('Person', 'PRODUCED')

class Person(GraphObject):
    __primarykey__ = 'name'

    name = Property()
    born = Property()
    acted_in = RelatedTo('Movie')
    directed = RelatedTo('Movie')
    produced = RelatedTo('Movie')

我们可以用它来结合 Graph 查询，例如：

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

from py2neo import Graph
from py2neo.ogm import GraphObject, Property

graph = Graph(password='123456')


class Person(GraphObject):
    __primarykey__ = 'name'

    name = Property()
    age = Property()
    location = Property()

person = Person.select(graph).where(age=21).first()
print(person)
print(person.name)
print(person.age)

运行结果：

1
2
3

<Person name='Alice'>
Alice
21

这样我们就成功实现了对象和 Node 的映射。 我们可以用它动态改变 Node 的属性，例如修改某个 Node 的 age 属性，实例如下：

1
2
3
4
5

person = Person.select(graph).where(age=21).first()
print(person.__ogm__.node)
person.age = 22
print(person.__ogm__.node)
graph.push(person)

运行结果：

1
2

(ccf5640:Person {age:21,location:"北京",name:"Mike"})
(ccf5640:Person {age:22,location:"北京",name:"Mike"})

另外我们也可以通过映射关系进行 Relationship 的调整，例如通过 Relationship 添加一个关联 Node，实例如下：

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

from py2neo import Graph
from py2neo.ogm import GraphObject, Property, RelatedTo

graph = Graph(password='123456')

class Person(GraphObject):
    __primarykey__ = 'name'

    name = Property()
    age = Property()
    location = Property()
    knows = RelatedTo('Person', 'KNOWS')

person = Person.select(graph).where(age=21).first()
print(list(person.knows))
new_person = Person()
new_person.name = 'Durant'
new_person.age = 28
person.knows.add(new_person)
print(list(person.knows))

运行结果：

1
2

[<Person name='Bob'>]
[<Person name='Bob'>, <Person name='Durant'>]

这样我们就完成了 Node 和 Relationship 的添加，同时由于设置了 primarykey 为 name，所以不会重复添加。 但是注意此时数据库并没有更新，只是对象更新了，如果要更新到数据库中还需要调用 Graph 对象的 push() 或 pull() 方法，添加如下代码即可：

1

graph.push(person)

也可以通过 remove() 方法移除某个关联 Node，实例如下：

1
2
3
4
5

person = Person.select(graph).where(name='Alice').first()
target = Person.select(graph).where(name='Durant').first()
person.knows.remove(target)
graph.push(person)
graph.delete(target)

这里 target 是 name 为 Durant 的 Node，代码运行完毕后即可删除关联 Relationship 和删除 Node。 以上便是 OGM 的用法，查询修改非常方便，推荐使用此方法进行 Node 和 Relationship 的修改。 更多内容可以查看：http://py2neo.org/v3/ogm.html#module-py2neo.ogm。

结语

以上便是对 Neo4j 的相关介绍。

基本步骤： 1、训练素材分类： 我是参考官方的目录结构： 每个目录中放对应的文本，一个 txt 文件一篇对应的文章：就像下面这样 需要注意的是所有素材比例请保持在相同的比例（根据训练结果酌情调整、不可比例过于悬殊、容易造成过拟合（通俗点就是大部分文章都给你分到素材最多的那个类别去了）） 废话不多说直接上代码吧（测试代码的丑得一逼；将就着看看吧） 需要一个小工具： pip install chinese-tokenizer 这是训练器：

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

import re
import jieba
import json
from io import BytesIO
from chinese_tokenizer.tokenizer import Tokenizer
from sklearn.datasets import load_files
from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.externals import joblib

jie_ba_tokenizer = Tokenizer().jie_ba_tokenizer

# 加载数据集
training_data = load_files('./data', encoding='utf-8')
# x_train txt内容 y_train 是类别（正 负 中 ）
x_train, _, y_train, _ = train_test_split(training_data.data, training_data.target)
print('开始建模.....')
with open('training_data.target', 'w', encoding='utf-8') as f:
    f.write(json.dumps(training_data.target_names))
# tokenizer参数是用来对文本进行分词的函数（就是上面我们结巴分词）
count_vect = CountVectorizer(tokenizer=jieba_tokenizer)

tfidf_transformer = TfidfTransformer()
X_train_counts = count_vect.fit_transform(x_train)

X_train_tfidf = tfidf_transformer.fit_transform(X_train_counts)
print('正在训练分类器.....')
# 多项式贝叶斯分类器训练
clf = MultinomialNB().fit(X_train_tfidf, y_train)
# 保存分类器（好在其它程序中使用）
joblib.dump(clf, 'model.pkl')
# 保存矢量化（坑在这儿！！需要使用和训练器相同的 矢量器 不然会报错！！！！！！ 提示 ValueError dimension mismatch··）
joblib.dump(count_vect, 'count_vect')
print("分类器的相关信息：")
print(clf)

下面是是使用训练好的分类器分类文章： 需要分类的文章放在 predict_data 目录中：照样是一篇文章一个 txt 文件

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

# -*- coding: utf-8 -*-
# @Time    : 2017/8/23 18:02
# @Author  : 哎哟卧槽
# @Site    :
# @File    : 贝叶斯分类器.py
# @Software: PyCharm

import re
import jieba
import json
from sklearn.datasets import load_files
from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
from sklearn.externals import joblib


# 加载分类器
clf = joblib.load('model.pkl')

count_vect = joblib.load('count_vect')
testing_data = load_files('./predict_data', encoding='utf-8')
target_names = json.loads(open('training_data.target', 'r', encoding='utf-8').read())
#     # 字符串处理
tfidf_transformer = TfidfTransformer()

X_new_counts = count_vect.transform(testing_data.data)
X_new_tfidf = tfidf_transformer.fit_transform(X_new_counts)
# 进行预测
predicted = clf.predict(X_new_tfidf)
for title, category in zip(testing_data.filenames, predicted):
    print('%r => %s' % (title, target_names[category]))

这个样子将训练好的分类器在新的程序中使用时候 就不报错： ValueError dimension mismatch·· 这儿有个 demo 仅供参考：GitHub 地址

估摸着各位小伙伴儿被想使用 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)