静觅 崔庆才的个人站点 - Python爬虫教程

本节我们来用 TensorFlow 来实现一个深度学习模型，用来实现验证码识别的过程，这里我们识别的验证码是图形验证码，首先我们会用标注好的数据来训练一个模型，然后再用模型来实现这个验证码的识别。

验证码

首先我们来看下验证码是怎样的，这里我们使用 Python 的 captcha 库来生成即可，这个库默认是没有安装的，所以这里我们需要先安装这个库，另外我们还需要安装 pillow 库，使用 pip3 即可：

1

pip3 install captcha pillow

安装好之后，我们就可以用如下代码来生成一个简单的图形验证码了：

1
2
3
4
5
6
7
8

from captcha.image import ImageCaptcha
from PIL import Image

text = '1234'
image = ImageCaptcha()
captcha = image.generate(text)
captcha_image = Image.open(captcha)
captcha_image.show()

运行之后便会弹出一张图片，结果如下： 可以看到图中的文字正是我们所定义的 text 内容，这样我们就可以得到一张图片和其对应的真实文本，这样我们就可以用它来生成一批训练数据和测试数据了。

预处理

在训练之前肯定是要进行数据预处理了，现在我们首先定义好了要生成的验证码文本内容，这就相当于已经有了 label 了，然后我们再用它来生成验证码，就可以得到输入数据 x 了，在这里我们首先定义好我们的输入词表，由于大小写字母加数字的词表比较庞大，设想我们用含有大小写字母和数字的验证码，一个验证码四个字符，那么一共可能的组合是 (26 + 26 + 10) ^ 4 = 14776336 种组合，这个数量训练起来有点大，所以这里我们精简一下，只使用纯数字的验证码来训练，这样其组合个数就变为 10 ^ 4 = 10000 种，显然少了很多。 所以在这里我们先定义一个词表和其长度变量：

1
2
3

VOCAB = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
CAPTCHA_LENGTH = 4
VOCAB_LENGTH = len(VOCAB)

这里 VOCAB 就是词表的内容，即 0 到 9 这 10 个数字，验证码的字符个数即 CAPTCHA_LENGTH 是 4，词表长度是 VOCAB 的长度，即 10。 接下来我们定义一个生成验证码数据的方法，流程类似上文，只不过这里我们将返回的数据转为了 Numpy 形式的数组：

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

from PIL import Image
from captcha.image import ImageCaptcha
import numpy as np

def generate_captcha(captcha_text):
    """
    get captcha text and np array
    :param captcha_text: source text
    :return: captcha image and array
    """
    image = ImageCaptcha()
    captcha = image.generate(captcha_text)
    captcha_image = Image.open(captcha)
    captcha_array = np.array(captcha_image)
    return captcha_array

这样调用此方法，我们就可以得到一个 Numpy 数组了，这个其实是把验证码转化成了每个像素的 RGB，我们调用一下这个方法试试：

1
2

captcha = generate_captcha('1234')
print(captcha, captcha.shape)

内容如下：

1
2
3
4
5
6
7
8
9

[[[239 244 244]
  [239 244 244]
  [239 244 244]
  ..., 
  ..., 
  [239 244 244]
  [239 244 244]
  [239 244 244]]] 
(60, 160, 3)

可以看到它的 shape 是 (60, 160, 3)，这其实代表验证码图片的高度是 60，宽度是 160，是 60 x 160 像素的验证码，每个像素都有 RGB 值，所以最后一维即为像素的 RGB 值。 接下来我们需要定义 label，由于我们需要使用深度学习模型进行训练，所以这里我们的 label 数据最好使用 One-Hot 编码，即如果验证码文本是 1234，那么应该词表索引位置置 1，总共的长度是 40，我们用程序实现一下 One-Hot 编码和文本的互相转换：

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

def text2vec(text):
    """
    text to one-hot vector
    :param text: source text
    :return: np array
    """
    if len(text) > CAPTCHA_LENGTH:
        return False
    vector = np.zeros(CAPTCHA_LENGTH * VOCAB_LENGTH)
    for i, c in enumerate(text):
        index = i * VOCAB_LENGTH + VOCAB.index(c)
        vector[index] = 1
    return vector


def vec2text(vector):
    """
    vector to captcha text
    :param vector: np array
    :return: text
    """
    if not isinstance(vector, np.ndarray):
        vector = np.asarray(vector)
    vector = np.reshape(vector, [CAPTCHA_LENGTH, -1])
    text = ''
    for item in vector:
        text += VOCAB[np.argmax(item)]
    return text

这里 text2vec() 方法就是将真实文本转化为 One-Hot 编码，vec2text() 方法就是将 One-Hot 编码转回真实文本。 例如这里调用一下这两个方法，我们将 1234 文本转换为 One-Hot 编码，然后在将其转回来：

1
2
3

vector = text2vec('1234')
text = vec2text(vector)
print(vector, text)

运行结果如下：

1
2
3
4

[ 0.  1.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  1.  0.  0.  0.  0.  0.
  0.  0.  0.  0.  0.  1.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  1.  0.
  0.  0.  0.  0.]
1234

这样我们就可以实现文本到 One-Hot 编码的互转了。 接下来我们就可以构造一批数据了，x 数据就是验证码的 Numpy 数组，y 数据就是验证码的文本的 One-Hot 编码，生成内容如下：

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

import random
from os.path import join, exists
import pickle
import numpy as np
from os import makedirs

DATA_LENGTH = 10000
DATA_PATH = 'data'

def get_random_text():
    text = ''
    for i in range(CAPTCHA_LENGTH):
        text += random.choice(VOCAB)
    return text

def generate_data():
    print('Generating Data...')
    data_x, data_y = [], []

    # generate data x and y
    for i in range(DATA_LENGTH):
        text = get_random_text()
        # get captcha array
        captcha_array = generate_captcha(text)
        # get vector
        vector = text2vec(text)
        data_x.append(captcha_array)
        data_y.append(vector)

    # write data to pickle
    if not exists(DATA_PATH):
        makedirs(DATA_PATH)

    x = np.asarray(data_x, np.float32)
    y = np.asarray(data_y, np.float32)
    with open(join(DATA_PATH, 'data.pkl'), 'wb') as f:
        pickle.dump(x, f)
        pickle.dump(y, f)

这里我们定义了一个 get_random_text() 方法，可以随机生成验证码文本，然后接下来再利用这个随机生成的文本来产生对应的 x、y 数据，然后我们再将数据写入到 pickle 文件里，这样就完成了预处理的操作。

构建模型

有了数据之后，我们就开始构建模型吧，这里我们还是利用 train_test_split() 方法将数据分为三部分，训练集、开发集、验证集：

1
2
3
4
5
6
7

with open('data.pkl', 'rb') as f:
    data_x = pickle.load(f)
    data_y = pickle.load(f)
    return standardize(data_x), data_y

train_x, test_x, train_y, test_y = train_test_split(data_x, data_y, test_size=0.4, random_state=40)
dev_x, test_x, dev_y, test_y, = train_test_split(test_x, test_y, test_size=0.5, random_state=40)

接下来我们使用者三个数据集构建三个 Dataset 对象：

1
2
3
4
5
6
7
8
9

# train and dev dataset
train_dataset = tf.data.Dataset.from_tensor_slices((train_x, train_y)).shuffle(10000)
train_dataset = train_dataset.batch(FLAGS.train_batch_size)

dev_dataset = tf.data.Dataset.from_tensor_slices((dev_x, dev_y))
dev_dataset = dev_dataset.batch(FLAGS.dev_batch_size)

test_dataset = tf.data.Dataset.from_tensor_slices((test_x, test_y))
test_dataset = test_dataset.batch(FLAGS.test_batch_size)

然后初始化一个迭代器，并绑定到这个数据集上：

1
2
3
4
5

# a reinitializable iterator
iterator = tf.data.Iterator.from_structure(train_dataset.output_types, train_dataset.output_shapes)
train_initializer = iterator.make_initializer(train_dataset)
dev_initializer = iterator.make_initializer(dev_dataset)
test_initializer = iterator.make_initializer(test_dataset)

接下来就是关键的部分了，在这里我们使用三层卷积和两层全连接网络进行构造，在这里为了简化写法，直接使用 TensorFlow 的 layers 模块：

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

# input Layer
with tf.variable_scope('inputs'):
    # x.shape = [-1, 60, 160, 3]
    x, y_label = iterator.get_next()
keep_prob = tf.placeholder(tf.float32, [])
y = tf.cast(x, tf.float32)
# 3 CNN layers
for _ in range(3):
    y = tf.layers.conv2d(y, filters=32, kernel_size=3, padding='same', activation=tf.nn.relu)
    y = tf.layers.max_pooling2d(y, pool_size=2, strides=2, padding='same')
    # y = tf.layers.dropout(y, rate=keep_prob)

# 2 dense layers
y = tf.layers.flatten(y)
y = tf.layers.dense(y, 1024, activation=tf.nn.relu)
y = tf.layers.dropout(y, rate=keep_prob)
y = tf.layers.dense(y, VOCAB_LENGTH)

这里卷积核大小为 3，padding 使用 SAME 模式，激活函数使用 relu。 经过全连接网络变换之后，y 的 shape 就变成了 [batch_size, n_classes]，我们的 label 是 CAPTCHA_LENGTH 个 One-Hot 向量拼合而成的，在这里我们想使用交叉熵来计算，但是交叉熵计算的时候，label 参数向量最后一维各个元素之和必须为 1，不然计算梯度的时候会出现问题。详情参见 TensorFlow 的官方文档：https://www.tensorflow.org/api_docs/python/tf/nn/softmax_cross_entropy_with_logits：

NOTE: While the classes are mutually exclusive, their probabilities need not be. All that is required is that each row of labels is a valid probability distribution. If they are not, the computation of the gradient will be incorrect.

但是现在的 label 参数是 CAPTCHA_LENGTH 个 One-Hot 向量拼合而成，所以这里各个元素之和为 CAPTCHA_LENGTH，所以我们需要重新 reshape 一下，确保最后一维各个元素之和为 1：

1
2

y_reshape = tf.reshape(y, [-1, VOCAB_LENGTH])
y_label_reshape = tf.reshape(y_label, [-1, VOCAB_LENGTH])

这样我们就可以确保最后一维是 VOCAB_LENGTH 长度，而它就是一个 One-Hot 向量，所以各元素之和必定为 1。 然后 Loss 和 Accuracy 就好计算了：

1
2
3
4
5
6
7

# loss
cross_entropy = tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(logits=y_reshape, labels=y_label_reshape))
# accuracy
max_index_predict = tf.argmax(y_reshape, axis=-1)
max_index_label = tf.argmax(y_label_reshape, axis=-1)
correct_predict = tf.equal(max_index_predict, max_index_label)
accuracy = tf.reduce_mean(tf.cast(correct_predict, tf.float32))

再接下来执行训练即可：

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

# train
train_op = tf.train.RMSPropOptimizer(FLAGS.learning_rate).minimize(cross_entropy, global_step=global_step)
for epoch in range(FLAGS.epoch_num):
    tf.train.global_step(sess, global_step_tensor=global_step)
    # train
    sess.run(train_initializer)
    for step in range(int(train_steps)):
        loss, acc, gstep, _ = sess.run([cross_entropy, accuracy, global_step, train_op],
                                       feed_dict={keep_prob: FLAGS.keep_prob})
        # print log
        if step % FLAGS.steps_per_print == 0:
            print('Global Step', gstep, 'Step', step, 'Train Loss', loss, 'Accuracy', acc)

    if epoch % FLAGS.epochs_per_dev == 0:
        # dev
        sess.run(dev_initializer)
        for step in range(int(dev_steps)):
            if step % FLAGS.steps_per_print == 0:
                print('Dev Accuracy', sess.run(accuracy, feed_dict={keep_prob: 1}), 'Step', step)

在这里我们首先初始化 train_initializer，将 iterator 绑定到 Train Dataset 上，然后执行 train_op，获得 loss、acc、gstep 等结果并输出。

训练

运行训练过程，结果类似如下：

1
2
3
4
5
6
7
8
9
10

...
Dev Accuracy 0.9580078 Step 0
Dev Accuracy 0.9472656 Step 2
Dev Accuracy 0.9501953 Step 4
Dev Accuracy 0.9658203 Step 6
Global Step 3243 Step 0 Train Loss 1.1920928e-06 Accuracy 1.0
Global Step 3245 Step 2 Train Loss 1.5497207e-06 Accuracy 1.0
Global Step 3247 Step 4 Train Loss 1.1920928e-06 Accuracy 1.0
Global Step 3249 Step 6 Train Loss 1.7881392e-06 Accuracy 1.0
...

验证集准确率 95% 以上。

测试

训练过程我们还可以每隔几个 Epoch 保存一下模型：

1
2
3

# save model
if epoch % FLAGS.epochs_per_save == 0:
    saver.save(sess, FLAGS.checkpoint_dir, global_step=gstep)

当然也可以取验证集上准确率最高的模型进行保存。 验证时我们可以重新 Reload 一下模型，然后进行验证：

1
2
3
4
5
6
7
8
9
10
11

# load model
ckpt = tf.train.get_checkpoint_state('ckpt')
if ckpt:
    saver.restore(sess, ckpt.model_checkpoint_path)
    print('Restore from', ckpt.model_checkpoint_path)
    sess.run(test_initializer)
    for step in range(int(test_steps)):
        if step % FLAGS.steps_per_print == 0:
            print('Test Accuracy', sess.run(accuracy, feed_dict={keep_prob: 1}), 'Step', step)
else:
    print('No Model Found')

验证之后其准确率基本是差不多的。 如果要进行新的 Inference 的话，可以替换下 test_x 即可。

结语

以上便是使用 TensorFlow 进行验证码识别的过程，代码见：https://github.com/AIDeepLearning/CrackCaptcha。

大家好，我是四毛，最近开通了个人公众号“用 Python 来编程”，欢迎大家“关注”，这样您就可以收到优质的文章了。

今天跟大家分享的主题是利用 python 库 twilio 来免费发送短信。

先放一张成品图

代码放在了本文最后的地址中，欢迎有需要的自取，有任何也可以在评论或者后台直接私聊我。

正文

眼尖的小伙伴已经发现了上面的短信的前缀显示这个短信来自于一个叫 Twilio 的免费的账户，今天我们用到的库就是 twilio，既然是免费的账户，那么肯定是有一些限制的，这个会在后面提到。

另外要注意的是这个网站从国内访问的时候，可能会因为一些你懂得原因没法访问，那就只好学习一下怎么科学上网了。

1.Twilio

Twilio 是一个做成开放插件的电话跟踪服务（call-tracking service）。美国当地时间 2016 年 6 月 23 日，云通讯公司 Twilio 在纽约证券交易所上市（来自于百度百科）

2. 安装

官方文档地址：https://www.twilio.com/docs/libraries/python

同时官方还提供对以下语言的支持

可以看到，还是很丰富的。

最简单的方式就是通过 pip，执行如下命令：

1

pip install twilio

3.注册账号

安装好库以后，就需要到官方的网页上进行注册了。

进入官网：https://www.twilio.com

然后进入注册页面

接着通过了人机认证以后，就会对你的手机号码进行认证，这个就不发图片了。

4. 进入 console

注册好了以后，就可以进入我们自己的面板了

图中箭头所指的两个参数是我们代码中需要的， 可以把两个都复制一下；

既然是发短信，那么肯定是有一个接收者和一个发送者，发送者的号码可不是我们自己刚刚填的号码，而且 twilio 给我们分配的一个号码，因为我也是前段时间搞好了，所以不太记得这个号码是不是一开始进去就有的了，如果没有的话，那么就点击 Get Stared。

现在我们点击 Manage Numbers

这个时候就可以看到我们的号码了，这是重点，记下来

5. 写代码

根据文档的内容，我们编写了下面的代码：

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author  : ShiMeng
# @File    : send_sms.py
# @Software: PyCharm
from twilio.rest import Client
# Your Account SID from twilio.com/console
account_sid = "your account sid"
# Your Auth Token from twilio.com/console
auth_token  = "your token"
client = Client(account_sid, auth_token)
message = client.messages.create(
# 这里中国的号码前面需要加86
to="+接收者的号码",
from_="+twilio给你的号码 ",
body="Hello from Python!")
print(message.sid)

然后执行程序，你应该会碰到下面的错误

可以从报错信息中明显的看到，提示我们说这个号码没有验证，我们可以到验证的网址上验证一下，也可以购买一个高级别的账号来给未验证的号码发送信息。

而这个就是我一开始提到的免费账号的限制，在这个限制下面如果你想发送信息给一个接收者，这个接收者的号码必须通过验证，语音验证或者短信验证都可以。如果你是想大批量的发那种垃圾信息，那么你不用往下面看了。下面我们就来对号码进行验证。

6. 验证号码

验证网址：https://www.twilio.com/console/phone-numbers/verified

7.重新执行代码

这个时候重新执行我们的代码，没有报错的话，接收者就应该收到你的消息了，就像我一开始放的成品图一样。

但是，在我们发送的信息前面，有一段前缀，我查了一下官方的文档，说这个免费的账户，这个前缀是去不掉的。。。。。。

8.查看用量

在面板中，点击 Usage 即可看到我们的用量， 如下图所示

可以看到我们的用量以及花费，这个花费是不需要我们真正的付钱的，官方的解释是：

9.打电话

打电话的代码也很简单

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

# Download the Python helper library from twilio.com/docs/python/install
from twilio.rest import Client
# Your Account Sid and Auth Token from twilio.com/user/account
account_sid = "AC8a9ba33072b6a05f2b81126e3e6609b7"
auth_token = "f0150d603c1886d93b9d45ff15d84f24"
client = Client(account_sid, auth_token)
call = client.calls.create(
to="+接收者号码",
from_="+你的twilio号码",
url="http://demo.twilio.com/docs/voice.xml",
method="GET",
status_callback="https://www.myapp.com/events",
status_callback_method="POST",
status_callback_event=["initiated", "ringing", "answered", "completed"]
)
print(call.sid)

执行程序后，电话也可以接通，但是里面的人会提示你升级账号。。。。。

总结

好了，到这里我们就可以免费的发送短信了。

通过这个库，我们可以：

（1）对线上或者线下后台跑的程序进行监控，并及时发送短信报警

（2）结合树莓派玩一下，可以实现对超多场景的监测

代码被放在了这里：https://github.com/xiaosimao/wx_code/tree/master/send_sms

有问题的可以在评论中指出，或者直接在后台发消息给我。

欢迎大家关注我。

本书此部分内容属进阶内容，暂不开放。 如需查看更多可以购买书籍查看。 购买地址： https://item.jd.com/26114674847.html https://item.jd.com/26124473455.html 本书由图灵教育-人民邮电出版社出版发行。 作者：崔庆才 视频学习资源：

• 自己动手，丰衣足食！Python3 网络爬虫实战案例
• Python3 爬虫三大案例实战分享

全书预览图：

在前一章中，我们已经成功尝试分析 Ajax 来抓取相关数据，但是并不是所有页面都可以通过分析 Ajax 来完成抓取。比如，淘宝，它的整个页面数据确实也是通过 Ajax 获取的，但是这些 Ajax 接口参数比较复杂，可能会包含加密密钥等，所以如果想自己构造 Ajax 参数，还是比较困难的。对于这种页面，最方便快捷的抓取方法就是通过 Selenium。本节中，我们就用 Selenium 来模拟浏览器操作，抓取淘宝的商品信息，并将结果保存到 MongoDB。

1. 本节目标

本节中，我们要利用 Selenium 抓取淘宝商品并用 pyquery 解析得到商品的图片、名称、价格、购买人数、店铺名称和店铺所在地信息，并将其保存到 MongoDB。

2. 准备工作

本节中，我们首先以 Chrome 为例来讲解 Selenium 的用法。在开始之前，请确保已经正确安装好 Chrome 浏览器并配置好了 ChromeDriver；另外，还需要正确安装 Python 的 Selenium 库；最后，还对接了 PhantomJS 和 Firefox，请确保安装好 PhantomJS 和 Firefox 并配置好了 GeckoDriver。如果环境没有配置好，可参考第 1 章。

3. 接口分析

首先，我们来看下淘宝的接口，看看它比一般 Ajax 多了怎样的内容。

打开淘宝页面，搜索商品，比如 iPad，此时打开开发者工具，截获 Ajax 请求，我们可以发现获取商品列表的接口，如图 7-19 所示。

图 7-19 列表接口

它的链接包含了几个 GET 参数，如果要想构造 Ajax 链接，直接请求再好不过了，它的返回内容是 JSON 格式，如图 7-20 所示。

图 7-20 JSON 数据

但是这个 Ajax 接口包含几个参数，其中_ksTS、rn参数不能直接发现其规律，如果要去探寻它的生成规律，也不是做不到，但这样相对会比较烦琐，所以如果直接用 Selenium 来模拟浏览器的话，就不需要再关注这些接口参数了，只要在浏览器里面可以看到的，都可以爬取。这也是我们选用 Selenium 爬取淘宝的原因。

4. 页面分析

本节的目标是爬取商品信息。图 7-21 是一个商品条目，其中包含商品的基本信息，包括商品图片、名称、价格、购买人数、店铺名称和店铺所在地，我们要做的就是将这些信息都抓取下来。

图 7-21 商品条目

抓取入口就是淘宝的搜索页面，这个链接可以通过直接构造参数访问。例如，如果搜索 iPad，就可以直接访问https://s.taobao.com/search?q=iPad，呈现的就是第一页的搜索结果，如图 7-22 所示。

图 7-22 搜索结果

在页面下方，有一个分页导航，其中既包括前 5 页的链接，也包括下一页的链接，同时还有一个输入任意页码跳转的链接，如图 7-23 所示。

图 7-23 分页导航

这里商品的搜索结果一般最大都为 100 页，要获取每一页的内容，只需要将页码从 1 到 100 顺序遍历即可，页码数是确定的。所以，直接在页面跳转文本框中输入要跳转的页码，然后点击“确定”按钮即可跳转到页码对应的页面。

这里不直接点击“下一页”的原因是：一旦爬取过程中出现异常退出，比如到 50 页退出了，此时点击“下一页”时，就无法快速切换到对应的后续页面了。此外，在爬取过程中，也需要记录当前的页码数，而且一旦点击“下一页”之后页面加载失败，还需要做异常检测，检测当前页面是加载到了第几页。整个流程相对比较复杂，所以这里我们直接用跳转的方式来爬取页面。

当我们成功加载出某一页商品列表时，利用 Selenium 即可获取页面源代码，然后再用相应的解析库解析即可。这里我们选用 pyquery 进行解析。下面我们用代码来实现整个抓取过程。

5. 获取商品列表

首先，需要构造一个抓取的 URL：https://s.taobao.com/search?q=iPad。这个 URL 非常简洁，参数q就是要搜索的关键字。只要改变这个参数，即可获取不同商品的列表。这里我们将商品的关键字定义成一个变量，然后构造出这样的一个 URL。

然后，就需要用 Selenium 进行抓取了。我们实现如下抓取列表页的方法：

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

from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait
from urllib.parse import quote

browser = webdriver.Chrome()
wait = WebDriverWait(browser, 10)
KEYWORD = 'iPad'

def index_page(page):
    """
    抓取索引页
    :param page: 页码
    """
    print('正在爬取第', page, '页')
    try:
        url = 'https://s.taobao.com/search?q=' + quote(KEYWORD)
        browser.get(url)
        if page > 1:
            input = wait.until(
                EC.presence_of_element_located((By.CSS_SELECTOR, '#mainsrp-pager div.form > input')))
            submit = wait.until(
                EC.element_to_be_clickable((By.CSS_SELECTOR, '#mainsrp-pager div.form > span.btn.J_Submit')))
            input.clear()
            input.send_keys(page)
            submit.click()
        wait.until(
            EC.text_to_be_present_in_element((By.CSS_SELECTOR, '#mainsrp-pager li.item.active > span'), str(page)))
        wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, '.m-itemlist .items .item')))
        get_products()
    except TimeoutException:
        index_page(page)

这里首先构造了一个WebDriver对象，使用的浏览器是 Chrome，然后指定一个关键词，如 iPad，接着定义了index_page()方法，用于抓取商品列表页。

在该方法里，我们首先访问了搜索商品的链接，然后判断了当前的页码，如果大于 1，就进行跳页操作，否则等待页面加载完成。

等待加载时，我们使用了WebDriverWait对象，它可以指定等待条件，同时指定一个最长等待时间，这里指定为最长 10 秒。如果在这个时间内成功匹配了等待条件，也就是说页面元素成功加载出来了，就立即返回相应结果并继续向下执行，否则到了最大等待时间还没有加载出来时，就直接抛出超时异常。

比如，我们最终要等待商品信息加载出来，就指定了presence_of_element_located这个条件，然后传入了.m-itemlist .items .item这个选择器，而这个选择器对应的页面内容就是每个商品的信息块，可以到网页里面查看一下。如果加载成功，就会执行后续的get_products()方法，提取商品信息。

关于翻页操作，这里首先获取页码输入框，赋值为input，然后获取“确定”按钮，赋值为submit，分别是图 7-24 中的两个元素。

图 7-24 跳转选项

首先，我们清空了输入框，此时调用clear()方法即可。随后，调用send_keys()方法将页码填充到输入框中，然后点击“确定”按钮即可。

那么，怎样知道有没有跳转到对应的页码呢？我们可以注意到，成功跳转某一页后，页码都会高亮显示，如图 7-25 所示。

图 7-25 页码高亮显示

我们只需要判断当前高亮的页码数是当前的页码数即可，所以这里使用了另一个等待条件text_to_be_present_in_element，它会等待指定的文本出现在某一个节点里面时即返回成功。这里我们将高亮的页码节点对应的 CSS 选择器和当前要跳转的页码通过参数传递给这个等待条件，这样它就会检测当前高亮的页码节点是不是我们传过来的页码数，如果是，就证明页面成功跳转到了这一页，页面跳转成功。

这样刚才实现的index_page()方法就可以传入对应的页码，待加载出对应页码的商品列表后，再去调用get_products()方法进行页面解析。

6. 解析商品列表

接下来，我们就可以实现get_products()方法来解析商品列表了。这里我们直接获取页面源代码，然后用 pyquery 进行解析，实现如下：

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

from pyquery import PyQuery as pq
def get_products():
    """
    提取商品数据
    """
    html = browser.page_source
    doc = pq(html)
    items = doc('#mainsrp-itemlist .items .item').items()
    for item in items:
        product = {
            'image': item.find('.pic .img').attr('data-src'),
            'price': item.find('.price').text(),
            'deal': item.find('.deal-cnt').text(),
            'title': item.find('.title').text(),
            'shop': item.find('.shop').text(),
            'location': item.find('.location').text()
        }
        print(product)
        save_to_mongo(product)

首先，调用page_source属性获取页码的源代码，然后构造了 PyQuery 解析对象，接着提取了商品列表，此时使用的 CSS 选择器是#mainsrp-itemlist .items .item，它会匹配整个页面的每个商品。它的匹配结果是多个，所以这里我们又对它进行了一次遍历，用for循环将每个结果分别进行解析，每次循环把它赋值为item变量，每个item变量都是一个PyQuery对象，然后再调用它的find()方法，传入 CSS 选择器，就可以获取单个商品的特定内容了。

比如，查看一下商品信息的源码，如图 7-26 所示。

图 7-26 商品信息源码

可以发现，它是一个img节点，包含id、class、data-src、alt和src等属性。这里之所以可以看到这张图片，是因为它的src属性被赋值为图片的 URL。把它的src属性提取出来，就可以获取商品的图片了。不过我们还注意data-src属性，它的内容也是图片的 URL，观察后发现此 URL 是图片的完整大图，而src是压缩后的小图，所以这里抓取data-src属性来作为商品的图片。

因此，我们需要先利用find()方法找到图片的这个节点，然后再调用attr()方法获取商品的data-src属性，这样就成功提取了商品图片链接。然后用同样的方法提取商品的价格、成交量、名称、店铺和店铺所在地等信息，接着将所有提取结果赋值为一个字典product，随后调用save_to_mongo()将其保存到 MongoDB 即可。

7. 保存到 MongoDB

接下来，我们将商品信息保存到 MongoDB，实现代码如下：

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

MONGO_URL = 'localhost'
MONGO_DB = 'taobao'
MONGO_COLLECTION = 'products'
client = pymongo.MongoClient(MONGO_URL)
db = client[MONGO_DB]
def save_to_mongo(result):
    """
    保存至MongoDB
    :param result: 结果
    """
    try:
        if db[MONGO_COLLECTION].insert(result):
            print('存储到MongoDB成功')
    except Exception:
        print('存储到MongoDB失败')

这里首先创建了一个 MongoDB 的连接对象，然后指定了数据库，随后指定了 Collection 的名称，接着直接调用insert()方法将数据插入到 MongoDB。此处的result变量就是在get_products()方法里传来的product，包含单个商品的信息。

8. 遍历每页

刚才我们所定义的get_index()方法需要接收参数page，page代表页码。这里我们实现页码遍历即可，代码如下：

1
2
3
4
5
6
7

MAX_PAGE = 100
def main():
    """
    遍历每一页
    """
    for i in range(1, MAX_PAGE + 1):
        index_page(i)

其实现非常简单，只需要调用一个for循环即可。这里定义最大的页码数为 100，range()方法的返回结果就是 1 到 100 的列表，顺序遍历，调用index_page()方法即可。

这样我们的淘宝商品爬虫就完成了，最后调用main()方法即可运行。

9. 运行

运行代码，可以发现首先会弹出一个 Chrome 浏览器，然后会访问淘宝页面，接着控制台便会输出相应的提取结果，如图 7-27 所示。

图 7-27 运行结果

可以发现，这些商品信息的结果都是字典形式，它们被存储到 MongoDB 里面。

再看一下 MongoDB 中的结果，如图 7-28 所示。

图 7-28 保存结果

可以看到，所有的信息都保存到 MongoDB 里了，这说明爬取成功。

10. Chrome Headless 模式

从 Chrome 59 版本开始，已经开始支持 Headless 模式，也就是无界面模式，这样爬取的时候就不会弹出浏览器了。如果要使用此模式，请把 Chrome 升级到 59 版本及以上。启用 Headless 模式的方式如下：

1
2
3

chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--headless')
browser = webdriver.Chrome(chrome_options=chrome_options)

首先，创建ChromeOptions对象，接着添加headless参数，然后在初始化 Chrome 对象的时候通过chrome_options传递这个ChromeOptions对象，这样我们就可以成功启用 Chrome 的 Headless 模式了。

11. 对接 Firefox

要对接 Firefox 浏览器，非常简单，只需要更改一处即可：

1

browser = webdriver.Firefox()

这里更改了browser对象的创建方式，这样爬取的时候就会使用 Firefox 浏览器了。

12. 对接 PhantomJS

如果不想使用 Chrome 的 Headless 模式，还可以使用 PhantomJS（它是一个无界面浏览器）来抓取。抓取时，同样不会弹出窗口，还是只需要将WebDriver的声明修改一下即可：

1

browser = webdriver.PhantomJS()

另外，它还支持命令行配置。比如，可以设置缓存和禁用图片加载的功能，进一步提高爬取效率：

1
2

SERVICE_ARGS = ['--load-images=false', '--disk-cache=true']
browser = webdriver.PhantomJS(service_args=SERVICE_ARGS)

最后，给出本节的代码地址：https://github.com/Python3WebSpider/TaobaoProduct。

本节中，我们用 Selenium 演示了淘宝页面的抓取。利用它，我们不用去分析 Ajax 请求，真正做到可见即可爬。

用Splash做页面抓取时，如果爬取的量非常大，任务非常多，用一个Splash服务来处理的话，未免压力太大了，此时可以考虑搭建一个负载均衡器来把压力分散到各个服务器上。这相当于多台机器多个服务共同参与任务的处理，可以减小单个Splash服务的压力。

1. 配置Splash服务

要搭建Splash负载均衡，首先要有多个Splash服务。假如这里在4台远程主机的8050端口上都开启了Splash服务，它们的服务地址分别为41.159.27.223:8050、41.159.27.221:8050、41.159.27.9:8050和41.159.117.119:8050，这4个服务完全一致，都是通过Docker的Splash镜像开启的。访问其中任何一个服务时，都可以使用Splash服务。

2. 配置负载均衡

接下来，可以选用任意一台带有公网IP的主机来配置负载均衡。首先，在这台主机上装好Nginx，然后修改Nginx的配置文件nginx.conf，添加如下内容：

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

http {
    upstream splash {
        least_conn;
        server 41.159.27.223:8050;
        server 41.159.27.221:8050;
        server 41.159.27.9:8050;
        server 41.159.117.119:8050;
    }
    server {
        listen 8050;
        location / {
            proxy_pass http://splash;
        }
    }
}

这样我们通过upstream字段定义了一个名字叫作splash的服务集群配置。其中least_conn代表最少链接负载均衡，它适合处理请求处理时间长短不一造成服务器过载的情况。

当然，我们也可以不指定配置，具体如下：

1
2
3
4
5
6

upstream splash {
    server 41.159.27.223:8050;
    server 41.159.27.221:8050;
    server 41.159.27.9:8050;
    server 41.159.117.119:8050;
}

这样默认以轮询策略实现负载均衡，每个服务器的压力相同。此策略适合服务器配置相当、无状态且短平快的服务使用。

另外，我们还可以指定权重，配置如下：

1
2
3
4
5
6

upstream splash {
    server 41.159.27.223:8050 weight=4;
    server 41.159.27.221:8050 weight=2;
    server 41.159.27.9:8050 weight=2;
    server 41.159.117.119:8050 weight=1;
}

这里weight参数指定各个服务的权重，权重越高，分配到处理的请求越多。假如不同的服务器配置差别比较大的话，可以使用此种配置。

最后，还有一种IP散列负载均衡，配置如下：

1
2
3
4
5
6
7

upstream splash {
    ip_hash;
    server 41.159.27.223:8050;
    server 41.159.27.221:8050;
    server 41.159.27.9:8050;
    server 41.159.117.119:8050;
}

服务器根据请求客户端的IP地址进行散列计算，确保使用同一个服务器响应请求，这种策略适合有状态的服务，比如用户登录后访问某个页面的情形。对于Splash来说，不需要应用此设置。

我们可以根据不同的情形选用不同的配置，配置完成后重启一下Nginx服务：

1

sudo nginx -s reload

这样直接访问Nginx所在服务器的8050端口，即可实现负载均衡了。

3. 配置认证

现在Splash是可以公开访问的，如果不想让其公开访问，还可以配置认证，这仍然借助于Nginx。可以在server的location字段中添加auth_basic和auth_basic_user_file字段，具体配置如下：

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

http {
    upstream splash {
        least_conn;
        server 41.159.27.223:8050;
        server 41.159.27.221:8050;
        server 41.159.27.9:8050;
        server 41.159.117.119:8050;
    }
    server {
        listen 8050;
        location / {
            proxy_pass http://splash;
            auth_basic "Restricted";
            auth_basic_user_file /etc/nginx/conf.d/.htpasswd;
        }
    }
}

这里使用的用户名和密码配置放置在/etc/nginx/conf.d目录下，我们需要使用htpasswd命令创建。例如，创建一个用户名为admin的文件，相关命令如下：

1

htpasswd -c .htpasswd admin

接下来就会提示我们输入密码，输入两次之后，就会生成密码文件，其内容如下：

1
2

cat .htpasswd 
admin:5ZBxQr0rCqwbc

配置完成后，重启一下Nginx服务：

1

sudo nginx -s reload

这样访问认证就成功配置好了。

4. 测试

最后，我们可以用代码来测试一下负载均衡的配置，看看到底是不是每次请求会切换IP。利用http://httpbin.org/get测试即可，实现代码如下：

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

import requests
from urllib.parse import quote
import re

lua = '''
function main(splash, args)
  local treat = require("treat")
  local response = splash:http_get("http://httpbin.org/get")
  return treat.as_string(response.body)
end
'''

url = 'http://splash:8050/execute?lua_source=' + quote(lua)
response = requests.get(url, auth=('admin', 'admin'))
ip = re.search('(\d+\.\d+\.\d+\.\d+)', response.text).group(1)
print(ip)

这里URL中的splash字符串请自行替换成自己的Nginx服务器IP。这里我修改了Hosts，设置了splash为Nginx服务器IP。

多次运行代码之后，可以发现每次请求的IP都会变化，比如第一次的结果：

1

41.159.27.223

第二次的结果：

1

41.159.27.9

这就说明负载均衡已经成功实现了。

本节中，我们成功实现了负载均衡的配置。配置负载均衡后，可以多个Splash服务共同合作，减轻单个服务的负载，这还是比较有用的。

Splash 是一个 JavaScript 渲染服务，是一个带有 HTTP API 的轻量级浏览器，同时它对接了 Python 中的 Twisted 和 QT 库。利用它，我们同样可以实现动态渲染页面的抓取。

1. 功能介绍

利用 Splash，我们可以实现如下功能：

• 异步方式处理多个网页渲染过程；
• 获取渲染后的页面的源代码或截图；
• 通过关闭图片渲染或者使用 Adblock 规则来加快页面渲染速度；
• 可执行特定的 JavaScript 脚本；
• 可通过 Lua 脚本来控制页面渲染过程；
• 获取渲染的详细过程并通过 HAR（HTTP Archive）格式呈现。

接下来，我们来了解一下它的具体用法。

2. 准备工作

在开始之前，请确保已经正确安装好了 Splash 并可以正常运行服务。如果没有安装，可以参考第 1 章。

3. 实例引入

首先，通过 Splash 提供的 Web 页面来测试其渲染过程。例如，我们在本机 8050 端口上运行了 Splash 服务，打开http://localhost:8050/即可看到其 Web 页面，如图 7-6 所示。

图 7-6 Web 页面

在图 7-6 右侧，呈现的是一个渲染示例。可以看到，上方有一个输入框，默认是http://google.com，这里换成百度测试一下，将内容更改为https://www.baidu.com，然后点击 Render me 按钮开始渲染，结果如图 7-7 所示。

图 7-7 运行结果

可以看到，网页的返回结果呈现了渲染截图、HAR 加载统计数据、网页的源代码。

通过 HAR 的结果可以看到，Splash 执行了整个网页的渲染过程，包括 CSS、JavaScript 的加载等过程，呈现的页面和我们在浏览器中得到的结果完全一致。

那么，这个过程由什么来控制呢？重新返回首页，可以看到实际上是有一段脚本，内容如下：

1
2
3
4
5
6
7
8
9

function main(splash, args)
  assert(splash:go(args.url))
  assert(splash:wait(0.5))
  return {
    html = splash:html(),
    png = splash:png(),
    har = splash:har(),
  }
end

这个脚本实际上是用 Lua 语言写的脚本。即使不懂这个语言的语法，但从脚本的表面意思，我们也可以大致了解到它首先调用go()方法去加载页面，然后调用wait()方法等待了一定时间，最后返回了页面的源码、截图和 HAR 信息。

到这里，我们大体了解了 Splash 是通过 Lua 脚本来控制了页面的加载过程的，加载过程完全模拟浏览器，最后可返回各种格式的结果，如网页源码和截图等。

接下来，我们就来了解 Lua 脚本的写法以及相关 API 的用法。

4. Splash Lua 脚本

Splash 可以通过 Lua 脚本执行一系列渲染操作，这样我们就可以用 Splash 来模拟类似 Chrome、PhantomJS 的操作了。

首先，我们来了解一下 Splash Lua 脚本的入口和执行方式。

入口及返回值

首先，来看一个基本实例：

1
2
3
4
5
6

function main(splash, args)
  splash:go("http://www.baidu.com")
  splash:wait(0.5)
  local title = splash:evaljs("document.title")
  return {title=title}
end

我们将代码粘贴到刚才打开的http://localhost:8050/的代码编辑区域，然后点击 Render me!按钮来测试一下。

我们看到它返回了网页的标题，如图 7-8 所示。这里我们通过evaljs()方法传入 JavaScript 脚本，而document.title的执行结果就是返回网页标题，执行完毕后将其赋值给一个title变量，随后将其返回。

图 7-8 运行结果

注意，我们在这里定义的方法名称叫作main()。这个名称必须是固定的，Splash 会默认调用这个方法。

该方法的返回值既可以是字典形式，也可以是字符串形式，最后都会转化为 Splash HTTP Response，例如：

1
2
3

function main(splash)
    return {hello="world!"}
end

返回了一个字典形式的内容。例如：

1
2
3

function main(splash)
    return 'hello'
end

返回了一个字符串形式的内容。

异步处理

Splash 支持异步处理，但是这里并没有显式指明回调方法，其回调的跳转是在 Splash 内部完成的。示例如下：

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

function main(splash, args)
  local example_urls = {"www.baidu.com", "www.taobao.com", "www.zhihu.com"}
  local urls = args.urls or example_urls
  local results = {}
  for index, url in ipairs(urls) do
    local ok, reason = splash:go("http://" .. url)
    if ok then
      splash:wait(2)
      results[url] = splash:png()
    end
  end
  return results
end

运行结果是 3 个站点的截图，如图 7-9 所示。

图 7-9 运行结果

在脚本内调用的wait()方法类似于 Python 中的sleep()，其参数为等待的秒数。当 Splash 执行到此方法时，它会转而去处理其他任务，然后在指定的时间过后再回来继续处理。

这里值得注意的是，Lua 脚本中的字符串拼接和 Python 不同，它使用的是..操作符，而不是+。如果有必要，可以简单了解一下 Lua 脚本的语法，详见http://www.runoob.com/lua/lua-basic-syntax.html。

另外，这里做了加载时的异常检测。go()方法会返回加载页面的结果状态，如果页面出现 4xx 或 5xx 状态码，ok变量就为空，就不会返回加载后的图片。

5. Splash 对象属性

我们注意到，前面例子中main()方法的第一个参数是splash，这个对象非常重要，它类似于 Selenium 中的WebDriver对象，我们可以调用它的一些属性和方法来控制加载过程。接下来，先看下它的属性。

args

该属性可以获取加载时配置的参数，比如 URL，如果为 GET 请求，它还可以获取 GET 请求参数；如果为 POST 请求，它可以获取表单提交的数据。Splash 也支持使用第二个参数直接作为args，例如：

1
2
3

function main(splash, args)
    local url = args.url
end

这里第二个参数args就相当于splash.args属性，以上代码等价于：

1
2
3

function main(splash)
    local url = splash.args.url
end

js_enabled

这个属性是 Splash 的 JavaScript 执行开关，可以将其配置为true或false来控制是否执行 JavaScript 代码，默认为true。例如，这里禁止执行 JavaScript 代码：

1
2
3
4
5
6

function main(splash, args)
  splash:go("https://www.baidu.com")
  splash.js_enabled = false
  local title = splash:evaljs("document.title")
  return {title=title}
end

接着我们重新调用了evaljs()方法执行 JavaScript 代码，此时运行结果就会抛出异常：

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

{
    "error": 400,
    "type": "ScriptError",
    "info": {
        "type": "JS_ERROR",
        "js_error_message": null,
        "source": "[string \"function main(splash, args)\r...\"]",
        "message": "[string \"function main(splash, args)\r...\"]:4: unknown JS error: None",
        "line_number": 4,
        "error": "unknown JS error: None",
        "splash_method": "evaljs"
    },
    "description": "Error happened while executing Lua script"
}

不过一般来说，不用设置此属性，默认开启即可。

resource_timeout

此属性可以设置加载的超时时间，单位是秒。如果设置为 0 或nil（类似 Python 中的None），代表不检测超时。示例如下：

1
2
3
4
5

function main(splash)
    splash.resource_timeout = 0.1
    assert(splash:go('https://www.taobao.com'))
    return splash:png()
end

例如，这里将超时时间设置为 0.1 秒。如果在 0.1 秒之内没有得到响应，就会抛出异常，错误如下：

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

{
    "error": 400,
    "type": "ScriptError",
    "info": {
        "error": "network5",
        "type": "LUA_ERROR",
        "line_number": 3,
        "source": "[string \"function main(splash)\r...\"]",
        "message": "Lua error: [string \"function main(splash)\r...\"]:3: network5"
    },
    "description": "Error happened while executing Lua script"
}

此属性适合在网页加载速度较慢的情况下设置。如果超过了某个时间无响应，则直接抛出异常并忽略即可。

images_enabled

此属性可以设置图片是否加载，默认情况下是加载的。禁用该属性后，可以节省网络流量并提高网页加载速度。但是需要注意的是，禁用图片加载可能会影响 JavaScript 渲染。因为禁用图片之后，它的外层 DOM 节点的高度会受影响，进而影响 DOM 节点的位置。因此，如果 JavaScript 对图片节点有操作的话，其执行就会受到影响。

另外值得注意的是，Splash 使用了缓存。如果一开始加载出来了网页图片，然后禁用了图片加载，再重新加载页面，之前加载好的图片可能还会显示出来，这时直接重启 Splash 即可。

禁用图片加载的示例如下：

1
2
3
4
5

function main(splash, args)
  splash.images_enabled = false
  assert(splash:go('https://www.jd.com'))
  return {png=splash:png()}
end

这样返回的页面截图就不会带有任何图片，加载速度也会快很多。

plugins_enabled

此属性可以控制浏览器插件（如 Flash 插件）是否开启。默认情况下，此属性是false，表示不开启。可以使用如下代码控制其开启和关闭：

1

splash.plugins_enabled = true/false

scroll_position

通过设置此属性，我们可以控制页面上下或左右滚动。这是一个比较常用的属性，示例如下：

1
2
3
4
5

function main(splash, args)
  assert(splash:go('https://www.taobao.com'))
  splash.scroll_position = {y=400}
  return {png=splash:png()}
end

这样我们就可以控制页面向下滚动 400 像素值，结果如图 7-10 所示。

图 7-10 运行结果

如果要让页面左右滚动，可以传入x参数，代码如下：

1

splash.scroll_position = {x=100, y=200}

6. Splash 对象的方法

除了前面介绍的属性外，Splash 对象还有如下方法。

go()

该方法用来请求某个链接，而且它可以模拟 GET 和 POST 请求，同时支持传入请求头、表单等数据，其用法如下：

1

ok, reason = splash:go{url, baseurl=nil, headers=nil, http_method="GET", body=nil, formdata=nil}

其参数说明如下。

• url：请求的 URL。
• baseurl：可选参数，默认为空，表示资源加载相对路径。
• headers：可选参数，默认为空，表示请求头。
• http_method：可选参数，默认为GET，同时支持POST。
• body：可选参数，默认为空，发 POST 请求时的表单数据，使用的Content-type为application/json。
• formdata：可选参数，默认为空，POST 的时候的表单数据，使用的Content-type为application/x-www-form-urlencoded。

该方法的返回结果是结果ok和原因reason的组合，如果ok为空，代表网页加载出现了错误，此时reason变量中包含了错误的原因，否则证明页面加载成功。示例如下：

1
2
3
4
5
6

function main(splash, args)
  local ok, reason = splash:go{"http://httpbin.org/post", http_method="POST", body="name=Germey"}
  if ok then
        return splash:html()
  end
end

这里我们模拟了一个 POST 请求，并传入了 POST 的表单数据，如果成功，则返回页面的源代码。

运行结果如下：

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

<html><head></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">{
  "args": {},
  "data": "",
  "files": {},
  "form": {
    "name": "Germey"
  },
  "headers": {
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Encoding": "gzip, deflate",
    "Accept-Language": "en,*",
    "Connection": "close",
    "Content-Length": "11",
    "Content-Type": "application/x-www-form-urlencoded",
    "Host": "httpbin.org",
    "Origin": "null",
    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/602.1 (KHTML, like Gecko) splash Version/9.0 Safari/602.1"
  },
  "json": null,
  "origin": "60.207.237.85",
  "url": "http://httpbin.org/post"
}
</pre></body></html>

可以看到，我们成功实现了 POST 请求并发送了表单数据。

wait()

此方法可以控制页面的等待时间，使用方法如下：

1

ok, reason = splash:wait{time, cancel_on_redirect=false, cancel_on_error=true}

参数说明如下。

• time：等待的秒数。
• cancel_on_redirect：可选参数，默认为false，表示如果发生了重定向就停止等待，并返回重定向结果。
• cancel_on_error：可选参数，默认为false，表示如果发生了加载错误，就停止等待。

返回结果同样是结果ok和原因reason的组合。

我们用一个实例感受一下：

1
2
3
4
5

function main(splash)
    splash:go("https://www.taobao.com")
    splash:wait(2)
    return {html=splash:html()}
end

这可以实现访问淘宝并等待 2 秒，随后返回页面源代码的功能。

jsfunc()

此方法可以直接调用 JavaScript 定义的方法，但是所调用的方法需要用双中括号包围，这相当于实现了 JavaScript 方法到 Lua 脚本的转换。示例如下：

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

function main(splash, args)
  local get_div_count = splash:jsfunc([[
  function () {
    var body = document.body;
    var divs = body.getElementsByTagName('div');
    return divs.length;
  }
  ]])
  splash:go("https://www.baidu.com")
  return ("There are %s DIVs"):format(
    get_div_count())
end

运行结果如下：

1

There are 21 DIVs

首先，我们声明了一个 JavaScript 定义的方法，然后在页面加载成功后调用了此方法计算出了页面中div节点的个数。

关于 JavaScript 到 Lua 脚本的更多转换细节，可以参考官方文档：https://splash.readthedocs.io/en/stable/scripting-ref.html#splash-jsfunc。

evaljs()

此方法可以执行 JavaScript 代码并返回最后一条 JavaScript 语句的返回结果，使用方法如下：

1

result = splash:evaljs(js)

比如，可以用下面的代码来获取页面标题：

1

local title = splash:evaljs("document.title")

runjs()

此方法可以执行 JavaScript 代码，它与evaljs()的功能类似，但是更偏向于执行某些动作或声明某些方法。例如：

1
2
3
4
5
6

function main(splash, args)
  splash:go("https://www.baidu.com")
  splash:runjs("foo = function() { return 'bar' }")
  local result = splash:evaljs("foo()")
  return result
end

这里我们用runjs()先声明了一个 JavaScript 定义的方法，然后通过evaljs()来调用得到的结果。

运行结果如下：

1

bar

autoload()

此方法可以设置每个页面访问时自动加载的对象，使用方法如下：

1

ok, reason = splash:autoload{source_or_url, source=nil, url=nil}

参数说明如下。

• source_or_url：JavaScript 代码或者 JavaScript 库链接。
• source：JavaScript 代码。
• url：JavaScript 库链接

但是此方法只负责加载 JavaScript 代码或库，不执行任何操作。如果要执行操作，可以调用evaljs()或runjs()方法。示例如下：

1
2
3
4
5
6
7
8
9

function main(splash, args)
  splash:autoload([[
    function get_document_title(){
      return document.title;
    }
  ]])
  splash:go("https://www.baidu.com")
  return splash:evaljs("get_document_title()")
end

这里我们调用autoload()方法声明了一个 JavaScript 方法，然后通过evaljs()方法来执行此 JavaScript 方法。

运行结果如下：

1

百度一下，你就知道

另外，我们也可以使用autoload()方法加载某些方法库，如 jQuery，示例如下：

1
2
3
4
5
6

function main(splash, args)
  assert(splash:autoload("https://code.jquery.com/jquery-2.1.3.min.js"))
  assert(splash:go("https://www.taobao.com"))
  local version = splash:evaljs("$.fn.jquery")
  return 'JQuery version: ' .. version
end

运行结果如下：

1

JQuery version: 2.1.3

call_later()

此方法可以通过设置定时任务和延迟时间来实现任务延时执行，并且可以在执行前通过cancel()方法重新执行定时任务。示例如下：

1
2
3
4
5
6
7
8
9
10
11

function main(splash, args)
  local snapshots = {}
  local timer = splash:call_later(function()
    snapshots["a"] = splash:png()
    splash:wait(1.0)
    snapshots["b"] = splash:png()
  end, 0.2)
  splash:go("https://www.taobao.com")
  splash:wait(3.0)
  return snapshots
end

这里我们设置了一个定时任务，0.2 秒的时候获取网页截图，然后等待 1 秒，1.2 秒时再次获取网页截图，访问的页面是淘宝，最后将截图结果返回。运行结果如图 7-11 所示。

图 7-11 运行结果

可以发现，第一次截图时网页还没有加载出来，截图为空，第二次网页便加载成功了。

http_get()

此方法可以模拟发送 HTTP 的 GET 请求，使用方法如下：

1

response = splash:http_get{url, headers=nil, follow_redirects=true}

参数说明如下。

• url：请求 URL。
• headers：可选参数，默认为空，请求头。
• follow_redirects：可选参数，表示是否启动自动重定向，默认为true。

示例如下：

1
2
3
4
5
6
7
8
9

function main(splash, args)
  local treat = require("treat")
  local response = splash:http_get("http://httpbin.org/get")
    return {
    html=treat.as_string(response.body),
    url=response.url,
    status=response.status
    }
end

运行结果如下：

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

Splash Response: Object
html: String (length 355)
{
  "args": {},
  "headers": {
    "Accept-Encoding": "gzip, deflate",
    "Accept-Language": "en,*",
    "Connection": "close",
    "Host": "httpbin.org",
    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/602.1 (KHTML, like Gecko) splash Version/9.0 Safari/602.1"
  },
  "origin": "60.207.237.85",
  "url": "http://httpbin.org/get"
}
status: 200
url: "http://httpbin.org/get"

http_post()

和http_get()方法类似，此方法用来模拟发送 POST 请求，不过多了一个参数body，使用方法如下：

1

response = splash:http_post{url, headers=nil, follow_redirects=true, body=nil}

参数说明如下。

• url：请求 URL。
• headers：可选参数，默认为空，请求头。
• follow_redirects：可选参数，表示是否启动自动重定向，默认为true。
• body：可选参数，即表单数据，默认为空。

我们用实例感受一下：

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

function main(splash, args)
  local treat = require("treat")
  local json = require("json")
  local response = splash:http_post{"http://httpbin.org/post",
      body=json.encode({name="Germey"}),
      headers={["content-type"]="application/json"}
    }
    return {
    html=treat.as_string(response.body),
    url=response.url,
    status=response.status
    }
end

运行结果如下：

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

Splash Response: Object
html: String (length 533)
{
  "args": {},
  "data": "{\"name\": \"Germey\"}",
  "files": {},
  "form": {},
  "headers": {
    "Accept-Encoding": "gzip, deflate",
    "Accept-Language": "en,*",
    "Connection": "close",
    "Content-Length": "18",
    "Content-Type": "application/json",
    "Host": "httpbin.org",
    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/602.1 (KHTML, like Gecko) splash Version/9.0 Safari/602.1"
  },
  "json": {
    "name": "Germey"
  },
  "origin": "60.207.237.85",
  "url": "http://httpbin.org/post"
}
status: 200
url: "http://httpbin.org/post"

可以看到，这里我们成功模拟提交了 POST 请求并发送了表单数据。

set_content()

此方法用来设置页面的内容，示例如下：

1
2
3
4

function main(splash)
    assert(splash:set_content("<html><body><h1>hello</h1></body></html>"))
    return splash:png()
end

运行结果如图 7-12 所示。

图 7-12 运行结果

html()

此方法用来获取网页的源代码，它是非常简单又常用的方法。示例如下：

1
2
3
4

function main(splash, args)
  splash:go("https://httpbin.org/get")
  return splash:html()
end

运行结果如下：

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

<html><head></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">{
  "args": {},
  "headers": {
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Encoding": "gzip, deflate",
    "Accept-Language": "en,*",
    "Connection": "close",
    "Host": "httpbin.org",
    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/602.1 (KHTML, like Gecko) splash Version/9.0 Safari/602.1"
  },
  "origin": "60.207.237.85",
  "url": "https://httpbin.org/get"
}
</pre></body></html>

png()

此方法用来获取 PNG 格式的网页截图，示例如下：

1
2
3
4

function main(splash, args)
  splash:go("https://www.taobao.com")
  return splash:png()
end

jpeg()

此方法用来获取 JPEG 格式的网页截图，示例如下：

1
2
3
4

function main(splash, args)
  splash:go("https://www.taobao.com")
  return splash:jpeg()
end

har()

此方法用来获取页面加载过程描述，示例如下：

1
2
3
4

function main(splash, args)
  splash:go("https://www.baidu.com")
  return splash:har()
end

运行结果如图 7-13 所示，其中显示了页面加载过程中每个请求记录的详情。

图 7-13 运行结果

url()

此方法可以获取当前正在访问的 URL，示例如下：

1
2
3
4

function main(splash, args)
  splash:go("https://www.baidu.com")
  return splash:url()
end

运行结果如下：

1

https://www.baidu.com/

get_cookies()

此方法可以获取当前页面的 Cookies，示例如下：

1
2
3
4

function main(splash, args)
  splash:go("https://www.baidu.com")
  return splash:get_cookies()
end

运行结果如下：

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

Splash Response: Array[2]
0: Object
domain: ".baidu.com"
expires: "2085-08-21T20:13:23Z"
httpOnly: false
name: "BAIDUID"
path: "/"
secure: false
value: "C1263A470B02DEF45593B062451C9722:FG=1"
1: Object
domain: ".baidu.com"
expires: "2085-08-21T20:13:23Z"
httpOnly: false
name: "BIDUPSID"
path: "/"
secure: false
value: "C1263A470B02DEF45593B062451C9722"

add_cookie()

此方法可以为当前页面添加 Cookie，用法如下：

1

cookies = splash:add_cookie{name, value, path=nil, domain=nil, expires=nil, httpOnly=nil, secure=nil}

该方法的各个参数代表 Cookie 的各个属性。

示例如下：

1
2
3
4
5

function main(splash)
    splash:add_cookie{"sessionid", "237465ghgfsd", "/", domain="http://example.com"}
    splash:go("http://example.com/")
    return splash:html()
end

clear_cookies()

此方法可以清除所有的 Cookies，示例如下：

1
2
3
4
5

function main(splash)
    splash:go("https://www.baidu.com/")
    splash:clear_cookies()
    return splash:get_cookies()
end

这里我们清除了所有的 Cookies，然后调用get_cookies()将结果返回。

运行结果如下：

1

Splash Response: Array[0]

可以看到，Cookies 被全部清空，没有任何结果。

get_viewport_size()

此方法可以获取当前浏览器页面的大小，即宽高，示例如下：

1
2
3
4

function main(splash)
    splash:go("https://www.baidu.com/")
    return splash:get_viewport_size()
end

运行结果如下：

1
2
3

Splash Response: Array[2]
0: 1024
1: 768

set_viewport_size()

此方法可以设置当前浏览器页面的大小，即宽高，用法如下：

1

splash:set_viewport_size(width, height)

例如，这里访问一个宽度自适应的页面：

1
2
3
4
5

function main(splash)
    splash:set_viewport_size(400, 700)
    assert(splash:go("http://cuiqingcai.com"))
    return splash:png()
end

运行结果如图 7-14 所示。

图 7-14 运行结果

set_viewport_full()

此方法可以设置浏览器全屏显示，示例如下：

1
2
3
4
5

function main(splash)
    splash:set_viewport_full()
    assert(splash:go("http://cuiqingcai.com"))
    return splash:png()
end

set_user_agent()

此方法可以设置浏览器的User-Agent，示例如下：

1
2
3
4
5

function main(splash)
  splash:set_user_agent('Splash')
  splash:go("http://httpbin.org/get")
  return splash:html()
end

这里我们将浏览器的User-Agent设置为Splash，运行结果如下：

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

<html><head></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">{
  "args": {},
  "headers": {
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Encoding": "gzip, deflate",
    "Accept-Language": "en,*",
    "Connection": "close",
    "Host": "httpbin.org",
    "User-Agent": "Splash"
  },
  "origin": "60.207.237.85",
  "url": "http://httpbin.org/get"
}
</pre></body></html>

可以看到，此处User-Agent被成功设置。

set_custom_headers()

此方法可以设置请求头，示例如下：

1
2
3
4
5
6
7
8

function main(splash)
  splash:set_custom_headers({
     ["User-Agent"] = "Splash",
     ["Site"] = "Splash",
  })
  splash:go("http://httpbin.org/get")
  return splash:html()
end

这里我们设置了请求头中的User-Agent和Site属性，运行结果如下：

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

<html><head></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">{
  "args": {},
  "headers": {
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Encoding": "gzip, deflate",
    "Accept-Language": "en,*",
    "Connection": "close",
    "Host": "httpbin.org",
    "Site": "Splash",
    "User-Agent": "Splash"
  },
  "origin": "60.207.237.85",
  "url": "http://httpbin.org/get"
}
</pre></body></html>

select()

该方法可以选中符合条件的第一个节点，如果有多个节点符合条件，则只会返回一个，其参数是 CSS 选择器。示例如下：

1
2
3
4
5
6
7

function main(splash)
  splash:go("https://www.baidu.com/")
  input = splash:select("#kw")
  input:send_text('Splash')
  splash:wait(3)
  return splash:png()
end

这里我们首先访问了百度，然后选中了搜索框，随后调用了send_text()方法填写了文本，然后返回网页截图。

结果如图 7-15 所示，可以看到，我们成功填写了输入框。

图 7-15 运行结果

select_all()

此方法可以选中所有符合条件的节点，其参数是 CSS 选择器。示例如下：

1
2
3
4
5
6
7
8
9
10
11

function main(splash)
  local treat = require('treat')
  assert(splash:go("http://quotes.toscrape.com/"))
  assert(splash:wait(0.5))
  local texts = splash:select_all('.quote .text')
  local results = {}
  for index, text in ipairs(texts) do
    results[index] = text.node.innerHTML
  end
  return treat.as_array(results)
end

这里我们通过 CSS 选择器选中了节点的正文内容，随后遍历了所有节点，将其中的文本获取下来。

运行结果如下：

1
2
3
4
5
6
7
8
9
10
11

Splash Response: Array[10]
0: "“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.”"
1: "“It is our choices, Harry, that show what we truly are, far more than our abilities.”"
2: “There are only two ways to live your life. One is as though nothing is a miracle. The other is as though everything is a miracle.”
3: "“The person, be it gentleman or lady, who has not pleasure in a good novel, must be intolerably stupid.”"
4: "“Imperfection is beauty, madness is genius and it's better to be absolutely ridiculous than absolutely boring.”"
5: "“Try not to become a man of success. Rather become a man of value.”"
6: "“It is better to be hated for what you are than to be loved for what you are not.”"
7: "“I have not failed. I've just found 10,000 ways that won't work.”"
8: "“A woman is like a tea bag; you never know how strong it is until it's in hot water.”"
9: "“A day without sunshine is like, you know, night.”"

可以发现，我们成功地将 10 个节点的正文内容获取了下来。

mouse_click()

此方法可以模拟鼠标点击操作，传入的参数为坐标值x和y。此外，也可以直接选中某个节点，然后调用此方法，示例如下：

1
2
3
4
5
6
7
8
9

function main(splash)
  splash:go("https://www.baidu.com/")
  input = splash:select("#kw")
  input:send_text('Splash')
  submit = splash:select('#su')
  submit:mouse_click()
  splash:wait(3)
  return splash:png()
end

这里我们首先选中页面的输入框，输入了文本，然后选中“提交”按钮，调用了mouse_click()方法提交查询，然后页面等待三秒，返回截图，结果如图 7-16 所示。

图 7-16 运行结果

可以看到，这里我们成功获取了查询后的页面内容，模拟了百度搜索操作。

前面介绍了 Splash 的常用 API 操作，还有一些 API 在这不再一一介绍，更加详细和权威的说明可以参见官方文档https://splash.readthedocs.io/en/stable/scripting-ref.html，此页面介绍了 Splash 对象的所有 API 操作。另外，还有针对页面元素的 API 操作，链接为https://splash.readthedocs.io/en/stable/scripting-element-object.html。

7. Splash API 调用

前面说明了 Splash Lua 脚本的用法，但这些脚本是在 Splash 页面中测试运行的，如何才能利用 Splash 渲染页面呢？怎样才能和 Python 程序结合使用并抓取 JavaScript 渲染的页面呢？

其实 Splash 给我们提供了一些 HTTP API 接口，我们只需要请求这些接口并传递相应的参数即可，下面简要介绍这些接口。

render.html

此接口用于获取 JavaScript 渲染的页面的 HTML 代码，接口地址就是 Splash 的运行地址加此接口名称，例如http://localhost:8050/render.html。可以用curl来测试一下：

1

curl http://localhost:8050/render.html?url=https://www.baidu.com

我们给此接口传递了一个url参数来指定渲染的 URL，返回结果即页面渲染后的源代码。

如果用 Python 实现的话，代码如下：

1
2
3
4

import requests
url = 'http://localhost:8050/render.html?url=https://www.baidu.com'
response = requests.get(url)
print(response.text)

这样就可以成功输出百度页面渲染后的源代码了。

另外，此接口还可以指定其他参数，比如通过wait指定等待秒数。如果要确保页面完全加载出来，可以增加等待时间，例如：

1
2
3
4

import requests
url = 'http://localhost:8050/render.html?url=https://www.taobao.com&wait=5'
response = requests.get(url)
print(response.text)

此时得到响应的时间就会相应变长，比如这里会等待 5 秒多钟才能获取淘宝页面的源代码。

另外，此接口还支持代理设置、图片加载设置、Headers 设置、请求方法设置，具体的用法可以参见官方文档https://splash.readthedocs.io/en/stable/api.html#render-html。

render.png

此接口可以获取网页截图，其参数比 render.html 多了几个，比如通过width和height来控制宽高，它返回的是 PNG 格式的图片二进制数据。示例如下：

1

curl http://localhost:8050/render.png?url=https://www.taobao.com&wait=5&width=1000&height=700

这里我们传入了width和height来设置页面大小为 1000×700 像素。

如果用 Python 实现，可以将返回的二进制数据保存为 PNG 格式的图片，具体如下：

1
2
3
4
5
6

import requests

url = 'http://localhost:8050/render.png?url=https://www.jd.com&wait=5&width=1000&height=700'
response = requests.get(url)
with open('taobao.png', 'wb') as f:
    f.write(response.content)

得到的图片如图 7-17 所示。

图 7-17 运行结果

这样我们就成功获取了京东首页渲染完成后的页面截图，详细的参数设置可以参考官网文档https://splash.readthedocs.io/en/stable/api.html#render-png。

render.jpeg

此接口和 render.png 类似，不过它返回的是 JPEG 格式的图片二进制数据。

另外，此接口比 render.png 多了参数quality，它用来设置图片质量。

render.har

此接口用于获取页面加载的 HAR 数据，示例如下：

1

curl http://localhost:8050/render.har?url=https://www.jd.com&wait=5

它的返回结果（如图 7-18 所示）非常多，是一个 JSON 格式的数据，其中包含页面加载过程中的 HAR 数据。

图 7-18 运行结果

render.json

此接口包含了前面接口的所有功能，返回结果是 JSON 格式，示例如下：

1

curl http://localhost:8050/render.json?url=https://httpbin.org

结果如下：

1

{"title": "httpbin(1): HTTP Client Testing Service", "url": "https://httpbin.org/", "requestedUrl": "https://httpbin.org/", "geometry": [0, 0, 1024, 768]}

可以看到，这里以 JSON 形式返回了相应的请求数据。

我们可以通过传入不同参数控制其返回结果。比如，传入html=1，返回结果即会增加源代码数据；传入png=1，返回结果即会增加页面 PNG 截图数据；传入har=1，则会获得页面 HAR 数据。例如：

1

curl http://localhost:8050/render.json?url=https://httpbin.org&html=1&har=1

这样返回的 JSON 结果会包含网页源代码和 HAR 数据。

此外还有更多参数设置，具体可以参考官方文档：https://splash.readthedocs.io/en/stable/api.html#render-json。

execute

此接口才是最为强大的接口。前面说了很多 Splash Lua 脚本的操作，用此接口便可实现与 Lua 脚本的对接。

前面的 render.html 和 render.png 等接口对于一般的 JavaScript 渲染页面是足够了，但是如果要实现一些交互操作的话，它们还是无能为力，这里就需要使用 execute 接口了。

我们先实现一个最简单的脚本，直接返回数据：

1
2
3

function main(splash)
    return 'hello'
end

然后将此脚本转化为 URL 编码后的字符串，拼接到 execute 接口后面，示例如下：

1

curl http://localhost:8050/execute?lua_source=function+main%28splash%29%0D%0A++return+%27hello%27%0D%0Aend

运行结果如下：

1

hello

这里我们通过lua_source参数传递了转码后的 Lua 脚本，通过 execute 接口获取了最终脚本的执行结果。

这里我们更加关心的肯定是如何用 Python 来实现，上例用 Python 实现的话，代码如下：

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

import requests
from urllib.parse import quote

lua = '''
function main(splash)
    return 'hello'
end
'''

url = 'http://localhost:8050/execute?lua_source=' + quote(lua)
response = requests.get(url)
print(response.text)

运行结果如下：

1

hello

这里我们用 Python 中的三引号将 Lua 脚本包括起来，然后用 urllib.parse 模块里的quote()方法将脚本进行 URL 转码，随后构造了 Splash 请求 URL，将其作为lua_source参数传递，这样运行结果就会显示 Lua 脚本执行后的结果。

我们再通过实例看一下：

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

import requests
from urllib.parse import quote

lua = '''
function main(splash, args)
  local treat = require("treat")
  local response = splash:http_get("http://httpbin.org/get")
    return {
    html=treat.as_string(response.body),
    url=response.url,
    status=response.status
    }
end
'''

url = 'http://localhost:8050/execute?lua_source=' + quote(lua)
response = requests.get(url)
print(response.text)

运行结果如下：

1

{"url": "http://httpbin.org/get", "status": 200, "html": "{\n  \"args\": {}, \n  \"headers\": {\n    \"Accept-Encoding\": \"gzip, deflate\", \n    \"Accept-Language\": \"en,*\", \n    \"Connection\": \"close\", \n    \"Host\": \"httpbin.org\", \n    \"User-Agent\": \"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/602.1 (KHTML, like Gecko) splash Version/9.0 Safari/602.1\"\n  }, \n  \"origin\": \"60.207.237.85\", \n  \"url\": \"http://httpbin.org/get\"\n}\n"}

可以看到，返回结果是 JSON 形式，我们成功获取了请求的 URL、状态码和网页源代码。

如此一来，我们之前所说的 Lua 脚本均可以用此方式与 Python 进行对接，所有网页的动态渲染、模拟点击、表单提交、页面滑动、延时等待后的一些结果均可以自由控制，获取页面源码和截图也都不在话下。

到现在为止，我们可以用 Python 和 Splash 实现 JavaScript 渲染的页面的抓取了。除了 Selenium，本节所说的 Splash 同样可以做到非常强大的渲染功能，同时它也不需要浏览器即可渲染，使用非常方便。

Selenium 是一个自动化测试工具，利用它可以驱动浏览器执行特定的动作，如点击、下拉等操作，同时还可以获取浏览器当前呈现的页面的源代码，做到可见即可爬。对于一些 JavaScript 动态渲染的页面来说，此种抓取方式非常有效。本节中，就让我们来感受一下它的强大之处吧。

1. 准备工作

本节以 Chrome 为例来讲解 Selenium 的用法。在开始之前，请确保已经正确安装好了 Chrome 浏览器并配置好了 ChromeDriver。另外，还需要正确安装好 Python 的 Selenium 库，详细的安装和配置过程可以参考第 1 章。

2. 基本使用

准备工作做好之后，首先来大体看一下 Selenium 有一些怎样的功能。示例如下：

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

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait

browser = webdriver.Chrome()
try:
    browser.get('https://www.baidu.com')
    input = browser.find_element_by_id('kw')
    input.send_keys('Python')
    input.send_keys(Keys.ENTER)
    wait = WebDriverWait(browser, 10)
    wait.until(EC.presence_of_element_located((By.ID, 'content_left')))
    print(browser.current_url)
    print(browser.get_cookies())
    print(browser.page_source)
finally:
    browser.close()

运行代码后发现，会自动弹出一个 Chrome 浏览器。浏览器首先会跳转到百度，然后在搜索框中输入 Python，接着跳转到搜索结果页，如图 7-1 所示。

图 7-1 运行结果

搜索结果加载出来后，控制台分别会输出当前的 URL、当前的 Cookies 和网页源代码：

1
2
3

https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=0&rsv_idx=1&tn=baidu&wd=Python&rsv_pq=c94d0df9000a72d0&rsv_t=07099xvun1ZmC0bf6eQvygJ43IUTTUOl5FCJVPgwG2YREs70GplJjH2F%2BCQ&rqlang=cn&rsv_enter=1&rsv_sug3=6&rsv_sug2=0&inputT=87&rsv_sug4=87
[{'secure': False, 'value': 'B490B5EBF6F3CD402E515D22BCDA1598', 'domain': '.baidu.com', 'path': '/', 'httpOnly': False, 'name': 'BDORZ', 'expiry': 1491688071.707553}, {'secure': False, 'value': '22473_1441_21084_17001', 'domain': '.baidu.com', 'path': '/', 'httpOnly': False, 'name': 'H_PS_PSSID'}, {'secure': False, 'value': '12883875381399993259_00_0_I_R_2_0303_C02F_N_I_I_0', 'domain': '.www.baidu.com', 'path': '/', 'httpOnly': False, 'name': '__bsi', 'expiry': 1491601676.69722}]
<!DOCTYPE html><!--STATUS OK-->...</html>

源代码过长，在此省略。可以看到，我们得到的当前 URL、Cookies 和源代码都是浏览器中的真实内容。

所以说，如果用 Selenium 来驱动浏览器加载网页的话，就可以直接拿到 JavaScript 渲染的结果了，不用担心使用的是什么加密系统。

下面来详细了解一下 Selenium 的用法。

3. 声明浏览器对象

Selenium 支持非常多的浏览器，如 Chrome、Firefox、Edge 等，还有 Android、BlackBerry 等手机端的浏览器。另外，也支持无界面浏览器 PhantomJS。

此外，我们可以用如下方式初始化：

1
2
3
4
5
6
7

from selenium import webdriver

browser = webdriver.Chrome()
browser = webdriver.Firefox()
browser = webdriver.Edge()
browser = webdriver.PhantomJS()
browser = webdriver.Safari()

这样就完成了浏览器对象的初始化并将其赋值为browser对象。接下来，我们要做的就是调用browser对象，让其执行各个动作以模拟浏览器操作。

4. 访问页面

我们可以用get()方法来请求网页，参数传入链接 URL 即可。比如，这里用get()方法访问淘宝，然后打印出源代码，代码如下：

1
2
3
4
5
6

from selenium import webdriver

browser = webdriver.Chrome()
browser.get('https://www.taobao.com')
print(browser.page_source)
browser.close()

运行后发现，弹出了 Chrome 浏览器并且自动访问了淘宝，然后控制台输出了淘宝页面的源代码，随后浏览器关闭。

通过这几行简单的代码，我们可以实现浏览器的驱动并获取网页源码，非常便捷。

5. 查找节点

Selenium 可以驱动浏览器完成各种操作，比如填充表单、模拟点击等。比如，我们想要完成向某个输入框输入文字的操作，总需要知道这个输入框在哪里吧？而 Selenium 提供了一系列查找节点的方法，我们可以用这些方法来获取想要的节点，以便下一步执行一些动作或者提取信息。

单个节点

比如，想要从淘宝页面中提取搜索框这个节点，首先要观察它的源代码，如图 7-2 所示。

图 7-2 源代码

可以发现，它的id是q，name也是q。此外，还有许多其他属性，此时我们就可以用多种方式获取它了。比如，find_element_by_name()是根据name值获取，find_element_by_id()是根据id获取。另外，还有根据 XPath、CSS 选择器等获取的方式。

我们用代码实现一下：

1
2
3
4
5
6
7
8
9

from selenium import webdriver

browser = webdriver.Chrome()
browser.get('https://www.taobao.com')
input_first = browser.find_element_by_id('q')
input_second = browser.find_element_by_css_selector('#q')
input_third = browser.find_element_by_xpath('//*[@id="q"]')
print(input_first, input_second, input_third)
browser.close()

这里我们使用 3 种方式获取输入框，分别是根据 ID、CSS 选择器和 XPath 获取，它们返回的结果完全一致。运行结果如下：

1
2
3

<selenium.webdriver.remote.webelement.WebElement (session="5e53d9e1c8646e44c14c1c2880d424af", element="0.5649563096161541-1")>
<selenium.webdriver.remote.webelement.WebElement (session="5e53d9e1c8646e44c14c1c2880d424af", element="0.5649563096161541-1")>
<selenium.webdriver.remote.webelement.WebElement (session="5e53d9e1c8646e44c14c1c2880d424af", element="0.5649563096161541-1")>

可以看到，这 3 个节点都是WebElement类型，是完全一致的。

这里列出所有获取单个节点的方法：

1
2
3
4
5
6
7
8

find_element_by_id
find_element_by_name
find_element_by_xpath
find_element_by_link_text
find_element_by_partial_link_text
find_element_by_tag_name
find_element_by_class_name
find_element_by_css_selector

另外，Selenium 还提供了通用方法find_element()，它需要传入两个参数：查找方式By和值。实际上，它就是find_element_by_id()这种方法的通用函数版本，比如find_element_by_id(id)就等价于find_element(By.ID, id)，二者得到的结果完全一致。我们用代码实现一下：

1
2
3
4
5
6
7
8

from selenium import webdriver
from selenium.webdriver.common.by import By

browser = webdriver.Chrome()
browser.get('https://www.taobao.com')
input_first = browser.find_element(By.ID, 'q')
print(input_first)
browser.close()

实际上，这种查找方式的功能和上面列举的查找函数完全一致，不过参数更加灵活。

多个节点

如果查找的目标在网页中只有一个，那么完全可以用find_element()方法。但如果有多个节点，再用find_element()方法查找，就只能得到第一个节点了。如果要查找所有满足条件的节点，需要用find_elements()这样的方法。注意，在这个方法的名称中，element 多了一个 s，注意区分。

比如，要查找淘宝左侧导航条的所有条目，如图 7-3 所示。

图 7-3 导航栏

就可以这样来实现：

1
2
3
4
5
6
7

from selenium import webdriver

browser = webdriver.Chrome()
browser.get('https://www.taobao.com')
lis = browser.find_elements_by_css_selector('.service-bd li')
print(lis)
browser.close()

运行结果如下：

1

[<selenium.webdriver.remote.webelement.WebElement (session="c26290835d4457ebf7d96bfab3740d19", element="0.09221044033125603-1")>, <selenium.webdriver.remote.webelement.WebElement (session="c26290835d4457ebf7d96bfab3740d19", element="0.09221044033125603-2")>, <selenium.webdriver.remote.webelement.WebElement (session="c26290835d4457ebf7d96bfab3740d19", element="0.09221044033125603-3")>...<selenium.webdriver.remote.webelement.WebElement (session="c26290835d4457ebf7d96bfab3740d19", element="0.09221044033125603-16")>]

这里简化了输出结果，中间部分省略。

可以看到，得到的内容变成了列表类型，列表中的每个节点都是WebElement类型。

也就是说，如果我们用find_element()方法，只能获取匹配的第一个节点，结果是WebElement类型。如果用find_elements()方法，则结果是列表类型，列表中的每个节点是WebElement类型。

这里列出所有获取多个节点的方法：

1
2
3
4
5
6
7
8

find_elements_by_id
find_elements_by_name
find_elements_by_xpath
find_elements_by_link_text
find_elements_by_partial_link_text
find_elements_by_tag_name
find_elements_by_class_name
find_elements_by_css_selector

当然，我们也可以直接用find_elements()方法来选择，这时可以这样写：

1

lis = browser.find_elements(By.CSS_SELECTOR, '.service-bd li')

结果是完全一致的。

6. 节点交互

Selenium 可以驱动浏览器来执行一些操作，也就是说可以让浏览器模拟执行一些动作。比较常见的用法有：输入文字时用send_keys()方法，清空文字时用clear()方法，点击按钮时用click()方法。示例如下：

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

from selenium import webdriver
import time

browser = webdriver.Chrome()
browser.get('https://www.taobao.com')
input = browser.find_element_by_id('q')
input.send_keys('iPhone')
time.sleep(1)
input.clear()
input.send_keys('iPad')
button = browser.find_element_by_class_name('btn-search')
button.click()

这里首先驱动浏览器打开淘宝，然后用find_element_by_id()方法获取输入框，然后用send_keys()方法输入 iPhone 文字，等待一秒后用clear()方法清空输入框，再次调用send_keys()方法输入 iPad 文字，之后再用find_element_by_class_name()方法获取搜索按钮，最后调用click()方法完成搜索动作。

通过上面的方法，我们就完成了一些常见节点的动作操作，更多的操作可以参见官方文档的交互动作介绍：http://selenium-python.readthedocs.io/api.html#module-selenium.webdriver.remote.webelement。

7. 动作链

在上面的实例中，一些交互动作都是针对某个节点执行的。比如，对于输入框，我们就调用它的输入文字和清空文字方法；对于按钮，就调用它的点击方法。其实，还有另外一些操作，它们没有特定的执行对象，比如鼠标拖曳、键盘按键等，这些动作用另一种方式来执行，那就是动作链。

比如，现在实现一个节点的拖曳操作，将某个节点从一处拖曳到另外一处，可以这样实现：