Python 自然语言处理中句子相似度计算的几种方法

在做自然语言处理的过程中，我们经常会遇到需要找出相似语句的场景，或者找出句子的近似表达，这时候我们就需要把类似的句子归到一起，这里面就涉及到句子相似度计算的问题，那么本节就来了解一下怎么样来用 Python 实现句子相似度的计算。

基本方法

句子相似度计算我们一共归类了以下几种方法：

编辑距离计算
杰卡德系数计算
TF 计算
TFIDF 计算
Word2Vec 计算

下面我们来一一了解一下这几种算法的原理和 Python 实现。

编辑距离计算

编辑距离，英文叫做 Edit Distance，又称 Levenshtein 距离，是指两个字串之间，由一个转成另一个所需的最少编辑操作次数，如果它们的距离越大，说明它们越是不同。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。例如我们有两个字符串：string 和 setting，如果我们想要把 string 转化为 setting，需要这么两步：

第一步，在 s 和 t 之间加入字符 e。
第二步，把 r 替换成 t。

所以它们的编辑距离差就是 2，这就对应着二者要进行转化所要改变（添加、替换、删除）的最小步数。那么用 Python 怎样来实现呢，我们可以直接使用 distance 库：

import distance

def edit_distance(s1, s2):
    return distance.levenshtein(s1, s2)

s1 = 'string'
s2 = 'setting'
print(edit_distance(s1, s2))

这里我们直接使用 distance 库的 levenshtein() 方法，传入两个字符串，即可获取两个字符串的编辑距离了。运行结果如下：

这里的 distance 库我们可以直接使用 pip3 来安装：

1	pip3 install distance

这样如果我们想要获取相似的文本的话可以直接设定一个编辑距离的阈值来实现，如设置编辑距离为 2，下面是一个样例：

import distance

def edit_distance(s1, s2):
    return distance.levenshtein(s1, s2)

strings = [
    '你在干什么',
    '你在干啥子',
    '你在做什么',
    '你好啊',
    '我喜欢吃香蕉'
]

target = '你在干啥'
results = list(filter(lambda x: edit_distance(x, target) <= 2, strings))
print(results)

这里我们定义了一些字符串，然后定义了一个目标字符串，然后用编辑距离 2 的阈值进行设定，最后得到的结果就是编辑距离在 2 及以内的结果，运行结果如下：

1	['你在干什么', '你在干啥子']

通过这种方式我们可以大致筛选出类似的句子，但是发现一些句子例如“你在做什么” 就没有被识别出来，但他们的意义确实是相差不大的，因此，编辑距离并不是一个好的方式，但是简单易用。

杰卡德系数计算

杰卡德系数，英文叫做 Jaccard index, 又称为 Jaccard 相似系数，用于比较有限样本集之间的相似性与差异性。Jaccard 系数值越大，样本相似度越高。实际上它的计算方式非常简单，就是两个样本的交集除以并集得到的数值，当两个样本完全一致时，结果为 1，当两个样本完全不同时，结果为 0。算法非常简单，就是交集除以并集，下面我们用 Python 代码来实现一下：

from sklearn.feature_extraction.text import CountVectorizer
import numpy as np


def jaccard_similarity(s1, s2):
    def add_space(s):
        return ' '.join(list(s))
    
    # 将字中间加入空格
    s1, s2 = add_space(s1), add_space(s2)
    # 转化为TF矩阵
    cv = CountVectorizer(tokenizer=lambda s: s.split())
    corpus = [s1, s2]
    vectors = cv.fit_transform(corpus).toarray()
    # 求交集
    numerator = np.sum(np.min(vectors, axis=0))
    # 求并集
    denominator = np.sum(np.max(vectors, axis=0))
    # 计算杰卡德系数
    return 1.0 * numerator / denominator


s1 = '你在干嘛呢'
s2 = '你在干什么呢'
print(jaccard_similarity(s1, s2))

这里我们使用了 Sklearn 库中的 CountVectorizer 来计算句子的 TF 矩阵，然后利用 Numpy 来计算二者的交集和并集，随后计算杰卡德系数。这里值得学习的有 CountVectorizer 的用法，通过它的 fit_transform() 方法我们可以将字符串转化为词频矩阵，例如这里有两句话“你在干嘛呢”和“你在干什么呢”，首先 CountVectorizer 会计算出不重复的有哪些字，会得到一个字的列表，结果为：

1	['么', '什', '你', '呢', '嘛', '在', '干']

这个其实可以通过如下代码来获取，就是获取词表内容：

1	cv.get_feature_names()

接下来通过转化之后，vectors 变量就变成了：

1 2	[[0 0 1 1 1 1 1] [1 1 1 1 0 1 1]]

它对应的是两个句子对应词表的词频统计，这里是两个句子，所以结果是一个长度为 2 的二维数组，比如第一句话“你在干嘛呢”中不包含“么”字，那么第一个“么”字对应的结果就是0，即数量为 0，依次类推。后面我们使用了 np.min() 方法并传入了 axis 为 0，实际上就是获取了每一列的最小值，这样实际上就是取了交集，np.max() 方法是获取了每一列的最大值，实际上就是取了并集。二者分别取和即是交集大小和并集大小，然后作商即可，结果如下：

1	0.5714285714285714

这个数值越大，代表两个字符串越接近，否则反之，因此我们也可以使用这个方法，并通过设置一个相似度阈值来进行筛选。

TF 计算

第三种方案就是直接计算 TF 矩阵中两个向量的相似度了，实际上就是求解两个向量夹角的余弦值，就是点乘积除以二者的模长，公式如下：

1	cosθ=a·b/\|a\|*\|b\|

上面我们已经获得了 TF 矩阵，下面我们只需要求解两个向量夹角的余弦值就好了，代码如下：

from sklearn.feature_extraction.text import CountVectorizer
import numpy as np
from scipy.linalg import norm

def tf_similarity(s1, s2):
    def add_space(s):
        return ' '.join(list(s))
    
    # 将字中间加入空格
    s1, s2 = add_space(s1), add_space(s2)
    # 转化为TF矩阵
    cv = CountVectorizer(tokenizer=lambda s: s.split())
    corpus = [s1, s2]
    vectors = cv.fit_transform(corpus).toarray()
    # 计算TF系数
    return np.dot(vectors[0], vectors[1]) / (norm(vectors[0]) * norm(vectors[1]))


s1 = '你在干嘛呢'
s2 = '你在干什么呢'
print(tf_similarity(s1, s2))

在在这里我们使用了 np.dot() 方法获取了向量的点乘积，然后通过 norm() 方法获取了向量的模长，经过计算得到二者的 TF 系数，结果如下：

1	0.7302967433402214

TFIDF 计算

另外除了计算 TF 系数我们还可以计算 TFIDF 系数，TFIDF 实际上就是在词频 TF 的基础上再加入 IDF 的信息，IDF 称为逆文档频率，不了解的可以看下阮一峰老师的讲解：http://www.ruanyifeng.com/blog/2013/03/tf-idf.html，里面对 TFIDF 的讲解也是十分透彻的。下面我们还是借助于 Sklearn 中的模块 TfidfVectorizer 来实现，代码如下：

from sklearn.feature_extraction.text import TfidfVectorizer
import numpy as np
from scipy.linalg import norm


def tfidf_similarity(s1, s2):
    def add_space(s):
        return ' '.join(list(s))
    
    # 将字中间加入空格
    s1, s2 = add_space(s1), add_space(s2)
    # 转化为TF矩阵
    cv = TfidfVectorizer(tokenizer=lambda s: s.split())
    corpus = [s1, s2]
    vectors = cv.fit_transform(corpus).toarray()
    # 计算TF系数
    return np.dot(vectors[0], vectors[1]) / (norm(vectors[0]) * norm(vectors[1]))


s1 = '你在干嘛呢'
s2 = '你在干什么呢'
print(tfidf_similarity(s1, s2))

这里的 vectors 变量实际上就对应着 TFIDF 值，内容如下：

1 2	[[0. 0. 0.4090901 0.4090901 0.57496187 0.4090901 0.4090901 ] [0.49844628 0.49844628 0.35464863 0.35464863 0. 0.35464863 0.35464863]]

运行结果如下：

1	0.5803329846765686

所以通过 TFIDF 系数我们也可以进行相似度的计算。

Word2Vec 计算

Word2Vec，顾名思义，其实就是将每一个词转换为向量的过程。如果不了解的话可以参考：https://blog.csdn.net/itplus/article/details/37969519。这里我们可以直接下载训练好的 Word2Vec 模型，模型的链接地址为：https://pan.baidu.com/s/1TZ8GII0CEX32ydjsfMc0zw，是使用新闻、百度百科、小说数据来训练的 64 维的 Word2Vec 模型，数据量很大，整体效果还不错，我们可以直接下载下来使用，这里我们使用的是 news_12g_baidubaike_20g_novel_90g_embedding_64.bin 数据，然后实现 Sentence2Vec，代码如下：

import gensim
import jieba
import numpy as np
from scipy.linalg import norm

model_file = './word2vec/news_12g_baidubaike_20g_novel_90g_embedding_64.bin'
model = gensim.models.KeyedVectors.load_word2vec_format(model_file, binary=True)

def vector_similarity(s1, s2):
    def sentence_vector(s):
        words = jieba.lcut(s)
        v = np.zeros(64)
        for word in words:
            v += model[word]
        v /= len(words)
        return v
    
    v1, v2 = sentence_vector(s1), sentence_vector(s2)
    return np.dot(v1, v2) / (norm(v1) * norm(v2))

在获取 Sentence Vector 的时候，我们首先对句子进行分词，然后对分好的每一个词获取其对应的 Vector，然后将所有 Vector 相加并求平均，这样就可得到 Sentence Vector 了，然后再计算其夹角余弦值即可。调用示例如下：

1
2
3

s1 = '你在干嘛'
s2 = '你正做什么'
vector_similarity(s1, s2)

结果如下：

1	0.6701133967824016

这时如果我们再回到最初的例子看下效果：

strings = [
    '你在干什么',
    '你在干啥子',
    '你在做什么',
    '你好啊',
    '我喜欢吃香蕉'
]

target = '你在干啥'

for string in strings:
    print(string, vector_similarity(string, target))

依然是前面的例子，我们看下它们的匹配度结果是多少，运行结果如下：

你在干什么 0.8785495016487204
你在干啥子 0.9789649689827049
你在做什么 0.8781992402695274
你好啊 0.5174225914249863
我喜欢吃香蕉 0.582990841450621

可以看到相近的语句相似度都能到 0.8 以上，而不同的句子相似度都不足 0.6，这个区分度就非常大了，可以说有了 Word2Vec 我们可以结合一些语义信息来进行一些判断，效果明显也好很多。所以总体来说，Word2Vec 计算的方式是非常好的。另外学术界还有一些可能更好的研究成果，这个可以参考知乎上的一些回答：https://www.zhihu.com/question/29978268/answer/54399062。以上便是进行句子相似度计算的基本方法和 Python 实现，本节代码地址：https://github.com/AIDeepLearning/SentenceDistance。

作者崔庆才发表于 2018-06-08 阅读次数：本文字数： 5.7k 阅读时长 ≈ 5 分钟

Python 小白进阶之Scrapy第六篇Scrapy-Redis详解

Scrapy-Redis 详解

通常我们在一个站站点进行采集的时候，如果是小站的话我们使用scrapy本身就可以满足。但是如果在面对一些比较大型的站点的时候，单个scrapy就显得力不从心了。要是我们能够多个Scrapy一起采集该多好啊人多力量大。很遗憾Scrapy官方并不支持多个同时采集一个站点，虽然官方给出一个方法： 将一个站点的分割成几部分交给不同的scrapy去采集 似乎是个解决办法，但是很麻烦诶！毕竟分割很麻烦的哇下面就改轮到我们的额主角Scrapy-Redis登场了！

什么？？你这么就登场了？还没说为什么呢？

好吧为了简单起见就用官方图来简单说明一下：这张图大家相信大家都很熟悉了。重点看一下SCHEDULER 1. 先来看看官方对于SCHEDULER的定义： SCHEDULER接受来自Engine的Requests,并将它们放入队列（可以按顺序优先级），以便在之后将其提供给Engine 点我看文档 2. 现在我们来看看SCHEDULER都提供了些什么功能：根据官方文档说明在我们没有没有指定 SCHEDULER 参数时，默认使用：’scrapy.core.scheduler.Scheduler’ 作为SCHEDULER(调度器) scrapy.core.scheduler.py:

class Scheduler(object):

    def __init__(self, dupefilter, jobdir=None, dqclass=None, mqclass=None,
                 logunser=False, stats=None, pqclass=None):
        self.df = dupefilter
        self.dqdir = self._dqdir(jobdir)
        self.pqclass = pqclass
        self.dqclass = dqclass
        self.mqclass = mqclass
        self.logunser = logunser
        self.stats = stats
        # 注意在scrpy中优先注意这个方法，此方法是一个钩子 用于访问当前爬虫的配置
    @classmethod
    def from_crawler(cls, crawler):
        settings = crawler.settings
        # 获取去重用的类 默认：scrapy.dupefilters.RFPDupeFilter
        dupefilter_cls = load_object(settings['DUPEFILTER_CLASS'])
        # 对去重类进行配置from_settings 在 scrapy.dupefilters.RFPDupeFilter 43行
        # 这种调用方式对于IDE跳转不是很好  所以需要自己去找
        # @classmethod
        # def from_settings(cls, settings):
        #     debug = settings.getbool('DUPEFILTER_DEBUG')
        #     return cls(job_dir(settings), debug)
        # 上面就是from_settings方法 其实就是设置工作目录 和是否开启debug
        dupefilter = dupefilter_cls.from_settings(settings)
        # 获取优先级队列 类对象 默认：queuelib.pqueue.PriorityQueue
        pqclass = load_object(settings['SCHEDULER_PRIORITY_QUEUE'])
        # 获取磁盘队列 类对象（SCHEDULER使用磁盘存储 重启不会丢失）
        dqclass = load_object(settings['SCHEDULER_DISK_QUEUE'])
        # 获取内存队列 类对象（SCHEDULER使用内存存储 重启会丢失）
        mqclass = load_object(settings['SCHEDULER_MEMORY_QUEUE'])
        # 是否开启debug
        logunser = settings.getbool('LOG_UNSERIALIZABLE_REQUESTS', settings.getbool('SCHEDULER_DEBUG'))
        # 将这些参数传递给 __init__方法
        return cls(dupefilter, jobdir=job_dir(settings), logunser=logunser,
                   stats=crawler.stats, pqclass=pqclass, dqclass=dqclass, mqclass=mqclass)


    def has_pending_requests(self):
      """检查是否有没处理的请求"""
        return len(self) > 0

    def open(self, spider):
      """Engine创建完毕之后会调用这个方法"""
        self.spider = spider
        # 创建一个有优先级的内存队列 实例化对象
        # self.pqclass 默认是：queuelib.pqueue.PriorityQueue
        # self._newmq 会返回一个内存队列的 实例化对象 在110  111 行
        self.mqs = self.pqclass(self._newmq)
        # 如果self.dqdir 有设置 就创建一个磁盘队列 否则self.dqs 为空
        self.dqs = self._dq() if self.dqdir else None
        # 获得一个去重实例对象 open 方法是从BaseDupeFilter继承的
        # 现在我们可以用self.df来去重啦
        return self.df.open()

    def close(self, reason):
      """当然Engine关闭时"""
          # 如果有磁盘队列 则对其进行dump后保存到active.json文件中
        if self.dqs:
            prios = self.dqs.close()
            with open(join(self.dqdir, 'active.json'), 'w') as f:
                json.dump(prios, f)
        # 然后关闭去重
        return self.df.close(reason)

    def enqueue_request(self, request):
      """添加一个Requests进调度队列"""
          # self.df.request_seen是检查这个Request是否已经请求过了 如果有会返回True
        if not request.dont_filter and self.df.request_seen(request):
              # 如果Request的dont_filter属性没有设置（默认为False）和 已经存在则去重
            # 不push进队列
            self.df.log(request, self.spider)
            return False
        # 先尝试将Request push进磁盘队列
        dqok = self._dqpush(request)
        if dqok:
              # 如果成功 则在记录一次状态
            self.stats.inc_value('scheduler/enqueued/disk', spider=self.spider)
        else:
              # 不能添加进磁盘队列则会添加进内存队列
            self._mqpush(request)
            self.stats.inc_value('scheduler/enqueued/memory', spider=self.spider)
        self.stats.inc_value('scheduler/enqueued', spider=self.spider)
        return True

    def next_request(self):
      """从队列中获取一个Request"""
          # 优先从内存队列中获取
        request = self.mqs.pop()
        if request:
            self.stats.inc_value('scheduler/dequeued/memory', spider=self.spider)
        else:
              # 不能获取的时候从磁盘队列队里获取
            request = self._dqpop()
            if request:
                self.stats.inc_value('scheduler/dequeued/disk', spider=self.spider)
        if request:
            self.stats.inc_value('scheduler/dequeued', spider=self.spider)
        # 将获取的到Request返回给Engine
        return request

    def __len__(self):
        return len(self.dqs) + len(self.mqs) if self.dqs else len(self.mqs)

    def _dqpush(self, request):
        if self.dqs is None:
            return
        try:
            reqd = request_to_dict(request, self.spider)
            self.dqs.push(reqd, -request.priority)
        except ValueError as e:  # non serializable request
            if self.logunser:
                msg = ("Unable to serialize request: %(request)s - reason:"
                       " %(reason)s - no more unserializable requests will be"
                       " logged (stats being collected)")
                logger.warning(msg, {'request': request, 'reason': e},
                               exc_info=True, extra={'spider': self.spider})
                self.logunser = False
            self.stats.inc_value('scheduler/unserializable',
                                 spider=self.spider)
            return
        else:
            return True

    def _mqpush(self, request):
        self.mqs.push(request, -request.priority)

    def _dqpop(self):
        if self.dqs:
            d = self.dqs.pop()
            if d:
                return request_from_dict(d, self.spider)

    def _newmq(self, priority):
        return self.mqclass()

    def _newdq(self, priority):
        return self.dqclass(join(self.dqdir, 'p%s' % priority))

    def _dq(self):
        activef = join(self.dqdir, 'active.json')
        if exists(activef):
            with open(activef) as f:
                prios = json.load(f)
        else:
            prios = ()
        q = self.pqclass(self._newdq, startprios=prios)
        if q:
            logger.info("Resuming crawl (%(queuesize)d requests scheduled)",
                        {'queuesize': len(q)}, extra={'spider': self.spider})
        return q

    def _dqdir(self, jobdir):
        if jobdir:
            dqdir = join(jobdir, 'requests.queue')
            if not exists(dqdir):
                os.makedirs(dqdir)
            return dqdir

只挑了一些重点的写了一些注释剩下大家自己领会(才不是我懒哦 ) 从上面的代码我们可以很清楚的知道 SCHEDULER的主要是完成了 push Request pop Request 和去重的操作。而且queue 操作是在内存队列中完成的。大家看queuelib.queue就会发现基于内存的（deque）那么去重呢？

class RFPDupeFilter(BaseDupeFilter):
    """Request Fingerprint duplicates filter"""

    def __init__(self, path=None, debug=False):
        self.file = None
        self.fingerprints = set()
        self.logdupes = True
        self.debug = debug
        self.logger = logging.getLogger(__name__)
        if path:
              # 此处可以看到去重其实打开了一个名叫 requests.seen的文件
            # 如果是使用的磁盘的话
            self.file = open(os.path.join(path, 'requests.seen'), 'a+')
            self.file.seek(0)
            self.fingerprints.update(x.rstrip() for x in self.file)

    @classmethod
    def from_settings(cls, settings):
        debug = settings.getbool('DUPEFILTER_DEBUG')
        return cls(job_dir(settings), debug)

    def request_seen(self, request):
        fp = self.request_fingerprint(request)
        if fp in self.fingerprints:
              # 判断我们的请求是否在这个在集合中
            return True
        # 没有在集合就添加进去
        self.fingerprints.add(fp)
        # 如果用的磁盘队列就写进去记录一下
        if self.file:
            self.file.write(fp + os.linesep)

  按照正常流程就是大家都会进行重复的采集；我们都知道进程之间内存中的数据不可共享的，那么你在开启多个Scrapy的时候，它们相互之间并不知道对方采集了些什么那些没有没采集。那就大家伙儿自己玩自己的了。完全没没有效率的提升啊！ ![](https://thsheep-wordpress.oss-cn-beijing.aliyuncs.com/7015cb643d0c05854dab5b8457f076af.jpg) 怎么解决呢？ 这就是我们Scrapy-Redis解决的问题了，不能协作不就是因为Request 和 去重这两个 不能共享吗？ 那我把这两个独立出来好了。 将Scrapy中的SCHEDULER组件独立放到大家都能访问的地方不就OK啦！加上scrapy-redis后流程图就应该变成这样了? ![](https://thsheep-wordpress.oss-cn-beijing.aliyuncs.com/0a94645a8f10707fe80610b5ebeb945e.jpg) So············· 这样是不是看起来就清楚多了？？？ 下面我们来看看Scrapy-Redis是怎么处理的? scrapy_redis.scheduler.py：

class Scheduler(object):
    """Redis-based scheduler

    Settings
    --------
    SCHEDULER_PERSIST : bool (default: False)
        Whether to persist or clear redis queue.
    SCHEDULER_FLUSH_ON_START : bool (default: False)
        Whether to flush redis queue on start.
    SCHEDULER_IDLE_BEFORE_CLOSE : int (default: 0)
        How many seconds to wait before closing if no message is received.
    SCHEDULER_QUEUE_KEY : str
        Scheduler redis key.
    SCHEDULER_QUEUE_CLASS : str
        Scheduler queue class.
    SCHEDULER_DUPEFILTER_KEY : str
        Scheduler dupefilter redis key.
    SCHEDULER_DUPEFILTER_CLASS : str
        Scheduler dupefilter class.
    SCHEDULER_SERIALIZER : str
        Scheduler serializer.

    """

    def __init__(self, server,
                 persist=False,
                 flush_on_start=False,
                 queue_key=defaults.SCHEDULER_QUEUE_KEY,
                 queue_cls=defaults.SCHEDULER_QUEUE_CLASS,
                 dupefilter_key=defaults.SCHEDULER_DUPEFILTER_KEY,
                 dupefilter_cls=defaults.SCHEDULER_DUPEFILTER_CLASS,
                 idle_before_close=0,
                 serializer=None):
        """Initialize scheduler.

        Parameters
        ----------
        server : Redis
            这是Redis实例
        persist : bool
            是否在关闭时清空Requests.默认值是False。
        flush_on_start : bool
            是否在启动时清空Requests。 默认值是False。
        queue_key : str
            Request队列的Key名字
        queue_cls : str
            队列的可导入路径（就是使用什么队列）
        dupefilter_key : str
            去重队列的Key
        dupefilter_cls : str
            去重类的可导入路径。
        idle_before_close : int
            等待多久关闭

        """
        if idle_before_close < 0:
            raise TypeError("idle_before_close cannot be negative")

        self.server = server
        self.persist = persist
        self.flush_on_start = flush_on_start
        self.queue_key = queue_key
        self.queue_cls = queue_cls
        self.dupefilter_cls = dupefilter_cls
        self.dupefilter_key = dupefilter_key
        self.idle_before_close = idle_before_close
        self.serializer = serializer
        self.stats = None

    def __len__(self):
        return len(self.queue)

    @classmethod
    def from_settings(cls, settings):
        kwargs = {
            'persist': settings.getbool('SCHEDULER_PERSIST'),
            'flush_on_start': settings.getbool('SCHEDULER_FLUSH_ON_START'),
            'idle_before_close': settings.getint('SCHEDULER_IDLE_BEFORE_CLOSE'),
        }

        # If these values are missing, it means we want to use the defaults.
        optional = {
            # TODO: Use custom prefixes for this settings to note that are
            # specific to scrapy-redis.
            'queue_key': 'SCHEDULER_QUEUE_KEY',
            'queue_cls': 'SCHEDULER_QUEUE_CLASS',
            'dupefilter_key': 'SCHEDULER_DUPEFILTER_KEY',
            # We use the default setting name to keep compatibility.
            'dupefilter_cls': 'DUPEFILTER_CLASS',
            'serializer': 'SCHEDULER_SERIALIZER',
        }
        # 从setting中获取配置组装成dict(具体获取那些配置是optional字典中key)
        for name, setting_name in optional.items():
            val = settings.get(setting_name)
            if val:
                kwargs[name] = val

        # Support serializer as a path to a module.
        if isinstance(kwargs.get('serializer'), six.string_types):
            kwargs['serializer'] = importlib.import_module(kwargs['serializer'])
                # 或得一个Redis连接
        server = connection.from_settings(settings)
        # Ensure the connection is working.
        server.ping()

        return cls(server=server, **kwargs)

    @classmethod
    def from_crawler(cls, crawler):
        instance = cls.from_settings(crawler.settings)
        # FIXME: for now, stats are only supported from this constructor
        instance.stats = crawler.stats
        return instance

    def open(self, spider):
        self.spider = spider

        try:
              # 根据self.queue_cls这个可以导入的类 实例化一个队列
            self.queue = load_object(self.queue_cls)(
                server=self.server,
                spider=spider,
                key=self.queue_key % {'spider': spider.name},
                serializer=self.serializer,
            )
        except TypeError as e:
            raise ValueError("Failed to instantiate queue class '%s': %s",
                             self.queue_cls, e)

        try:
              # 根据self.dupefilter_cls这个可以导入的类 实例一个去重集合
            # 默认是集合 可以实现自己的去重方式 比如 bool 去重
            self.df = load_object(self.dupefilter_cls)(
                server=self.server,
                key=self.dupefilter_key % {'spider': spider.name},
                debug=spider.settings.getbool('DUPEFILTER_DEBUG'),
            )
        except TypeError as e:
            raise ValueError("Failed to instantiate dupefilter class '%s': %s",
                             self.dupefilter_cls, e)

        if self.flush_on_start:
            self.flush()
        # notice if there are requests already in the queue to resume the crawl
        if len(self.queue):
            spider.log("Resuming crawl (%d requests scheduled)" % len(self.queue))

    def close(self, reason):
        if not self.persist:
            self.flush()

    def flush(self):
        self.df.clear()
        self.queue.clear()

    def enqueue_request(self, request):
      """这个和Scrapy本身的一样"""
        if not request.dont_filter and self.df.request_seen(request):
            self.df.log(request, self.spider)
            return False
        if self.stats:
            self.stats.inc_value('scheduler/enqueued/redis', spider=self.spider)
        # 向队列里面添加一个Request
        self.queue.push(request)
        return True

    def next_request(self):
      """获取一个Request"""
        block_pop_timeout = self.idle_before_close
        # block_pop_timeout 是一个等待参数 队列没有东西会等待这个时间  超时就会关闭
        request = self.queue.pop(block_pop_timeout)
        if request and self.stats:
            self.stats.inc_value('scheduler/dequeued/redis', spider=self.spider)
        return request

    def has_pending_requests(self):
        return len(self) > 0

来先来看看以上就是Scrapy-Redis中的SCHEDULER模块。下面我们来看看queue和本身的什么不同： scrapy_redis.queue.py 以最常用的优先级队列 PriorityQueue 举例：

class PriorityQueue(Base):
    """Per-spider priority queue abstraction using redis' sorted set"""
        """其实就是使用Redis的有序集合 来对Request进行排序，这样就可以优先级高的在有序集合的顶层 我们只需要"""
    """从上往下依次获取Request即可"""
    def __len__(self):
        """Return the length of the queue"""
        return self.server.zcard(self.key)

    def push(self, request):
        """Push a request"""
        """添加一个Request进队列"""
        # self._encode_request 将Request请求进行序列化
        data = self._encode_request(request)
        """
        d = {
        'url': to_unicode(request.url),  # urls should be safe (safe_string_url)
        'callback': cb,
        'errback': eb,
        'method': request.method,
        'headers': dict(request.headers),
        'body': request.body,
        'cookies': request.cookies,
        'meta': request.meta,
        '_encoding': request._encoding,
        'priority': request.priority,
        'dont_filter': request.dont_filter,
        'flags': request.flags,
        '_class': request.__module__ + '.' + request.__class__.__name__
            }

        data就是上面这个字典的序列化
        在Scrapy.utils.reqser.py 中的request_to_dict方法中处理
        """

        # 在Redis有序集合中数值越小优先级越高(就是会被放在顶层)所以这个位置是取得 相反数
        score = -request.priority
        # We don't use zadd method as the order of arguments change depending on
        # whether the class is Redis or StrictRedis, and the option of using
        # kwargs only accepts strings, not bytes.
        # ZADD 是添加进有序集合
        self.server.execute_command('ZADD', self.key, score, data)

    def pop(self, timeout=0):
        """
        Pop a request
        timeout not support in this queue class
        有序集合不支持超时所以就木有使用timeout了  这个timeout就是挂羊头卖狗肉
        """
        """从有序集合中取出一个Request"""
        # use atomic range/remove using multi/exec
        """使用multi的原因是为了将获取Request和删除Request合并成一个操作(原子性的)在获取到一个元素之后 删除它，因为有序集合 不像list 有pop 这种方式啊"""
        pipe = self.server.pipeline()
        pipe.multi()
        # 取出 顶层第一个
        # zrange :返回有序集 key 中，指定区间内的成员。0,0 就是第一个了
        # zremrangebyrank：移除有序集 key 中，指定排名(rank)区间内的所有成员 0，0也就是第一个了
        # 更多请参考Redis官方文档
        pipe.zrange(self.key, 0, 0).zremrangebyrank(self.key, 0, 0)
        results, count = pipe.execute()
        if results:
            return self._decode_request(results[0])

以上就是SCHEDULER在处理Request的时候做的操作了。是时候来看看SCHEDULER是怎么处理去重的了！只需要注意这个?方法即可：

def request_seen(self, request):
  """Returns True if request was already seen.

        Parameters
        ----------
        request : scrapy.http.Request

        Returns
        -------
        bool

        """
  # 通过self.request_fingerprint 会生一个sha1的指纹
  fp = self.request_fingerprint(request)
  # This returns the number of values added, zero if already exists.
  # 添加进一个Redis集合如果self.key这个集合中存在fp这个指纹会返回1  不存在返回0
  added = self.server.sadd(self.key, fp)
  return added == 0

这样大家就都可以访问同一个Redis 获取同一个spider的Request 在同一个位置去重，就不用担心重复啦 大概就像这样：

spider1：检查一下这个Request是否在Redis去重，如果在就证明其它的spider采集过啦！如果不在就添加进调度队列，等待别人获取。自己继续干活抓取网页产生新的Request了重复之前步骤。
spider2：以相同的逻辑执行

可能有些小伙儿会产生疑问了~~！spider2拿到了别人的Request了怎么能正确的执行呢？逻辑不会错吗？这个不用担心啦因为整Request当中包含了，所有的逻辑，回去看看上面那个序列化的字典。总结一下：

1. Scrapy-Reids 就是将Scrapy原本在内存中处理的调度(就是一个队列Queue)、去重、这两个操作通过Redis来实现
多个Scrapy在采集同一个站点时会使用相同的redis key（可以理解为队列）添加Request 获取Request 去重Request，这样所有的spider不会进行重复采集。效率自然就嗖嗖的上去了。
3. Redis是原子性的，好处不言而喻(一个Request要么被处理要么没被处理，不存在第三可能)

另外Scrapy-Redis本身不支持Redis-Cluster，大量网站去重的话会给单机很大的压力（就算使用boolfilter 内存也不够整啊！）改造方式很简单：

使用 rediscluster 这个包替换掉本身的Redis连接
Redis-Cluster 不支持事务，可以使用lua脚本进行代替（lua脚本是原子性的哦）
注意使用lua脚本不能写占用时间很长的操作（毕竟一大群人等着操作Redis 你总不能让人家等着吧）

以上！完毕对于懒人小伙伴儿看看这个我改好的: 集群版Scrapy-Redis PS: 支持Python3.6+ 哦！其余的版本没测试过

作者哎哟卧槽发表于 2018-06-06 阅读次数：本文字数： 14k 阅读时长 ≈ 13 分钟

Python Python中logging模块的基本用法

在 PyCon 2018 上，Mario Corchero 介绍了在开发过程中如何更方便轻松地记录日志的流程。

整个演讲的内容包括：

为什么日志记录非常重要
日志记录的流程是怎样的
怎样来进行日志记录
怎样进行日志记录相关配置
日志记录使用常见误区

下面我们来梳理一下整个演讲的过程，其实其核心就是介绍了 logging 模块的使用方法和一些配置。

日志记录的重要性

在开发过程中，如果程序运行出现了问题，我们是可以使用我们自己的 Debug 工具来检测到到底是哪一步出现了问题，如果出现了问题的话，是很容易排查的。但程序开发完成之后，我们会将它部署到生产环境中去，这时候代码相当于是在一个黑盒环境下运行的，我们只能看到其运行的效果，是不能直接看到代码运行过程中每一步的状态的。在这个环境下，运行过程中难免会在某个地方出现问题，甚至这个问题可能是我们开发过程中未曾遇到的问题，碰到这种情况应该怎么办？如果我们现在只能得知当前问题的现象，而没有其他任何信息的话，如果我们想要解决掉这个问题的话，那么只能根据问题的现象来试图复现一下，然后再一步步去调试，这恐怕是很难的，很大的概率上我们是无法精准地复现这个问题的，而且 Debug 的过程也会耗费巨多的时间，这样一旦生产环境上出现了问题，修复就会变得非常棘手。但这如果我们当时有做日志记录的话，不论是正常运行还是出现报错，都有相关的时间记录，状态记录，错误记录等，那么这样我们就可以方便地追踪到在当时的运行过程中出现了怎样的状况，从而可以快速排查问题。因此，日志记录是非常有必要的，任何一款软件如果没有标准的日志记录，都不能算作一个合格的软件。作为开发者，我们需要重视并做好日志记录过程。

日志记录的流程框架

那么在 Python 中，怎样才能算作一个比较标准的日志记录过程呢？或许很多人会使用 print 语句输出一些运行信息，然后再在控制台观察，运行的时候再将输出重定向到文件输出流保存到文件中，这样其实是非常不规范的，在 Python 中有一个标准的 logging 模块，我们可以使用它来进行标注的日志记录，利用它我们可以更方便地进行日志记录，同时还可以做更方便的级别区分以及一些额外日志信息的记录，如时间、运行模块信息等。接下来我们先了解一下日志记录流程的整体框架。如图所示，整个日志记录的框架可以分为这么几个部分：

Logger：即 Logger Main Class，是我们进行日志记录时创建的对象，我们可以调用它的方法传入日志模板和信息，来生成一条条日志记录，称作 Log Record。
Log Record：就代指生成的一条条日志记录。
Handler：即用来处理日志记录的类，它可以将 Log Record 输出到我们指定的日志位置和存储形式等，如我们可以指定将日志通过 FTP 协议记录到远程的服务器上，Handler 就会帮我们完成这些事情。
Formatter：实际上生成的 Log Record 也是一个个对象，那么我们想要把它们保存成一条条我们想要的日志文本的话，就需要有一个格式化的过程，那么这个过程就由 Formatter 来完成，返回的就是日志字符串，然后传回给 Handler 来处理。
Filter：另外保存日志的时候我们可能不需要全部保存，我们可能只需要保存我们想要的部分就可以了，所以保存前还需要进行一下过滤，留下我们想要的日志，如只保存某个级别的日志，或只保存包含某个关键字的日志等，那么这个过滤过程就交给 Filter 来完成。
Parent Handler：Handler 之间可以存在分层关系，以使得不同 Handler 之间共享相同功能的代码。

以上就是整个 logging 模块的基本架构和对象功能，了解了之后我们详细来了解一下 logging 模块的用法。

日志记录的相关用法

总的来说 logging 模块相比 print 有这么几个优点：

可以在 logging 模块中设置日志等级，在不同的版本（如开发环境、生产环境）上通过设置不同的输出等级来记录对应的日志，非常灵活。
print 的输出信息都会输出到标准输出流中，而 logging 模块就更加灵活，可以设置输出到任意位置，如写入文件、写入远程服务器等。
logging 模块具有灵活的配置和格式化功能，如配置输出当前模块信息、运行时间等，相比 print 的字符串格式化更加方便易用。

下面我们初步来了解下 logging 模块的基本用法，先用一个实例来感受一下：

import logging

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

logger.info('This is a log info')
logger.debug('Debugging')
logger.warning('Warning exists')
logger.info('Finish')

在这里我们首先引入了 logging 模块，然后进行了一下基本的配置，这里通过 basicConfig 配置了 level 信息和 format 信息，这里 level 配置为 INFO 信息，即只输出 INFO 级别的信息，另外这里指定了 format 格式的字符串，包括 asctime、name、levelname、message 四个内容，分别代表运行时间、模块名称、日志级别、日志内容，这样输出内容便是这四者组合而成的内容了，这就是 logging 的全局配置。接下来声明了一个 Logger 对象，它就是日志输出的主类，调用对象的 info() 方法就可以输出 INFO 级别的日志信息，调用 debug() 方法就可以输出 DEBUG 级别的日志信息，非常方便。在初始化的时候我们传入了模块的名称，这里直接使用 name 来代替了，就是模块的名称，如果直接运行这个脚本的话就是 main，如果是 import 的模块的话就是被引入模块的名称，这个变量在不同的模块中的名字是不同的，所以一般使用 name 来表示就好了，再接下来输出了四条日志信息，其中有两条 INFO、一条 WARNING、一条 DEBUG 信息，我们看下输出结果：

1
2
3

2018-06-03 13:42:43,526 - __main__ - INFO - This is a log info
2018-06-03 13:42:43,526 - __main__ - WARNING - Warning exists
2018-06-03 13:42:43,526 - __main__ - INFO - Finish

可以看到输出结果一共有三条日志信息，每条日志都是对应了指定的格式化内容，另外我们发现 DEBUG 的信息是没有输出的，这是因为我们在全局配置的时候设置了输出为 INFO 级别，所以 DEBUG 级别的信息就被过滤掉了。这时如果我们将输出的日志级别设置为 DEBUG，就可以看到 DEBUG 级别的日志输出了：

1	logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')

输出结果：

2018-06-03 13:49:22,770 - __main__ - INFO - This is a log info
2018-06-03 13:49:22,770 - __main__ - DEBUG - Debugging
2018-06-03 13:49:22,770 - __main__ - WARNING - Warning exists
2018-06-03 13:49:22,770 - __main__ - INFO - Finish

由此可见，相比 print 来说，通过刚才的代码，我们既可以输出时间、模块名称，又可以输出不同级别的日志信息作区分并加以过滤，是不是灵活多了？当然这只是 logging 模块的一小部分功能，接下来我们首先来全面了解一下 basicConfig 的参数都有哪些：

filename：即日志输出的文件名，如果指定了这个信息之后，实际上会启用 FileHandler，而不再是 StreamHandler，这样日志信息便会输出到文件中了。
filemode：这个是指定日志文件的写入方式，有两种形式，一种是 w，一种是 a，分别代表清除后写入和追加写入。
format：指定日志信息的输出格式，即上文示例所示的参数，详细参数可以参考：docs.python.org/3/library/l…，部分参数如下所示：
- %(levelno)s：打印日志级别的数值。
- %(levelname)s：打印日志级别的名称。
- %(pathname)s：打印当前执行程序的路径，其实就是sys.argv[0]。
- %(filename)s：打印当前执行程序名。
- %(funcName)s：打印日志的当前函数。
- %(lineno)d：打印日志的当前行号。
- %(asctime)s：打印日志的时间。
- %(thread)d：打印线程ID。
- %(threadName)s：打印线程名称。
- %(process)d：打印进程ID。
- %(processName)s：打印线程名称。
- %(module)s：打印模块名称。
- %(message)s：打印日志信息。
datefmt：指定时间的输出格式。
style：如果 format 参数指定了，这个参数就可以指定格式化时的占位符风格，如 %、{、$ 等。
level：指定日志输出的类别，程序会输出大于等于此级别的信息。
stream：在没有指定 filename 的时候会默认使用 StreamHandler，这时 stream 可以指定初始化的文件流。
handlers：可以指定日志处理时所使用的 Handlers，必须是可迭代的。

下面我们再用一个实例来感受一下：

import logging

logging.basicConfig(level=logging.DEBUG,
                    filename='output.log',
                    datefmt='%Y/%m/%d %H:%M:%S',
                    format='%(asctime)s - %(name)s - %(levelname)s - %(lineno)d - %(module)s - %(message)s')
logger = logging.getLogger(__name__)

logger.info('This is a log info')
logger.debug('Debugging')
logger.warning('Warning exists')
logger.info('Finish')

这里我们指定了输出文件的名称为 output.log，另外指定了日期的输出格式，其中年月日的格式变成了 %Y/%m/%d，另外输出的 format 格式增加了 lineno、module 这两个信息，运行之后便会生成一个 output.log 的文件，内容如下：

2018/06/03 14:43:26 - __main__ - INFO - 9 - demo3 - This is a log info
2018/06/03 14:43:26 - __main__ - DEBUG - 10 - demo3 - Debugging
2018/06/03 14:43:26 - __main__ - WARNING - 11 - demo3 - Warning exists
2018/06/03 14:43:26 - __main__ - INFO - 12 - demo3 - Finish

可以看到日志便会输出到文件中，同时输出了行号、模块名称等信息。以上我们通过 basicConfig 来进行了一些全局的配置，我们同样可以使用 Formatter、Handler 进行更灵活的处理，下面我们来了解一下。

Level

首先我们来了解一下输出日志的等级信息，logging 模块共提供了如下等级，每个等级其实都对应了一个数值，列表如下：

等级

数值

CRITICAL

FATAL

ERROR

WARNING

WARN

INFO

DEBUG

NOTSET

这里最高的等级是 CRITICAL 和 FATAL，两个对应的数值都是 50，另外对于 WARNING 还提供了简写形式 WARN，两个对应的数值都是 30。我们设置了输出 level，系统便只会输出 level 数值大于或等于该 level 的的日志结果，例如我们设置了输出日志 level 为 INFO，那么输出级别大于等于 INFO 的日志，如 WARNING、ERROR 等，DEBUG 和 NOSET 级别的不会输出。

import logging

logger = logging.getLogger(__name__)
logger.setLevel(level=logging.WARN)

# Log
logger.debug('Debugging')
logger.critical('Critical Something')
logger.error('Error Occurred')
logger.warning('Warning exists')
logger.info('Finished')

这里我们设置了输出级别为 WARN，然后对应输出了五种不同级别的日志信息，运行结果如下：

1
2
3

Critical Something
Error Occurred
Warning exists

可以看到只有 CRITICAL、ERROR、WARNING 信息输出了，DEBUG、INFO 信息没有输出。

Handler

下面我们先来了解一下 Handler 的用法，看下面的实例：

import logging

logger = logging.getLogger(__name__)
logger.setLevel(level=logging.INFO)
handler = logging.FileHandler('output.log')
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)

logger.info('This is a log info')
logger.debug('Debugging')
logger.warning('Warning exists')
logger.info('Finish')

这里我们没有再使用 basicConfig 全局配置，而是先声明了一个 Logger 对象，然后指定了其对应的 Handler 为 FileHandler 对象，然后 Handler 对象还单独指定了 Formatter 对象单独配置输出格式，最后给 Logger 对象添加对应的 Handler 即可，最后可以发现日志就会被输出到 output.log 中，内容如下：

1
2
3

2018-06-03 14:53:36,467 - __main__ - INFO - This is a log info
2018-06-03 14:53:36,468 - __main__ - WARNING - Warning exists
2018-06-03 14:53:36,468 - __main__ - INFO - Finish

另外我们还可以使用其他的 Handler 进行日志的输出，logging 模块提供的 Handler 有：

StreamHandler：logging.StreamHandler；日志输出到流，可以是 sys.stderr，sys.stdout 或者文件。
FileHandler：logging.FileHandler；日志输出到文件。
BaseRotatingHandler：logging.handlers.BaseRotatingHandler；基本的日志回滚方式。
RotatingHandler：logging.handlers.RotatingHandler；日志回滚方式，支持日志文件最大数量和日志文件回滚。
TimeRotatingHandler：logging.handlers.TimeRotatingHandler；日志回滚方式，在一定时间区域内回滚日志文件。
SocketHandler：logging.handlers.SocketHandler；远程输出日志到TCP/IP sockets。
DatagramHandler：logging.handlers.DatagramHandler；远程输出日志到UDP sockets。
SMTPHandler：logging.handlers.SMTPHandler；远程输出日志到邮件地址。
SysLogHandler：logging.handlers.SysLogHandler；日志输出到syslog。
NTEventLogHandler：logging.handlers.NTEventLogHandler；远程输出日志到Windows NT/2000/XP的事件日志。
MemoryHandler：logging.handlers.MemoryHandler；日志输出到内存中的指定buffer。
HTTPHandler：logging.handlers.HTTPHandler；通过”GET”或者”POST”远程输出到HTTP服务器。

下面我们使用三个 Handler 来实现日志同时输出到控制台、文件、HTTP 服务器：

import logging
from logging.handlers import HTTPHandler
import sys

logger = logging.getLogger(__name__)
logger.setLevel(level=logging.DEBUG)

# StreamHandler
stream_handler = logging.StreamHandler(sys.stdout)
stream_handler.setLevel(level=logging.DEBUG)
logger.addHandler(stream_handler)

# FileHandler
file_handler = logging.FileHandler('output.log')
file_handler.setLevel(level=logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)

# HTTPHandler
http_handler = HTTPHandler(host='localhost:8001', url='log', method='POST')
logger.addHandler(http_handler)

# Log
logger.info('This is a log info')
logger.debug('Debugging')
logger.warning('Warning exists')
logger.info('Finish')

运行之前我们需要先启动 HTTP Server，并运行在 8001 端口，其中 log 接口是用来接收日志的接口。运行之后控制台输出会输出如下内容：

This is a log info
Debugging
Warning exists
Finish

output.log 文件会写入如下内容：

1
2
3

2018-06-03 15:13:44,895 - __main__ - INFO - This is a log info
2018-06-03 15:13:44,947 - __main__ - WARNING - Warning exists
2018-06-03 15:13:44,949 - __main__ - INFO - Finish

HTTP Server 会收到控制台输出的信息。这样一来，我们就通过设置多个 Handler 来控制了日志的多目标输出。另外值得注意的是，在这里 StreamHandler 对象我们没有设置 Formatter，因此控制台只输出了日志的内容，而没有包含时间、模块等信息，而 FileHandler 我们通过 setFormatter() 方法设置了一个 Formatter 对象，因此输出的内容便是格式化后的日志信息。另外每个 Handler 还可以设置 level 信息，最终输出结果的 level 信息会取 Logger 对象的 level 和 Handler 对象的 level 的交集。

Formatter

在进行日志格式化输出的时候，我们可以不借助于 basicConfig 来全局配置格式化输出内容，可以借助于 Formatter 来完成，下面我们再来单独看下 Formatter 的用法：

import logging

logger = logging.getLogger(__name__)
logger.setLevel(level=logging.WARN)
formatter = logging.Formatter(fmt='%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%Y/%m/%d %H:%M:%S')
handler = logging.StreamHandler()
handler.setFormatter(formatter)
logger.addHandler(handler)

# Log
logger.debug('Debugging')
logger.critical('Critical Something')
logger.error('Error Occurred')
logger.warning('Warning exists')
logger.info('Finished')

在这里我们指定了一个 Formatter，并传入了 fmt 和 datefmt 参数，这样就指定了日志结果的输出格式和时间格式，然后 handler 通过 setFormatter() 方法设置此 Formatter 对象即可，输出结果如下：

1
2
3

2018/06/03 15:47:15 - __main__ - CRITICAL - Critical Something
2018/06/03 15:47:15 - __main__ - ERROR - Error Occurred
2018/06/03 15:47:15 - __main__ - WARNING - Warning exists

这样我们可以每个 Handler 单独配置输出的格式，非常灵活。

捕获 Traceback

如果遇到错误，我们更希望报错时出现的详细 Traceback 信息，便于调试，利用 logging 模块我们可以非常方便地实现这个记录，我们用一个实例来感受一下：

import logging

logger = logging.getLogger(__name__)
logger.setLevel(level=logging.DEBUG)

# Formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# FileHandler
file_handler = logging.FileHandler('result.log')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)

# StreamHandler
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)

# Log
logger.info('Start')
logger.warning('Something maybe fail.')
try:
    result = 10 / 0
except Exception:
    logger.error('Faild to get result', exc_info=True)
logger.info('Finished')

这里我们在 error() 方法中添加了一个参数，将 exc_info 设置为了 True，这样我们就可以输出执行过程中的信息了，即完整的 Traceback 信息。运行结果如下：

2018-06-03 16:00:15,382 - __main__ - INFO - Start print log
2018-06-03 16:00:15,382 - __main__ - DEBUG - Do something
2018-06-03 16:00:15,382 - __main__ - WARNING - Something maybe fail.
2018-06-03 16:00:15,382 - __main__ - ERROR - Faild to get result
Traceback (most recent call last):
  File "/private/var/books/aicodes/loggingtest/demo8.py", line 23, in <module>
    result = 10 / 0
ZeroDivisionError: division by zero
2018-06-03 16:00:15,383 - __main__ - INFO - Finished

可以看到这样我们就非常方便地记录下来了报错的信息，一旦出现了错误，我们也能非常方便地排查。

配置共享

在写项目的时候，我们肯定会将许多配置放置在许多模块下面，这时如果我们每个文件都来配置 logging 配置那就太繁琐了，logging 模块提供了父子模块共享配置的机制，会根据 Logger 的名称来自动加载父模块的配置。例如我们这里首先定义一个 main.py 文件：

import logging
import core

logger = logging.getLogger('main')
logger.setLevel(level=logging.DEBUG)

# Handler
handler = logging.FileHandler('result.log')
handler.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)

logger.info('Main Info')
logger.debug('Main Debug')
logger.error('Main Error')
core.run()

这里我们配置了日志的输出格式和文件路径，同时定义了 Logger 的名称为 main，然后引入了另外一个模块 core，最后调用了 core 的 run() 方法。接下来我们定义 core.py，内容如下：

import logging

logger = logging.getLogger('main.core')

def run():
    logger.info('Core Info')
    logger.debug('Core Debug')
    logger.error('Core Error')

这里我们定义了 Logger 的名称为 main.core，注意这里开头是 main，即刚才我们在 main.py 里面的 Logger 的名称，这样 core.py 里面的 Logger 就会复用 main.py 里面的 Logger 配置，而不用再去配置一次了。运行之后会生成一个 result.log 文件，内容如下：

2018-06-03 16:55:56,259 - main - INFO - Main Info
2018-06-03 16:55:56,259 - main - ERROR - Main Error
2018-06-03 16:55:56,259 - main.core - INFO - Core Info
2018-06-03 16:55:56,259 - main.core - ERROR - Core Error

可以看到父子模块都使用了同样的输出配置。如此一来，我们只要在入口文件里面定义好 logging 模块的输出配置，子模块只需要在定义 Logger 对象时名称使用父模块的名称开头即可共享配置，非常方便。

文件配置

在开发过程中，将配置在代码里面写死并不是一个好的习惯，更好的做法是将配置写在配置文件里面，我们可以将配置写入到配置文件，然后运行时读取配置文件里面的配置，这样是更方便管理和维护的，下面我们以一个实例来说明一下，首先我们定义一个 yaml 配置文件：

version: 1
formatters:
  brief:
    format: "%(asctime)s - %(message)s"
  simple:
    format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
handlers:
  console:
    class : logging.StreamHandler
    formatter: brief
    level   : INFO
    stream  : ext://sys.stdout
  file:
    class : logging.FileHandler
    formatter: simple
    level: DEBUG
    filename: debug.log
  error:
    class: logging.handlers.RotatingFileHandler
    level: ERROR
    formatter: simple
    filename: error.log
    maxBytes: 10485760
    backupCount: 20
    encoding: utf8
loggers:
  main.core:
    level: DEBUG
    handlers: [console, file, error]
root:
  level: DEBUG
  handlers: [console]

这里我们定义了 formatters、handlers、loggers、root 等模块，实际上对应的就是各个 Formatter、Handler、Logger 的配置，参数和它们的构造方法都是相同的。接下来我们定义一个主入口文件，main.py，内容如下：

import logging
import core
import yaml
import logging.config
import os


def setup_logging(default_path='config.yaml', default_level=logging.INFO):
    path = default_path
    if os.path.exists(path):
        with open(path, 'r', encoding='utf-8') as f:
            config = yaml.load(f)
            logging.config.dictConfig(config)
    else:
        logging.basicConfig(level=default_level)


def log():
    logging.debug('Start')
    logging.info('Exec')
    logging.info('Finished')


if __name__ == '__main__':
    yaml_path = 'config.yaml'
    setup_logging(yaml_path)
    log()
    core.run()

这里我们定义了一个 setup_logging() 方法，里面读取了 yaml 文件的配置，然后通过 dictConfig() 方法将配置项传给了 logging 模块进行全局初始化。另外这个模块还引入了另外一个模块 core，所以我们定义 core.py 如下：

import logging

logger = logging.getLogger('main.core')

def run():
    logger.info('Core Info')
    logger.debug('Core Debug')
    logger.error('Core Error')

这个文件的内容和上文是没有什么变化的。观察配置文件，主入口文件 main.py 实际上对应的是 root 一项配置，它指定了 handlers 是 console，即只输出到控制台。另外在 loggers 一项配置里面，我们定义了 main.core 模块，handlers 是 console、file、error 三项，即输出到控制台、输出到普通文件和回滚文件。这样运行之后，我们便可以看到所有的运行结果输出到了控制台：

2018-06-03 17:07:12,727 - Exec
2018-06-03 17:07:12,727 - Finished
2018-06-03 17:07:12,727 - Core Info
2018-06-03 17:07:12,727 - Core Info
2018-06-03 17:07:12,728 - Core Error
2018-06-03 17:07:12,728 - Core Error

在 debug.log 文件中则包含了 core.py 的运行结果：

1
2
3

2018-06-03 17:07:12,727 - main.core - INFO - Core Info
2018-06-03 17:07:12,727 - main.core - DEBUG - Core Debug
2018-06-03 17:07:12,728 - main.core - ERROR - Core Error

可以看到，通过配置文件，我们可以非常灵活地定义 Handler、Formatter、Logger 等配置，同时也显得非常直观，也非常容易维护，在实际项目中，推荐使用此种方式进行配置。以上便是 logging 模块的基本使用方法，有了它，我们可以方便地进行日志管理和维护，会给我们的工作带来极大的方便。

日志记录使用常见误区

在日志输出的时候经常我们会用到字符串拼接的形式，很多情况下我们可能会使用字符串的 format() 来构造一个字符串，但这其实并不是一个好的方法，因为还有更好的方法，下面我们对比两个例子：

import logging

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# bad
logging.debug('Hello {0}, {1}!'.format('World', 'Congratulations'))
# good
logging.debug('Hello %s, %s!', 'World', 'Congratulations')

这里有两种打印 Log 的方法，第一种使用了字符串的 format() 的方法进行构造，传给 logging 的只用到了第一个参数，实际上 logging 模块提供了字符串格式化的方法，我们只需要在第一个参数写上要打印输出的模板，占位符用 %s、%d 等表示即可，然后在后续参数添加对应的值就可以了，推荐使用这种方法。运行结果如下：

1 2	2018-06-03 22:27:51,220 - root - DEBUG - Hello World, Congratulations! 2018-06-03 22:27:51,220 - root - DEBUG - Hello World, Congratulations!

另外在进行异常处理的时候，通常我们会直接将异常进行字符串格式化，但其实可以直接指定一个参数将 traceback 打印出来，示例如下：

import logging

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')

try:
    result = 5 / 0
except Exception as e:
    # bad
    logging.error('Error: %s', e)
    # good
    logging.error('Error', exc_info=True)
    # good
    logging.exception('Error')

如果我们直接使用字符串格式化的方法将错误输出的话，是不会包含 Traceback 信息的，但如果我们加上 exc_info 参数或者直接使用 exception() 方法打印的话，那就会输出 Traceback 信息了。运行结果如下：

2018-06-03 22:24:31,927 - root - ERROR - Error: division by zero
2018-06-03 22:24:31,927 - root - ERROR - Error
Traceback (most recent call last):
  File "/private/var/books/aicodes/loggingtest/demo9.py", line 6, in <module>
    result = 5 / 0
ZeroDivisionError: division by zero
2018-06-03 22:24:31,928 - root - ERROR - Error
Traceback (most recent call last):
  File "/private/var/books/aicodes/loggingtest/demo9.py", line 6, in <module>
    result = 5 / 0
ZeroDivisionError: division by zero

以上便是整个对 logging 模块的介绍。嗯，是时候抛弃 print 了，开始体验下 logging 的便利吧！

参考内容

https://docs.python.org/3/library/logging.html * http://www.cnblogs.com/dahu-daqing/p/7040764.html

作者崔庆才发表于 2018-06-03 阅读次数：本文字数： 16k 阅读时长 ≈ 14 分钟

Python 《Python3网络爬虫开发实战》来了！

2022 年最新第二版《Python3 网络爬虫开发实战》

现在《Python3 网络爬虫开发实战（第二版）》已经在 2021 年底正式上市了～
之前第一版的爬虫书《Python3 网络爬虫开发实战》在 2018 年出版，上市三年来，一直处于市面上所有爬虫书的销冠位置，豆瓣评分 9.0 分，销量 10w 册。

如今，这本书现在又进一步做了升级，第二版将案例进行了全面升级，自建了案例平台防止代码过期，同时增加了非常多的新技术、新知识的介绍，比如异步爬虫、JavaScript 逆向、安卓逆向、Kubernetes、智能解析。

可以说，目前市面上的爬虫书，其他的书跟这本书相比，内容方面这本书的算是最全的，没有之一。能将最前沿的爬虫技术比如异步、JavaScript 逆向、安卓逆向、智能解析、WebAssembly、Kubernetes 等技术都涵盖的，目前应该就是本新发布的《Python3 网络爬虫开发实战（第二版）》了。

就是这本：

2018 年 5 月《Python3 网络爬虫开发实战》的第一版出版了，从上市到现在三年多销量约 10w 册。后来，由于一些技术更迭，第二版书开始策划中。

2021 年 11 月，这本书历经各种反复修改、审稿等阶段，到今天终于上架了！

第二版更新内容

大家第一个问题可能就会问，第二版比第一版更新了哪些内容？

因为技术总是在不断发展和进步的，爬虫技术也是一样，它在爬虫和反爬虫不断斗争的过程中也在不断演进。比如现在越来越多的网页采取了各种防护措施，比如前端代码的压缩和混淆、API 的参数加密、WebDriver 的检测，要做到高效的数据爬取，我们就需要懂得一些 JavaScript 逆向分析相关技术。App 也是一样，App 的抓包防护、加壳保护、Native 化、风控检测使得越来越多的 App 数据难以爬取，所以我们也不得不了解一些逆向相关技术，如 Xposed、Frida、IDA Pro 等工具的使用。除此之外，近几年深度学习和人工智能发展得也是如火如荼，所以爬虫也可以和人工智能结合起来，比如基于深度学习的验证码识别、网页内容的智能化解析和提取等技术我们也可以进行学习和了解。另外，一些大规模爬虫的管理和运维技术也在不断发展，当前 Kubernetes、Docker、Prometheus 等云原生技术也非常火爆，基于 Kubernetes 等云原生技术的爬虫管理和运维解决方案也已经很受青睐。然而，之前第一版书对以上提到的这些新兴技术几乎没有提及。

除此之外，第一版书在讲解数据爬取的过程中引用了很多案例和服务，比如猫眼电影网站、淘宝网站、代理服务网站，然而几年过去了，有些案例网站和服务早已经改版或者停止维护，这就导致第一版书中的很多案例已经不能正常运行了。这其实是一个很大的问题，因为程序运行不通会大大降低学习的积极性和成就感，而且会浪费不少时间。另外，即使案例对应的爬虫代码及时更新了，那我们也不知道这些案例网站和服务什么时候会再次改版，因为这都是不可控的。所以，为了彻底解决这个问题，我花费了近半年的时间构建了一个爬虫案例平台（https://scrape.center），平台包含了几十个爬虫案例，包括服务端渲染（SSR）网站、单页面应用（SPA）网站、各类反爬网站、验证码网站、模拟登录网站、各类 App 等，覆盖了现在爬虫和反爬虫相关的大多数技术，整个平台都是我来维护的，书中几乎所有案例都是从案例平台来的，从而解决了页面改版的问题。

所以，本书相比第一版来说，更新的内容主要如下：

绝大多数都迁移到了自建的案例平台，以后再也不用担心案例有过期或改版问题。
替换了原本第一章环境安装的章节，将环境配置的部分全部汇总并迁移到案例平台（https://setup.scrape.center）并在书中以外链的形式附上，以确保环境的配置和安装说明能够被及时更新。
增加了一些新的请求库、解析库、存储库等的介绍，如 httpx、parsel、Elasticsearch 等库的介绍。
增加了异步爬虫的介绍，如协程的基本原理、aiohttp 的使用和爬取实战介绍。
增加了一些新兴自动化工具的介绍，如 Pyppeteer、Playwright 的介绍。
增加了深度学习相关内容，如图形验证码、滑动验证码的识别方案。
丰富了模拟登录章节的内容，如增加了 JWT 模拟登录的介绍和实战、大规模账号池的优化。
增加了 JavaScript 逆向的章节，包括网站加密和混淆技术、JavaScript 逆向调试技巧、JavaScript 的各种模拟执行方式、AST 还原混淆代码、WebAssembly 等相关技术的介绍。
丰富了 App 自动化爬取技术的章节，如新兴框架 Airtest 的介绍、手机群控和云手机技术的介绍。
增加了 Android 逆向章节，如反编译、反汇编、Hook、脱壳、so 文件分析和模拟执行等技术的介绍。
增加了网页智能化解析章节，包括列表页、详情页内容提取算法和分类算法。
丰富了 Scrapy 相关章节的介绍，如 Pyppeteer 的对接、RabbitMQ 的对接、Prometheus 的对接等。
增加了基于 Kubernetes、Docker、Prometheus、Grafana 等云原生技术爬虫管理和运维解决方案的介绍。

以上就是第二版的主要更新内容。

章节介绍

为了让大家更直接地了解到全书的内容，这里就直接放目录了：

没错！全书一共 900 多页，量了下有 4.3 厘米厚，定价是 139.8 元。

可以直接看第二版吗？

当然，有朋友也会担心，我需不需要先学习第一版，然后才能学第二版呢？

答案是：可以直接学第二版，第二版书爬虫的内容知识体系是完整的，一些旧的技术已经在第一版中移除，第二版的书籍是对所有爬虫知识体系的全新升级。

没有基础可以学吗？

有朋友也可能会问，没有爬虫或者 Python 基础可以学吗？

答案是：可以，本书就是专为零爬虫基础的朋友准备的，本书从最基础的环境配置、基础知识的讲解开始，循序渐进地对爬虫的各个知识点进行介绍，所以完全不用担心没有爬虫基础学不会的问题。如果没有 Python 基础，那也没关系（当然有会更好），书中也会提及 Python 环境的配置并附上一些 Python 入门学习资料（链接），同时也会通过各个 Python 代码片段来进行讲解，很多案例也很简单易懂，学爬虫的时候 Python 也就会逐渐掌握了。

大咖推荐

这本书同时还获得了 Python 之父的推荐（没错就是 Python 的创始人，Guido van Rossum）。另外我还有幸获得了微软亚洲互联网工程院副院长曾文峰、知名爬虫专家梁斌 penny、中国人民大学高瓴人工智能学院长聘副教授宋睿华的推荐。

下面是推荐语的内容：

宣传彩页

另外编辑还为本书制作了几张宣传彩页，是对整本书的一个宣传介绍，大家可以看下：

有没有电子版？

看到这里，大家可能也会问了，有没有电子版呢？可能有的朋友习惯用电子版书籍来学习，有的朋友可能在海外也不方便购买，所以想要电子版。

但还是很遗憾地说：没有电子版。

因为你知道的，如果出了电子版，那么马上就会有各种盗版袭来，网上也会造成各种恶意传播。

所以，为了保护版权，这本书是没有上电子版的。

购买链接

是的，最后就是大家最关心的部分了，到哪里能够买到呢？

购买链接：https://item.jd.com/13527222.html

为了方便购买，我把这个链接转成了二维码，大家可以直接扫码购买：

谢谢大家支持！

2018 年第一版爬虫书

以下是 2018 年第一版《Python3 网络爬虫开发实战》简介。

嗨~ 给大家重磅推荐一本新书！还未上市前就已经重印 3 次的 Python 爬虫书！那么它就是由静觅博客博主崔庆才所作的《Python3 网络爬虫开发实战》！！！

书籍介绍

本书《Python3 网络爬虫开发实战》全面介绍了利用 Python3 开发网络爬虫的知识，书中首先详细介绍了各种类型的环境配置过程和爬虫基础知识，还讨论了 urllib、requests 等请求库和 Beautiful Soup、XPath、pyquery 等解析库以及文本和各类数据库的存储方法，另外本书通过多个真实新鲜案例介绍了分析 Ajax 进行数据爬取，Selenium 和 Splash 进行动态网站爬取的过程，接着又分享了一些切实可行的爬虫技巧，比如使用代理爬取和维护动态代理池的方法、ADSL 拨号代理的使用、各类验证码（图形、极验、点触、宫格等）的破解方法、模拟登录网站爬取的方法及 Cookies 池的维护等等。此外，本书的内容还远远不止这些，作者还结合移动互联网的特点探讨了使用 Charles、mitmdump、Appium 等多种工具实现 App 抓包分析、加密参数接口爬取、微信朋友圈爬取的方法。此外本书还详细介绍了 pyspider 框架、Scrapy 框架的使用和分布式爬虫的知识，另外对于优化及部署工作，本书还包括 Bloom Filter 效率优化、Docker 和 Scrapyd 爬虫部署、分布式爬虫管理框架 Gerapy 的分享。全书共 604 页，足足两斤重呢~ 定价为 99 元！

作者介绍

看书就先看看谁写的嘛，我们来了解一下~ 崔庆才，静觅博客博主（https://cuiqingcai.com），博客 Python 爬虫博文已过百万，北京航空航天大学硕士，微软小冰大数据工程师，有多个大型分布式爬虫项目经验，乐于技术分享，文章通俗易懂 ^^ 附皂片一张 ~(@^^@)~

图文介绍

呕心沥血设计的宣传图也得放一下~

专家评论

书是好是坏，得让专家看评一评呀，那么下面就是几位专家的精彩评论，快来看看吧~ 在互联网软件开发工程师的分类中，爬虫工程师是非常重要的。爬虫工作往往是一个公司核心业务开展的基础，数据抓取下来，才有后续的加工处理和最终展现。此时数据的抓取规模、稳定性、实时性、准确性就显得非常重要。早期的互联网充分开放互联，数据获取的难度很小。随着各大公司对数据资产日益看重，反爬水平也在不断提高，各种新技术不断给爬虫软件提出新的课题。本书作者对爬虫的各个领域都有深刻研究，书中探讨了 Ajax 数据的抓取、动态渲染页面的抓取、验证码识别、模拟登录等高级话题，同时也结合移动互联网的特点探讨了 App 的抓取等。更重要的是，本书提供了大量源码，可以帮助读者更好地理解相关内容。强烈推荐给各位技术爱好者阅读！

——梁斌，八友科技总经理

数据既是当今大数据分析的前提，也是各种人工智能应用场景的基础。得数据者得天下，会爬虫者走遍天下也不怕！一册在手，让小白到老司机都能有所收获！

——李舟军，北京航空航天大学教授，博士生导师

本书从爬虫入门到分布式抓取，详细介绍了爬虫技术的各个要点，并针对不同的场景提出了对应的解决方案。另外，书中通过大量的实例来帮助读者更好地学习爬虫技术，通俗易懂，干货满满。强烈推荐给大家！

——宋睿华，微软小冰首席科学家

有人说中国互联网的带宽全给各种爬虫占据了，这说明网络爬虫的重要性以及中国互联网数据封闭垄断的现状。爬是一种能力，爬是为了不爬。

——施水才，北京拓尔思信息技术股份有限公司总裁

全书目录

书的目录也有~ 看这里！

1-开发环境配置
1.1-Python3 的安装
1.2-请求库的安装
1.3-解析库的安装
1.4-数据库的安装
1.5-存储库的安装
1.6-Web 库的安装
1.7-App 爬取相关库的安装
1.8-爬虫框架的安装
1.9-部署相关库的安装
2-爬虫基础
2.1-HTTP 基本原理
2.2-网页基础
2.3-爬虫的基本原理
2.4-会话和 Cookies
2.5-代理的基本原理
3-基本库的使用
3.1-使用 urllib
3.1.1-发送请求
3.1.2-处理异常
3.1.3-解析链接
3.1.4-分析 Robots 协议
3.2-使用 requests
3.2.1-基本用法
3.2.2-高级用法
3.3-正则表达式
3.4-抓取猫眼电影排行
4-解析库的使用
4.1-使用 XPath
4.2-使用 Beautiful Soup
4.3-使用 pyquery
5-数据存储
5.1-文件存储
5.1.1-TXT 文本存储
5.1.2-JSON 文件存储
5.1.3-CSV 文件存储
5.2-关系型数据库存储
5.2.1-MySQL 存储
5.3-非关系型数据库存储
5.3.1-MongoDB 存储
5.3.2-Redis 存储
6-Ajax 数据爬取
6.1-什么是 Ajax
6.2-Ajax 分析方法
6.3-Ajax 结果提取
6.4-分析 Ajax 爬取今日头条街拍美图
7-动态渲染页面爬取
7.1-Selenium 的使用
7.2-Splash 的使用
7.3-Splash 负载均衡配置
7.4-使用 Selenium 爬取淘宝商品
8-验证码的识别
8.1-图形验证码的识别
8.2-极验滑动验证码的识别
8.3-点触验证码的识别
8.4-微博宫格验证码的识别
9-代理的使用
9.1-代理的设置
9.2-代理池的维护
9.3-付费代理的使用
9.4-ADSL 拨号代理
9.5-使用代理爬取微信公众号文章
10-模拟登录
10.1-模拟登录并爬取 GitHub
10.2-Cookies 池的搭建
11-App 的爬取
11.1-Charles 的使用
11.2-mitmproxy 的使用
11.3-mitmdump 爬取“得到”App 电子书信息
11.4-Appium 的基本使用
11.5-Appium 爬取微信朋友圈
11.6-Appium+mitmdump 爬取京东商品
12-pyspider 框架的使用
12.1-pyspider 框架介绍
12.2-pyspider 的基本使用
12.3-pyspider 用法详解
13-Scrapy 框架的使用
13.1-Scrapy 框架介绍
13.2-Scrapy 入门
13.3-Selector 的用法
13.4-Spider 的用法
13.5-Downloader Middleware 的用法
13.6-Spider Middleware 的用法
13.7-Item Pipeline 的用法
13.8-Scrapy 对接 Selenium
13.9-Scrapy 对接 Splash
13.10-Scrapy 通用爬虫
13.11-Scrapyrt 的使用
13.12-Scrapy 对接 Docker
13.13-Scrapy 爬取新浪微博
14-分布式爬虫
14.1-分布式爬虫原理
14.2-Scrapy-Redis 源码解析
14.3-Scrapy 分布式实现
14.4-Bloom Filter 的对接
15-分布式爬虫的部署
15.1-Scrapyd 分布式部署
15.2-Scrapyd-Client 的使用
15.3-Scrapyd 对接 Docker
15.4-Scrapyd 批量部署
15.5-Gerapy 分布式管理

购买链接

想必很多小伙伴已经等了很久了，之前预售那么久也一直迟迟没有货，发售就有不少网店又售空了，不过现在起不用担心了！

书籍现已在京东、天猫、当当等网店上架并全面供应啦，复制链接到浏览器打开或扫描二维码打开即可购买了！

京东商城

https://item.jd.com/12333540.html

天猫商城

https://detail.tmall.com/item.htm?id=566699703917

当当网

http://product.dangdang.com/25249602.html

欢迎大家购买，谢谢支持！O(∩_∩)O

免费预览

不放心？想先看看有些啥，没问题！看这里：免费章节试读（复制粘贴至浏览器打开）： https://cuiqingcai.com/5052.html 将一直免费开放前 7 章节，欢迎大家试读！

视频教程

当然除了书籍，也有配套的视频课程，作者同样是崔庆才，二者结合学习效果更佳！限时优惠折扣中！扫描下图中二维码即可了解详情！视频教程链接： https://edu.hellobi.com/course/157 http://study.163.com/course/courseMain.htm?courseId=1003827039 感谢大家支持！

作者崔庆才发表于 2018-05-04 阅读次数：本文字数： 6.4k 阅读时长 ≈ 6 分钟

Python Flask 静态文件缓存问题

大家好，今天才发现很多学习 Flask 的小伙伴都有这么一个问题，清理缓存好麻烦啊，今天就教大家怎么解决。

大家在使用 Flask 静态文件的时候，每次更新，发现 CSS 或是 Js 或者其他的文件不会更新。这是因为浏览器的缓存问题。普遍大家是这几步解决办法。

清理浏览器缓存
设置浏览器不缓存
也有以下这么写的

@app.context_processor
def override_url_for():
    return dict(url_for=dated_url_for)

def dated_url_for(endpoint, **values):
    if endpoint == 'static':
        filename = values.get('filename', None)
    if filename:
        file_path = os.path.join(app.root_path, endpoint, filename)
        values['q'] = int(os.stat(file_path).st_mtime)
        return url_for(endpoint, **values)

如果是我，我不会这么做，效率很低。这是 Flask 的 config 的源码，里面可以看到，有设置缓存最大时间 SEND_FILE_MAX_AGE_DEFAULT 可以看到，它是一个 temedelta 的值 我们去更改配置。 第 2 行: 我们引入了datetime的timedelta对象 第 6 行: 我们配置缓存最大时间 这样就解决了缓存问题，不用去写多余的代码，不用去清理浏览器的缓存。 一定要学着去看官方文档和框架的源代码！！

有什么问题请联系

[caption id=”attachment_5953” align=”aligncenter” width=”320”] 微信二维码[/caption]

作者蒋翔宇发表于 2018-04-15 阅读次数：本文字数： 751 阅读时长 ≈ 1 分钟

Linux SSH反向隧道搭建过程

现在我们有一台内网主机 A，在局域网内是可以访问的，但是如果我们现在不处在局域网内，可以选择 VPN 连接，但这样其实并不太方便，所以本节我们来说明一下利用 SSH 反向隧道来实现访问内网主机的方法。

准备

首先我们需要有一台公网主机作为跳板，这台主机是可以公网访问的，我们将其命名为 B，它的 IP 假设为 10.10.10.10。所以两台机器网络配置如下：

A 内网机器

IP：192.168.1.2
SSH端口： 22
用户名：usera
密码：passworda
内网配置端口：22（即配置 SSH 端口的反向隧道）

B 公网机器

IP：10.10.10.10
SSH端口： 22
用户名：userb
密码：passwordb
公网端口：22001（即用 B 的 22001 端口连到 A 的 SSH 22 端口）

配置SSH秘钥

首先我们需要在 A 主机上生成 SSH 秘钥，和 B 用 SSH 建立认证。首先在主机 A 上执行如下命令生成 SSH 秘钥：

1	ssh-keygen -t rsa -C "your@email.com"

命令里面的邮箱需要自行更换。然后利用如下命令将 A 的 SSH 秘钥添加到 B 的 authorized_keys 里面：

1	ssh-copy-id userb@10.10.10.10

执行后会提示输入主机 B 的密码，执行完毕之后，我们登录到 B，就发现 authorized_keys 里面就多了 A 的 SSH 公钥了，成功建立 SSH 认证。

B 主机配置

B 主机需要更改 /etc/ssh/sshd_config 文件，修改如下一行：

1	GatewayPorts yes

这样可以把监听的端口绑定到任意IP 0.0.0.0上，否则只有本机 127.0.0.1 可以访问。然后重启 sshd 服务：

1	sudo service sshd restart

A 主机配置

主机 A 再安装一个 AutoSSH，以 Ubuntu 为例，命令如下：

1	sudo apt-get install autossh

然后执行如下命令即可完成反向 SSH 配置：

1	autossh -M 55555 -NfR 0.0.0.0:22001:localhost:22 userb@10.10.10.10

这里 -M 后面任意填写一个可用端口即可，-N 代表只建立连接，不打开shell ，-f 代表建立成功后在后台运行，-R 代表指定端口映射。这里是将 A 主机的 22 端口映射到 B 主机的 22001 端口，这样就完成了配置。主要我们再访问 B 主机的 22001 端口，就会自动转发到 A 主机的 22 端口了，即可以公网访问了。

连接测试

接下来 SSH 测试连接 A 主机即可：

1	ssh usera@10.10.10.10 -p 22001

输入密码，完成连接。

作者崔庆才发表于 2018-03-26 阅读次数：本文字数： 1.1k 阅读时长 ≈ 1 分钟

Python Attention原理及TensorFlow AttentionWrapper源码解析

本节来详细说明一下 Seq2Seq 模型中一个非常有用的 Attention 的机制，并结合 TensorFlow 中的 AttentionWrapper 来剖析一下其代码实现。

Seq2Seq

首先来简单说明一下 Seq2Seq 模型，如果搞过深度学习，想必一定听说过 Seq2Seq 模型，Seq2Seq 其实就是 Sequence to Sequence，也简称 S2S，也可以称之为 Encoder-Decoder 模型，这个模型的核心就是编码器（Encoder）和解码器（Decoder）组成的，架构雏形是在 2014 年由论文 Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation, Cho et al 提出的，后来 Sequence to Sequence Learning with Neural Networks, Sutskever et al 算是比较正式地提出了 Sequence to Sequence 的架构，后来 Neural Machine Translation by Jointly Learning to Align and Translate, Bahdanau et al 又提出了 Attention 机制，将 Seq2Seq 模型推上神坛，并横扫了非常多的任务，现在也非常广泛地用于机器翻译、对话生成、文本摘要生成等各种任务上，并取得了非常好的效果。下面的图示意了 Seq2Seq 模型的基本架构：可以看到图中有一个中间状态 $ c $ 向量，在 $ c $ 向量左侧的我们可以称之为编码器（Encoder），编码器这里示意的是 RNN 序列，另外 RNN 单元还可以使用 LSTM、GRU 等变体，在编码器下方输入了 $ x_1 $、$ x_2 $、$ x_3 $、$ x_4 $，代表模型的输入内容，例如在翻译模型中可以分别代表“我爱中国”这四个字，这样经过序列处理，它就会得到最后的输出，我们将其表示为 $ c $ 向量，这样编码器的工作就完成了。在图中 $ c $ 向量的右侧部分我们可以称之为解码器（Decoder），它拿到编码器生成的 $ c $ 向量，然后再进行序列解码，得到输出结果 $ y_1 $、$ y_2 $、$ y_3 $，例如刚才输入的“我爱中国”四个字便被解码成了 “I love China”，这样就实现了翻译任务，以上就是最基本的 Seq2Seq 模型原理。另外还有一种变体，$ c $ 向量在每次解码的时候都会作为解码器的输入，其实原理都是类似的，如图所示：这种模型架构是通用的，所以它的适用场景也非常广泛。如机器翻译、对话生成、文本摘要、阅读理解、语音识别，也可以用在一些趣味场景中，如诗词生成、对联生成、代码生成、评论生成等等，效果都很不错。

Attention

通过上图我们可以发现，Encoder 把所有的输入序列编码成了一个 $ c $ 向量，然后使用 $ c $ 向量来进行解码，因此，$ c $ 向量中必须包含了原始序列中的所有信息，所以它的压力其实是很大的，而且由于 RNN 容易把前面的信息“忘记”掉，所以基本的 Seq2Seq 模型，对于较短的输入来说，效果还是可以接受的，但是在输入序列比较长的时候，$ c $ 向量存不下那么多信息，就会导致生成效果大大折扣。 Attention 机制解决了这个问题，它可以使得在输入文本长的时候精确率也不会有明显下降，它是怎么做的呢？既然一个 $ c $ 向量存不了，那么就引入多个 $ c $ 向量，称之为 $ c1 $、$ c_2 $、…、$ c_i $，在解码的时候，这里的 $ i $ 对应着 Decoder 的解码位次，每次解码就利用对应的 $ c_i $ 向量来解码，如图所示：这里的每个 $ c_i $ 向量其实包含了当前所输出与输入序列各个部分重要性的相关的信息。不同的 $ c_i $ 向量里面包含的输入信息各部分的权重是不同的，先放一个示意图：还是上面的例子，例如输入信息是“我爱中国”，输出的的理想结果应该是“I love China”，在解码的时候，应该首先需要解码出 “I” 这个字符，这时候会用到 $ c_1 $ 向量，而 $ c_1 $ 向量包含的信息中，“我”这个字的重要性更大，因此它便倾向解码输出 “I”，当解码第二个字的时候，会用到 $ c_2 $ 向量，而 $ c_2 $ 向量包含的信息中，“爱” 这个字的重要性更大，因此会解码输出 “love”，在解码第三个字的时候，会用到 $ c_3 $ 向量，而 $ c_3 $向量包含的信息中，”中国” 这两个字的权重都比较大，因此会解码输出 “China”。所以其实，Attention 注意力机制中的 $ c_i $ 向量记录了不同解码时刻应该更关注于哪部分输入数据，也实现了编码解码过程的对齐。经过实验发现，这种机制可以有效解决输入信息过长时导致信息解码效果不理想的问题，另外解码生成效果同时也有提升。下面我们以 Bahdanau 提出的 Attention 为例来详细剖析一下 Attention 机制。在没有引入 Attention 之前，Decoder 在某个时刻解码的时候实际上是依赖于三个部分的，首先我们知道 RNN 中，每次输出结果会依赖于隐层和输入，在 Seq2Seq 模型中，还需要依赖于 $ c $ 向量，所以这里我们设在 $ i $ 时刻，解码器解码的内容是 $ y_i $，上一次解码结果是 $ y{i-1} $，隐层输出是 $ st $，所以它们满足这样的关系： $$ y_i = g(y{i-1}, si, c) $同时 $ s_i $ 和 $ c $ 还满足这样的关系：$ s_i = f(s{i-1}, y{i-1}, c) $即每次的隐层输出是上一个隐层和上一个输出结果和 $ c $ 向量共同计算得出的。但是刚才说了，这样会带来一些问题，$ c $ 向量不足以包含输入内容的所有信息，尤其是在输入序列特别长的情况下，所以这里我们不再使用一个 $ c $ 向量，而是每一个解码过程对应一个 $ c_i $ 向量，所以公式改写如下：$ y_i = g(y{i-1}, si, c_i) $同时 $ s_i $ 的计算方式也变为如下公式：$ s_i = f(s{i-1}, y{i-1}, c_i) $$ 所以，这里每次解码得出 $ y_i $ 时，都有与之对应的 $ c_i $ 向量。那么这个 $ c_i $ 向量又是怎么来的呢？实际上它是由编码器端每个时刻的隐含状态加权平均得到的，这里假设编码器端的的序列长度为 $ T_x $，序列位次用 $ j $ 来表示，编码器段每个时刻的隐含状态即为 $ h_1 $、$ h_2 $、…、$ h_j $、…、$ h{Tx} $，对于解码器的第 $ i $ 时刻，对应的 $ c_i $ 表示如下： $$ c_i = \sum{j=1}^{Tx} \alpha{ij}hj $$ 编码器输出的结果中，$ h_j $ 中包含了输入序列中的第 $ j $ 个词及前面的一些信息，如果是用了双向 RNN 的话，则包含的是第 $ j $ 个词即前后的一些词的信息，这里 $ \alpha{ij} $ 代表了分配的权重，这代表在生成第 i 个结果的时候，对于输入信息的各个阶段的 $ hj $ 的注意力分配是不同的。当 $ a{ij} $ 的值越高，表示第 $ i $ 个输出在第 $ j $ 个输入上分配的注意力越多，这样就会导致在生成第 $ i $ 个输出的时候，受第 $ j $ 个输入的影响也就越大。那么 $ a{ij} $ 又是怎么得来的呢？其实它就又关系到第 $ i-1 $ 个输出隐藏状态 $ s{i-1} $ 以及输入中的各个隐含状态 $ h_j $，公式表示如下： $$ \alpha{ij} = \frac {exp(e{ij})} {\sum{k=1}^{Tx} exp(e{ik})} $同时 $ e_{ij} $ 又表示为：$ e{ij} = a(s{i-1}, hj) = {v_a}^Ttanh(W_as{i-1} + Uah_j) $$ 这也就是说，这个权重就是 $ s{i-1} $ 和 $ hj $ 分别计算得到一个数值，然后再过一个 softmax 函数得到的，结果就是 $ \alpha{ij} $。因此 $ ci $ 就可以表示为： $$ c_i = \sum{j=1}^{Tx} softmax(a(s{i-1}, h_j)) \cdot h_j $$ 以上便是整个 Attention 机制的推导过程。

TensorFlow AttentionWrapper

我们了解了基本原理，但真正离程序实现出来其实还是有很大差距的，接下来我们就结合 TensorFlow 框架来了解一下 Attention 的实现机制。在 TensorFlow 中，Attention 的相关实现代码是在 tensorflow/contrib/seq2seq/python/ops/attention_wrapper.py 文件中，这里面实现了两种 Attention 机制，分别是 BahdanauAttention 和 LuongAttention，其实现论文分别如下：

整个 attention_wrapper.py 文件中主要包含几个类，我们主要关注其中几个：

AttentionMechanism、_BaseAttentionMechanism、LuongAttention、BahdanauAttention 实现了 Attention 机制的逻辑。
- AttentionMechanism 是 Attention 类的父类，继承了 object 类，内部没有任何实现。
- _BaseAttentionMechanism 继承自 AttentionMechanism 类，定义了 Attention 机制的一些公共方法实现和属性。
- LuongAttention、BahdanauAttention 均继承 _BaseAttentionMechanism 类，分别实现了上面两篇论文的 Attention 机制。
AttentionWrapperState 用来存储整个计算过程中的 state，和 RNN 中的 state 类似，只不过这里额外还存储了 attention、time 等信息。
AttentionWrapper 主要用于对封装 RNNCell，继承自 RNNCell，封装后依然是 RNNCell 的实例，可以构建一个带有 Attention 机制的 Decoder。
另外还有一些公共方法，例如 hardmax、safe_cumpord 等。

下面我们以 BahdanauAttention 为例来说明 Attention 机制及 AttentionWrapper 的实现。

BahdanauAttention

首先我们来介绍 BahdanauAttention 类的具体原理。首先我们来看下它的初始化方法：

def __init__(self,
    num_units,
    memory,
    memory_sequence_length=None,
    normalize=False,
    probability_fn=None,
    score_mask_value=None,
    dtype=None,
    name="BahdanauAttention"):

这里一共接受八个参数，下面一一进行说明：

numunits：神经元节点数，我们知道在计算 $ e{ij} $ 的时候，需要使用 $ s_{i-1} $ 和 $ h_j $ 来进行计算，而二者的维度可能并不是统一的，需要进行变换和统一，所以这里就有了 $ W_a $ 和 $ U_a $ 这两个系数，所以在代码中就是用 num_units 来声明了一个全连接 Dense 网络，用于统一二者的维度，以便于下一步的计算：

1 2	query_layer=layers_core.Dense(num_units, name="query_layer", use_bias=False, dtype=dtype) memory_layer=layers_core.Dense(num_units, name="memory_layer", use_bias=False, dtype=dtype)

这里我们可以看到声明了一个 querylayer 和 memory_layer，分别和 $ s{i-1} $ 及 $ h_j $ 做全连接变换，统一维度。

memory：The memory to query; usually the output of an RNN encoder. 即解码时用到的上文信息，维度需要是 [batch_size, max_time, context_dim]。这时我们观察一下父类 _BaseAttentionMechanism 的初始化方法，实现如下：

with ops.name_scope(
    name, "BaseAttentionMechanismInit", nest.flatten(memory)):
  self._values = _prepare_memory(
      memory, memory_sequence_length,
      check_inner_dims_defined=check_inner_dims_defined)
  self._keys = (
      self.memory_layer(self._values) if self.memory_layer
      else self._values)

这里通过 _prepare_memory() 方法对 memory 进行处理，然后调用 memory_layer 对 memory 进行全连接维度变换，变换成 [batch_size, max_time, num_units]。

memory_sequence_length：Sequence lengths for the batch entries in memory. 即 memory 变量的长度信息，类似于 dynamic_rnn 中的 sequence_length，被 _prepare_memory() 方法调用处理 memory 变量，进行 mask 操作：

seq_len_mask = array_ops.sequence_mask(
    memory_sequence_length,
    maxlen=array_ops.shape(nest.flatten(memory)[0])[1],
    dtype=nest.flatten(memory)[0].dtype)
seq_len_batch_size = (
    memory_sequence_length.shape[0].value
    or array_ops.shape(memory_sequence_length)[0])

normalize：Whether to normalize the energy term. 即是否要实现标准化，方法出自论文：Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks, Salimans, et al。
probability_fn：A callable function which converts the score to probabilities. 计算概率时的函数，必须是一个可调用的函数，默认使用 softmax()，还可以指定 hardmax() 等函数。
score_mask_value：The mask value for score before passing into probability_fn. The default is -inf. Only used if memory_sequence_length is not None. 在使用 probability_fn 计算概率之前，对 score 预先进行 mask 使用的值，默认是负无穷。但这个只有在 memory_sequence_length 参数定义的时候有效。
dtype：The data type for the query and memory layers of the attention mechanism. 数据类型，默认是 float32。
name：Name to use when creating ops，自定义名称。

接下来类里面定义了一个 call() 方法：

def __call__(self, query, previous_alignments):
    with variable_scope.variable_scope(None, "bahdanau_attention", [query]):
      processed_query = self.query_layer(query) if self.query_layer else query
      score = _bahdanau_score(processed_query, self._keys, self._normalize)
    alignments = self._probability_fn(score, previous_alignments)
    return alignments

这里首先定义了 processed_query，这里也是通过 query_layer 过了一个全连接网络，将最后一维统一成 num_units，然后调用了 bahdanau_score() 方法，这个方法是比较重要的，主要用来计算公式中的 $ e{ij} $，传入的参数是 processed_query 以及上文中提及的 keys 变量，二者一个代表了 $ s{i-1} $，一个代表了 $ h_j $，_bahdanau_score() 方法实现如下：

def _bahdanau_score(processed_query, keys, normalize):
    dtype = processed_query.dtype
    # Get the number of hidden units from the trailing dimension of keys
    num_units = keys.shape[2].value or array_ops.shape(keys)[2]
    # Reshape from [batch_size, ...] to [batch_size, 1, ...] for broadcasting.
    processed_query = array_ops.expand_dims(processed_query, 1)
    v = variable_scope.get_variable(
      "attention_v", [num_units], dtype=dtype)
    if normalize:
        # Scalar used in weight normalization
        g = variable_scope.get_variable(
            "attention_g", dtype=dtype,
            initializer=math.sqrt((1. / num_units)))
        # Bias added prior to the nonlinearity
        b = variable_scope.get_variable(
            "attention_b", [num_units], dtype=dtype,
            initializer=init_ops.zeros_initializer())
        # normed_v = g * v / ||v||
        normed_v = g * v * math_ops.rsqrt(
            math_ops.reduce_sum(math_ops.square(v)))
        return math_ops.reduce_sum(normed_v * math_ops.tanh(keys + processed_query + b), [2])
    else:
        return math_ops.reduce_sum(v * math_ops.tanh(keys + processed_query), [2])

这里其实就是实现了 keys 和 processedquery 的加和，如果指定了 normalize 的话还需要进行额外的 normalize，结果就是公式中的 $ e{ij} $，在 TensorFlow 中常用 score 变量表示。接下来再回到 call() 方法中，这里得到了 score 变量，接下来可以对齐求 softmax() 操作，得到 $ \alpha_{ij} $：

1	alignments = self._probability_fn(score, previous_alignments)

这就代表了在 $ i $ 时刻，Decoder 的时候对 Encoder 得到的每个 $ hj $ 的权重大小比例，在 TensorFlow 中常用 alignments 变量表示。所以综上所述，BahdanauAttention 就是初始化时传入 num_units 以及 Encoder Outputs，然后调时传入 query 用即可得到权重变量 alignments。

AttentionWrapperState

接下来我们再看下 AttentionWrapperState 这个类，这个类其实比较简单，就是定义了 Attention 过程中可能需要保存的变量，如 cell_state、attention、time、alignments 等内容，同时也便于后期的可视化呈现，代码实现如下：

class AttentionWrapperState(
    collections.namedtuple("AttentionWrapperState",
                           ("cell_state", "attention", "time", "alignments",
                            "alignment_history"))):

可见它就是继承了 namedtuple 这个数据结构，其实整个 AttentionWrapperState 就像声明了一个结构体，可以传入需要的字段生成这个对象。

AttentionWrapper

了解了 Attention 机制及 BahdanauAttention 的原理之后，最后我们再来了解一下 AttentionWrapper，可能你用过很多其他的 Wrapper，如 DropoutWrapper、ResidualWrapper 等等，它们其实都是 RNNCell 的实例，其实 AttentionWrapper 也不例外，它对 RNNCell 进行了封装，封装后依然还是 RNNCell 的实例。一个普通的 RNN 模型，你要加入 Attention，只需要在 RNNCell 外面套一层 AttentionWrapper 并指定 AttentionMechanism 的实例就好了。而且如果要更换 AttentionMechanism，只需要改变 AttentionWrapper 的参数就好了，这可谓对 Attention 的实现架构完全解耦，配置非常灵活，TF 大法好！接下来我们首先来看下它的初始化方法，其参数是这样的：

def __init__(self,
    cell,
    attention_mechanism,
    attention_layer_size=None,
    alignment_history=False,
    cell_input_fn=None,
    output_attention=True,
    initial_cell_state=None,
    name=None):

下面对参数进行一一说明：

cell：An instance of RNNCell. RNNCell 的实例，这里可以是单个的 RNNCell，也可以是多个 RNNCell 组成的 MultiRNNCell。
attention_mechanism：即 AttentionMechanism 的实例，如 BahdanauAttention 对象，另外可以是多个 AttentionMechanism 组成的列表。
attention_layer_size：是数字或者数字做成的列表，如果是 None（默认），直接使用加权计算后得到的 Attention 作为输出，如果不是 None，那么 Attention 结果还会和 Output 进行拼接并做线性变换再输出。其代码实现如下：

if attention_layer_size is not None:
    attention_layer_sizes = tuple(attention_layer_size if isinstance(attention_layer_size, (list, tuple)) else (attention_layer_size,))
    if len(attention_layer_sizes) != len(attention_mechanisms):
        raise ValueError("If provided, attention_layer_size must contain exactly one integer per attention_mechanism, saw: %d vs %d" % (len(attention_layer_sizes), len(attention_mechanisms)))
    self._attention_layers = tuple(layers_core.Dense(attention_layer_size, name="attention_layer", use_bias=False, dtype=attention_mechanisms[i].dtype) for i, attention_layer_size in enumerate(attention_layer_sizes))
    self._attention_layer_size = sum(attention_layer_sizes)
else:
    self._attention_layers = None
    self._attention_layer_size = sum(attention_mechanism.values.get_shape()[-1].value for attention_mechanism in attention_mechanisms) 
    
for i, attention_mechanism in enumerate(self._attention_mechanisms):
    attention, alignments = _compute_attention(attention_mechanism, cell_output, previous_alignments[i], self._attention_layers[i] if self._attention_layers else None)
    alignment_history = previous_alignment_history[i].write(state.time, alignments) if self._alignment_history else ()

alignment_history：即是否将之前的 alignments 存储到 state 中，以便于后期进行可视化展示。
cell_input_fn：将 Input 进行处理的方式，默认会将上一步的 Attention 进行拼接操作，以免造成重复关注同样的内容。代码调用如下：

1	cell_inputs = self._cell_input_fn(inputs, state.attention)

output_attention：是否将 Attention 返回，如果是 False 则返回 Output，否则返回 Attention，默认是 True。
initial_cell_state：计算时的初始状态。
name：自定义名称。

AttentionWrapper 的核心方法在它的 call() 方法，即类似于 RNNCell 的 call() 方法，AttentionWrapper 类对其进行了重载，代码实现如下：

def call(self, inputs, state):
    # Step 1
    cell_inputs = self._cell_input_fn(inputs, state.attention)
    # Step 2
    cell_state = state.cell_state
    cell_output, next_cell_state = self._cell(cell_inputs, cell_state)
    # Step 3
    if self._is_multi:
        previous_alignments = state.alignments
        previous_alignment_history = state.alignment_history
    else:
        previous_alignments = [state.alignments]
        previous_alignment_history = [state.alignment_history]
    all_alignments = []
    all_attentions = []
    all_histories = []
    for i, attention_mechanism in enumerate(self._attention_mechanisms):
        attention, alignments = _compute_attention(attention_mechanism, cell_output, previous_alignments[i], self._attention_layers[i] if self._attention_layers else None)
        alignment_history = previous_alignment_history[i].write(state.time, alignments) if self._alignment_history else ()
        all_alignments.append(alignments)
        all_histories.append(alignment_history)
        all_attentions.append(attention)
    # Step 4
    attention = array_ops.concat(all_attentions, 1)
    # Step 5
    next_state = AttentionWrapperState(
        time=state.time + 1,
        cell_state=next_cell_state,
        attention=attention,
        alignments=self._item_or_tuple(all_alignments),
        alignment_history=self._item_or_tuple(all_histories))
    # Step 6
    if self._output_attention:
        return attention, next_state
    else:
        return cell_output, next_state

在这里将一些异常判断代码去除了，以便于结构看得更清晰。首先在第一步中，调用了 _cell_input_fn() 方法，对 inputs 和 state.attention 变量进行处理，默认是使用 concat() 函数拼接，作为当前时间步的输入。因为可能前一步的 Attention 可能对当前 Attention 有帮助，以免让模型连续两次将注意力放在同一个地方。在第二步中，其实就是调用了普通的 RNNCell 的 call() 方法，得到输出和下一步的状态。第三步中，这时得到的输出其实并没有用上 AttentionMechanism 中的 alignments 信息，所以当前的输出信息中我们并没有跟 Encoder 的信息做 Attention，所以这里还需要调用 _compute_attention() 方法进行权重的计算，其方法实现如下：

def _compute_attention(attention_mechanism, cell_output, previous_alignments, attention_layer):
    alignments = attention_mechanism(cell_output, previous_alignments=previous_alignments)
    expanded_alignments = array_ops.expand_dims(alignments, 1)
    context = math_ops.matmul(expanded_alignments, attention_mechanism.values)
    context = array_ops.squeeze(context, [1])
    if attention_layer is not None:
        attention = attention_layer(array_ops.concat([cell_output, context], 1))
    else:
        attention = context
    return attention, alignments

这个方法接收四个参数，其中 attentionmechanism 就是 AttentionMechanism 的实例，cell_output 就是当前 Output，previous_alignments 是上步的 alignments 信息，调用 attention_mechanism 计算之后就会得到当前步的 alignments 信息了，即 $ \alpha{ij} $。接下来再利用 alignments 信息进行加权运算，得到 attention 信息，即 $ c_{i} $，最后将二者返回。在第四步中，就是将 attention 结果每个时间步进行 concat，得到 attention vector。第五步中，声明 AttentionWrapperState 作为下一步的状态。第六步，判断是否要输出 Attention，如果是，输出 Attention 及下一步状态，否则输出 Outputs 及下一步状态。好，以上便是整个 AttentionWrapper 源码解析过程，了解了源码之后，再做模型优化的话就非常得心应手了。

参考来源

作者崔庆才发表于 2018-03-25 阅读次数：本文字数： 14k 阅读时长 ≈ 13 分钟

Python Requests库作者另一神器Pipenv的用法

前言

我们在运行 Python 项目的时候经常会遇到一些版本问题，例如 A 项目依赖于 Django 1.5，而 B 项目又依赖 Django 2.0，而我们的系统却只有一个 Python 解释器，我们所有的包都被装在了 Python 安装目录的 site-packages 目录下，所以 Django 只能是某个特定的版本，所以这样就会导致运行的时候导致 A 或 B 项目出现兼容问题。为了解决这个问题，我们可能会使用 virtualenv 来为项目创建一套独立的 Python 运行环境，或者我们可能会使用 Docker 容器来实现不同项目的隔离运行，但总的来说，它们使用起来其实并没有那么方便。另外在进行 Python 包管理时，requirements.txt 这样的包依赖标识文件也显得很鸡肋，在某些情况下可能会带来一些麻烦。为了解决这些问题，一个更加使用方便的包管理工具诞生了，叫做 Pipenv，接下来就让我们一起来了解一下它的用法。

简介

Pipenv，它的项目简介为 Python Development Workflow for Humans，是 Python 著名的 requests 库作者 kennethreitz 写的一个包管理工具，它可以为我们的项目自动创建和管理虚拟环境并非常方便地管理 Python 包，现在它也已经是 Python 官方推荐的包管理工具。 Pipenv 我们可以简单理解为 pip 和 virtualenv 的集合体，它可以为我们的项目自动创建和管理一个虚拟环境。virtualenv 在使用时我们需要手动创建一个虚拟环境然后激活，Pipenv 会自动创建。另外我们之前可能使用 requirements.txt 文件来标识项目所需要的依赖，但是这样会带来一些问题，如有的 requirements.txt 中只是将库名列出来了，没有严格指定版本号，这样就可能会导致不同时间安装的库版本是不同的，如 requirements.txt 文件中对 Django 的依赖只写了一个 django，可能在 2016 年的时候运行安装会安装 Django 的 1.x 版本，到了 2017 年就会安装 Django 的 2.x 版本，所以可能导致一些麻烦。为了解决这个问题，Pipenv 直接弃用了 requirements.txt，会同时它会使用一个叫做 Pipfile 和 Pipfile.lock 的文件来管理项目所需的依赖包，而不再是简单地使用 requirements.txt 文件来记录项目所需要的依赖。总的来说，Pipenv 可以解决如下问题：

我们不需要再手动创建虚拟环境，Pipenv 会自动为我们创建，它会在某个特定的位置创建一个 virtualenv 环境，然后调用 pipenv shell 命令切换到虚拟环境。
使用 requirements.txt 可能会导致一些问题，所以 Pipenv 使用 Pipfile 和 Pipfile.lock 来替代之，而且 Pipfile 如果不存在的话会自动创建，而且在安装、升级、移除依赖包的时候会自动更新 Pipfile 和 Pipfile.lock 文件。
广泛使用 Hash 校验，保证安全性。
可以更清晰地查看 Python 包及其关系，调用 pipenv graph 即可呈现，结果简单明了。
可通过自动加载 .env 读取环境变量，简化开发流程。

安装

本文内容基于 Python 3.6 说明，默认的 Python 解释器命令为 python3，包管理工具命令为 pip3。 Pipenv 是基于 Python 开发的包，所以可以直接用 pip 来安装，命令如下：

1	pip3 install pipenv

另外还有多种安装方式，如 Pipsi、Nix、Homebrew，安装方式可以参考：http://pipenv.readthedocs.io/en/latest/#install-pipenv-today。

基本使用

首先我们可以新建一个项目，例如叫做 PipenvTest，然后新建一个 Python 脚本，例如叫 main.py，内容为：

1 2	import django print(django.get_version())

直接用系统的 Python3 运行此脚本：

1	python3 main.py

结果如下：

1.11

我们可以看到系统安装的 Django 版本是 1.11。但是我们想要本项目基于 Django 2.x 开发，当然我们可以选择将系统的 Django 版本升级，但这样又可能会影响其他的项目的运行，所以这并不是一个好的选择。为了不影响系统环境的 Django 版本，所以我们可以用 Pipenv 来创建一个虚拟环境。在该目录下，输入 pipenv 命令即可查看命令的完整用法：

Usage: pipenv [OPTIONS] COMMAND [ARGS]...

Options:
  --update         Update Pipenv & pip to latest.
  --where          Output project home information.
  --venv           Output virtualenv information.
  --py             Output Python interpreter information.
  --envs           Output Environment Variable options.
  --rm             Remove the virtualenv.
  --bare           Minimal output.
  --completion     Output completion (to be eval'd).
  --man            Display manpage.
  --three / --two  Use Python 3/2 when creating virtualenv.
  --python TEXT    Specify which version of Python virtualenv should use.
  --site-packages  Enable site-packages for the virtualenv.
  --jumbotron      An easter egg, effectively.
  --version        Show the version and exit.
  -h, --help       Show this message and exit.


Usage Examples:
   Create a new project using Python 3.6, specifically:
   $ pipenv --python 3.6

   Install all dependencies for a project (including dev):
   $ pipenv install --dev

   Create a lockfile containing pre-releases:
   $ pipenv lock --pre

   Show a graph of your installed dependencies:
   $ pipenv graph

   Check your installed dependencies for security vulnerabilities:
   $ pipenv check

   Install a local setup.py into your virtual environment/Pipfile:
   $ pipenv install -e .

Commands:
  check      Checks for security vulnerabilities and against PEP 508 markers
             provided in Pipfile.
  graph      Displays currently–installed dependency graph information.
  install    Installs provided packages and adds them to Pipfile, or (if none
             is given), installs all packages.
  lock       Generates Pipfile.lock.
  open       View a given module in your editor.
  run        Spawns a command installed into the virtualenv.
  shell      Spawns a shell within the virtualenv.
  uninstall  Un-installs a provided package and removes it from Pipfile.
  update     Uninstalls all packages, and re-installs package(s) in [packages]
             to latest compatible versions.

接下来我们首先验证一下当前的项目是没有创建虚拟环境的，调用如下命令：

1	pipenv --venv

结果如下：

1	No virtualenv has been created for this project yet!

这说明当前的项目尚未创建虚拟环境，接下来我们利用 Pipenv 来创建一个虚拟环境：

1	pipenv --three

或

1	pipenv --python 3.6

都可以创建一个 Python3 的虚拟环境，—three 代表创建一个 Python3 版本的虚拟环境，—python 则可以指定特定的 Python 版本，当然 —two 则创建一个 Python2 版本的虚拟环境，但前提你的系统必须装有该版本的 Python 才可以。执行完毕之后，样例输出如下：

Warning: the environment variable LANG is not set!
We recommend setting this in ~/.profile (or equivalent) for proper expected behavior.
Creating a virtualenv for this project…
Using /usr/local/bin/python3 to create virtualenv…
⠋Running virtualenv with interpreter /usr/local/bin/python3
Using base prefix '/usr/local/Cellar/python3/3.6.1/Frameworks/Python.framework/Versions/3.6'
New python executable in /Users/CQC/.local/share/virtualenvs/PipenvTest-VSTVh89E/bin/python3.6
Also creating executable in /Users/CQC/.local/share/virtualenvs/PipenvTest-VSTVh89E/bin/python
Installing setuptools, pip, wheel...done.
Virtualenv location: /Users/CQC/.local/share/virtualenvs/PipenvTest-VSTVh89E

这里显示 Pipenv 利用 /usr/local/bin/python3 作为 virtualenv 的解释器，然后在 /Users/CQC/.local/share/virtualenvs/PipenvTest-VSTVh89E/bin 目录下创建了一个新的 Python3 解释器，同时还创建了两个可执行文件别名 python3.6 和 python，另外我们还可以发现目录下多了一个 Pipfile 文件，这时虚拟环境就创建完成了。我们切换到 PipenvTest-VSTVh89E/bin 目录查看一下文件结构，可以看到这里面包含了 pip、pip3、pip3.6、python、python3、python3.6 等可执行文件，实际上目录结构和使用 virtualenv 时是完全一样的，只不过文件夹的位置不同而已。接下来我们可以切换到该虚拟环境下执行命令，执行如下命令即可：

1	pipenv shell

执行完毕之后样例输出如下：

Spawning environment shell (/bin/zsh). Use 'exit' to leave.
source /Users/CQC/.local/share/virtualenvs/PipenvTest-VSTVh89E/bin/activate                                                            
CQC-MAC% source /Users/CQC/.local/share/virtualenvs/PipenvTest-VSTVh89E/bin/activate
(PipenvTest-VSTVh89E) CQC-MAC%

实际上这也和 virtualenv 激活的流程一样，也是调用了类似 source venv/bin/activate 方法将这个路径加到全局环境变量最前面，这样就会优先调用该路径下的 python、python3、python3.6 可执行文件了。这时候我们会发现命令行的样子就变了，前面多了一个 (PipenvTest-VSTVh89E) 的标识，代表当前我们已经切换到了虚拟环境下。这时我们用 which 或 where 命令查看一下 Python 可执行文件的路径，命令如下：

(PipenvTest-VSTVh89E) CQC-MAC% which python3
/Users/CQC/.local/share/virtualenvs/PipenvTest-VSTVh89E/bin/python3
(PipenvTest-VSTVh89E) CQC-MAC% which python3.6
/Users/CQC/.local/share/virtualenvs/PipenvTest-VSTVh89E/bin/python3.6
(PipenvTest-VSTVh89E) CQC-MAC% which python
/Users/CQC/.local/share/virtualenvs/PipenvTest-VSTVh89E/bin/python

可以发现当前的 Python 可执行路径都被切换到了 PipenvTest-VSTVh89E/bin 目录下，调用的是虚拟环境中的 Python 解释器，这时我们重新执行刚才的脚本，命令如下：

1	(PipenvTest-VSTVh89E) CQC-MAC% python3 main.py

这时我们可以发现报了如下错误：

Traceback (most recent call last):
  File "main.py", line 1, in <module>
    import django
ModuleNotFoundError: No module named 'django'

这其实是因为新的虚拟环境没有安装任何的 Python 第三方包，实际上如果直接使用 virtualenv 时也是这样的结果。这是因为新的虚拟环境是一个全新的 Python 环境，它默认只包含了 Python 内置的包以及 pip、wheel、setuptools 包，其他的第三方包都没有安装。这时我们可以使用 Pipenv 来安装 django 包，命令如下：

1	pipenv install django

运行后输出结果如下：

Installing django…
Collecting django
  Downloading Django-2.0.2-py3-none-any.whl (7.1MB)
Collecting pytz (from django)
  Downloading pytz-2018.3-py2.py3-none-any.whl (509kB)
Installing collected packages: pytz, django
Successfully installed django-2.0.2 pytz-2018.3

Adding django to Pipfile's [packages]…
Locking [dev-packages] dependencies…
Locking [packages] dependencies…
Updated Pipfile.lock (e101fb)!

如果有这样的输出结果就代表成功安装了 Django，可以看到此时安装的 Django 版本为 2.0，代表我们的虚拟环境成功安装了 Django 2.0 版本。同时我们还注意到它输出了一句话叫做 Updated Pipfile.lock，这时我们可以发现项目路径下又生成了一个 Pipfile.lock 文件，内容如下：

{
    "_meta": {
        "hash": {
            "sha256": "7b9623243d9c22b1f333ee710aff70d0cbcdf1dd7e0aac69230dc76855d27270"
        },
        "host-environment-markers": {
            "implementation_name": "cpython",
            "implementation_version": "3.6.1",
            "os_name": "posix",
            "platform_machine": "x86_64",
            "platform_python_implementation": "CPython",
            "platform_release": "17.4.0",
            "platform_system": "Darwin",
            "platform_version": "Darwin Kernel Version 17.4.0: Sun Dec 17 09:19:54 PST 2017; root:xnu-4570.41.2~1/RELEASE_X86_64",
            "python_full_version": "3.6.1",
            "python_version": "3.6",
            "sys_platform": "darwin"
        },
        "pipfile-spec": 6,
        "requires": {},
        "sources": [
            {
                "name": "pypi",
                "url": "https://pypi.python.org/simple",
                "verify_ssl": true
            }
        ]
    },
    "default": {
        "django": {
            "hashes": [
                "sha256:af18618ce3291be5092893d8522fe3919661bf3a1fb60e3858ae74865a4f07c2",
                "sha256:9614851d4a7ff8cbd32b73c6076441f377c45a5bbff7e771798fb02c43c31f47"
            ],
            "version": "==2.0.2"
        },
        "pytz": {
            "hashes": [
                "sha256:ed6509d9af298b7995d69a440e2822288f2eca1681b8cce37673dbb10091e5fe",
                "sha256:f93ddcdd6342f94cea379c73cddb5724e0d6d0a1c91c9bdef364dc0368ba4fda",
                "sha256:61242a9abc626379574a166dc0e96a66cd7c3b27fc10868003fa210be4bff1c9",
                "sha256:ba18e6a243b3625513d85239b3e49055a2f0318466e0b8a92b8fb8ca7ccdf55f",
                "sha256:07edfc3d4d2705a20a6e99d97f0c4b61c800b8232dc1c04d87e8554f130148dd",
                "sha256:3a47ff71597f821cd84a162e71593004286e5be07a340fd462f0d33a760782b5",
                "sha256:5bd55c744e6feaa4d599a6cbd8228b4f8f9ba96de2c38d56f08e534b3c9edf0d",
                "sha256:887ab5e5b32e4d0c86efddd3d055c1f363cbaa583beb8da5e22d2fa2f64d51ef",
                "sha256:410bcd1d6409026fbaa65d9ed33bf6dd8b1e94a499e32168acfc7b332e4095c0"
            ],
            "version": "==2018.3"
        }
    },
    "develop": {}
}

可以看到里面标识了 Python 环境基本信息，以及依赖包的版本及 hashes 值。另外我们还可以注意到 Pipfile 文件内容也有更新，[packages] 部分多了一句 django = ““，标识了本项目依赖于 Django，这个其实类似于 requirements.txt 文件。那么到这里有小伙伴可能就会问了， Pipfile 和 Pipfile.lock 有什么用呢？ Pipfile 其实一个 TOML 格式的文件，标识了该项目依赖包的基本信息，还区分了生产环境和开发环境的包标识，作用上类似 requirements.txt 文件，但是功能更为强大。Pipfile.lock 详细标识了该项目的安装的包的精确版本信息、最新可用版本信息和当前库文件的 hash 值，顾明思义，它起了版本锁的作用，可以注意到当前 Pipfile.lock 文件中的 Django 版本标识为 ==2.0.2，意思是当前我们开发时使用的就是 2.0.2 版本，它可以起到版本锁定的功能。举个例子，刚才我们安装了 Django 2.0.2 的版本，即目前（2018.2.27）的最新版本。但可能 Django 以后还会有更新，比如某一天 Django 更新到了 2.1 版本，这时如果我们想要重新部署本项目到另一台机器上，假如此时不存在 Pipfile.lock 文件，只存在 Pipfile文件，由于 Pipfile 文件中标识的 Django 依赖为 django = ““，即没有版本限制，它会默认安装最新版本的 Django，即 2.1，但由于 Pipfile.lock 文件的存在，它会根据 Pipfile.lock 来安装，还是会安装 Django 2.0.2，这样就会避免一些库版本更新导致不兼容的问题。请记住：任何情况下都不要手动修改 Pipfile.lock 文件！好，接下来我们再回归正题，现在已经安装好了 Django 了，那么我们重新运行此脚本便可以成功输出 Django 版本信息了：

1	(PipenvTest-VSTVh89E) CQC-MAC% python3 main.py

结果如下：

2.0.2

这样我们就成功安装了 Django 2.x 了，和系统的 Django 1.11 没有任何冲突。在此模式的命令行下，我们就可以使用虚拟环境下的 Python 解释器，而且所安装的依赖包对外部系统没有任何影响，而且使用 Pipfile 和 Pipfile.lock 来管理项目的依赖更加方便和健壮。如果想要退出虚拟环境，只需要输入 exit 命令即可：

1
2
3

(PipenvTest-VSTVh89E) CQC-MAC% exit
➜  PipenvTest python3 main.py 
1.11

输入退出命令之后，我们重新再运行此脚本，就会重新使用系统的 Python 解释器，Django 版本又重新回到了 1.11。由此可以看来，有了 Pipenv，我们可以使用 Pipfile 和 Pipfile.lock 来方便地管理和维护项目的依赖包，而且可以实现虚拟环境运行，避免了包冲突问题，可谓一举两得。

常用命令

上文我们介绍了 Pipenv 的基本操作，下面我们再介绍一下它的一些常用命令。

虚拟环境路径

我们可以使用 —venv 参数来获得虚拟环境路径：

1	pipenv --venv

样例输出如下：

1	/Users/CQC/.local/share/virtualenvs/PipenvTest-VSTVh89E

可见这个路径是一个标准的路径，Pipenv 会把虚拟环境统一放到 virtualenvs 文件夹下，而不是本项目路径下。

Python 解释器路径

要获取虚拟环境 Python 解释器路径，可以使用 —py 参数：

1	pipenv --py

样例输出如下：

1	/Users/CQC/.local/share/virtualenvs/PipenvTest-VSTVh89E/bin/python

加载系统 Python 包

默认情况下，新创建的虚拟环境是不包含任何第三方包的，但我们也可以开启加载系统 Python 包功能，使用 —site-packages 即可：

1	pipenv --site-packages

这样创建的虚拟环境便可以使用系统已安装的 Python 包了。

开启虚拟环境

要开启虚拟环境只需要执行如下命令：

1	pipenv shell

这样就可以进入虚拟环境，此时运行的 python、python3 命令都是虚拟环境下的。

安装 Python 包

安装 Python 包我们不再需要 pip 来安装，直接使用 Pipenv 也可安装，如安装 requests，命令如下：

1	pipenv install requests

安装完成之后会同时更新项目目录下的 Pipfile 和 Pipfile.lock 文件。有时候一些 Python 包是仅仅开发环境需要的，如 pytest，这时候我们通过添加 —dev 参数即可，命令如下：

1	pipenv install pytest --dev

这时候，pytest 的依赖便会记录在 Pipfile 的 [dev-packages] 区域：

1 2	[dev-packages] pytest = "*"

获取包依赖

我们可以使用命令来清晰地呈现出当前安装的 Python 包版本及之间的依赖关系，命令如下：

1	pipenv graph

样例结果如下：

Django==2.0.2
  - pytz [required: Any, installed: 2018.3]
pytest==3.4.1
  - attrs [required: >=17.2.0, installed: 17.4.0]
  - pluggy [required: <0.7,>=0.5, installed: 0.6.0]
  - py [required: >=1.5.0, installed: 1.5.2]
  - setuptools [required: Any, installed: 38.5.1]
  - six [required: >=1.10.0, installed: 1.11.0]
requests==2.18.4
  - certifi [required: >=2017.4.17, installed: 2018.1.18]
  - chardet [required: >=3.0.2,<3.1.0, installed: 3.0.4]
  - idna [required: <2.7,>=2.5, installed: 2.6]
  - urllib3 [required: <1.23,>=1.21.1, installed: 1.22]

可以看到结果非常清晰，Django 当前安装了 2.0.2版本，依赖于 pytz 任何版本，已经安装了 2018.3 版本；pytest 已经安装了 3.4.1 版本，依赖 attrs>=17.2.0 版本，已经安装了 17.4.0 版本，另外还依赖 pluggy、py、setuptools、six 这些库。总之包的依赖关系一目了然。

卸载 Python 包

卸载 Python 包也非常简单，如卸载 requests 包，命令如下：

1	pipenv uninstall requests

卸载完成之后，Pipfile 和 Pipfile.lock 文件同样会更新。如果要卸载全部 Python 包，可以添加 —all 参数：

1	pipenv uninstall --all

产生 Pipfile.lock

有时候可能 Pipfile.lock 文件不存在或被删除了，这时候我们可以使用如下命令生成：

1	pipenv lock

以上便是一些常用的 Pipenv 命令，如果要查看更多用法可以参考其官方文档：https://docs.pipenv.org/#pipenv-usage。

结语

本文介绍了 Pipenv 的基本用法，作为 pip 和 virtualenv 的结合体，我们可以利用它更方便地创建和管理 Python 虚拟环境，还可以用更加科学的方式管理 Python 包，一举两得。嗯，是时候抛弃 virtualenv 和 pip 了！

作者崔庆才发表于 2018-03-15 阅读次数：本文字数： 12k 阅读时长 ≈ 10 分钟

Python 中文分词原理及工具

原理

中文分词，即 Chinese Word Segmentation，即将一个汉字序列进行切分，得到一个个单独的词。表面上看，分词其实就是那么回事，但分词效果好不好对信息检索、实验结果还是有很大影响的，同时分词的背后其实是涉及各种各样的算法的。中文分词与英文分词有很大的不同，对英文而言，一个单词就是一个词，而汉语是以字为基本的书写单位，词语之间没有明显的区分标记，需要人为切分。根据其特点，可以把分词算法分为四大类：

基于规则的分词方法
基于统计的分词方法
基于语义的分词方法
基于理解的分词方法

下面我们对这几种方法分别进行总结。

基于规则的分词方法

这种方法又叫作机械分词方法、基于字典的分词方法，它是按照一定的策略将待分析的汉字串与一个“充分大的”机器词典中的词条进行匹配。若在词典中找到某个字符串，则匹配成功。该方法有三个要素，即分词词典、文本扫描顺序和匹配原则。文本的扫描顺序有正向扫描、逆向扫描和双向扫描。匹配原则主要有最大匹配、最小匹配、逐词匹配和最佳匹配。

最大匹配法（MM）。基本思想是：假设自动分词词典中的最长词条所含汉字的个数为 i，则取被处理材料当前字符串序列中的前 i 个字符作为匹配字段，查找分词词典，若词典中有这样一个 i 字词，则匹配成功，匹配字段作为一个词被切分出来；若词典中找不到这样的一个 i 字词，则匹配失败，匹配字段去掉最后一个汉字，剩下的字符作为新的匹配字段，再进行匹配，如此进行下去，直到匹配成功为止。统计结果表明，该方法的错误率为 1/169。
逆向最大匹配法（RMM）。该方法的分词过程与 MM 法相同，不同的是从句子（或文章）末尾开始处理，每次匹配不成功时去掉的是前面的一个汉字。统计结果表明，该方法的错误率为 1/245。
逐词遍历法。把词典中的词按照由长到短递减的顺序逐字搜索整个待处理的材料，一直到把全部的词切分出来为止。不论分词词典多大，被处理的材料多么小，都得把这个分词词典匹配一遍。
设立切分标志法。切分标志有自然和非自然之分。自然切分标志是指文章中出现的非文字符号，如标点符号等；非自然标志是利用词缀和不构成词的词（包括单音词、复音节词以及象声词等）。设立切分标志法首先收集众多的切分标志，分词时先找出切分标志，把句子切分为一些较短的字段，再用 MM、RMM 或其它的方法进行细加工。这种方法并非真正意义上的分词方法，只是自动分词的一种前处理方式而已，它要额外消耗时间扫描切分标志，增加存储空间存放那些非自然切分标志。
最佳匹配法（OM）。此法分为正向的最佳匹配法和逆向的最佳匹配法，其出发点是：在词典中按词频的大小顺序排列词条，以求缩短对分词词典的检索时间，达到最佳效果，从而降低分词的时间复杂度，加快分词速度。实质上，这种方法也不是一种纯粹意义上的分词方法，它只是一种对分词词典的组织方式。OM 法的分词词典每条词的前面必须有指明长度的数据项，所以其空间复杂度有所增加，对提高分词精度没有影响，分词处理的时间复杂度有所降低。

此种方法优点是简单，易于实现。但缺点有很多：匹配速度慢；存在交集型和组合型歧义切分问题；词本身没有一个标准的定义，没有统一标准的词集；不同词典产生的歧义也不同；缺乏自学习的智能性。

基于统计的分词方法

该方法的主要思想：词是稳定的组合，因此在上下文中，相邻的字同时出现的次数越多，就越有可能构成一个词。因此字与字相邻出现的概率或频率能较好地反映成词的可信度。可以对训练文本中相邻出现的各个字的组合的频度进行统计，计算它们之间的互现信息。互现信息体现了汉字之间结合关系的紧密程度。当紧密程度高于某一个阈值时，便可以认为此字组可能构成了一个词。该方法又称为无字典分词。该方法所应用的主要的统计模型有：N 元文法模型（N-gram）、隐马尔可夫模型（Hiden Markov Model，HMM）、最大熵模型（ME）、条件随机场模型（Conditional Random Fields，CRF）等。在实际应用中此类分词算法一般是将其与基于词典的分词方法结合起来，既发挥匹配分词切分速度快、效率高的特点，又利用了无词典分词结合上下文识别生词、自动消除歧义的优点。

基于语义的分词方法

语义分词法引入了语义分析，对自然语言自身的语言信息进行更多的处理，如扩充转移网络法、知识分词语义分析法、邻接约束法、综合匹配法、后缀分词法、特征词库法、矩阵约束法、语法分析法等。

扩充转移网络法。该方法以有限状态机概念为基础。有限状态机只能识别正则语言，对有限状态机作的第一次扩充使其具有递归能力，形成递归转移网络（RTN）。在RTN 中，弧线上的标志不仅可以是终极符（语言中的单词）或非终极符（词类），还可以调用另外的子网络名字分非终极符（如字或字串的成词条件）。这样，计算机在运行某个子网络时，就可以调用另外的子网络，还可以递归调用。词法扩充转移网络的使用，使分词处理和语言理解的句法处理阶段交互成为可能，并且有效地解决了汉语分词的歧义。
矩阵约束法。其基本思想是：先建立一个语法约束矩阵和一个语义约束矩阵，其中元素分别表明具有某词性的词和具有另一词性的词相邻是否符合语法规则，属于某语义类的词和属于另一词义类的词相邻是否符合逻辑，机器在切分时以之约束分词结果。

基于理解的分词方法

基于理解的分词方法是通过让计算机模拟人对句子的理解，达到识别词的效果。其基本思想就是在分词的同时进行句法、语义分析，利用句法信息和语义信息来处理歧义现象。它通常包括三个部分：分词子系统、句法语义子系统、总控部分。在总控部分的协调下，分词子系统可以获得有关词、句子等的句法和语义信息来对分词歧义进行判断，即它模拟了人对句子的理解过程。这种分词方法需要使用大量的语言知识和信息。目前基于理解的分词方法主要有专家系统分词法和神经网络分词法等。

专家系统分词法。从专家系统角度把分词的知识（包括常识性分词知识与消除歧义切分的启发性知识即歧义切分规则）从实现分词过程的推理机中独立出来，使知识库的维护与推理机的实现互不干扰，从而使知识库易于维护和管理。它还具有发现交集歧义字段和多义组合歧义字段的能力和一定的自学习功能。
神经网络分词法。该方法是模拟人脑并行，分布处理和建立数值计算模型工作的。它将分词知识所分散隐式的方法存入神经网络内部，通过自学习和训练修改内部权值，以达到正确的分词结果，最后给出神经网络自动分词结果，如使用 LSTM、GRU 等神经网络模型等。
神经网络专家系统集成式分词法。该方法首先启动神经网络进行分词，当神经网络对新出现的词不能给出准确切分时，激活专家系统进行分析判断，依据知识库进行推理，得出初步分析，并启动学习机制对神经网络进行训练。该方法可以较充分发挥神经网络与专家系统二者优势，进一步提高分词效率。

以上便是对分词算法的基本介绍，接下来我们再介绍几个比较实用的分词 Python 库及它们的使用方法。

分词工具

在这里介绍几个比较有代表性的支持分词的 Python 库，主要有：

1. jieba

专用于分词的 Python 库，GitHub：https://github.com/fxsjy/jieba，分词效果较好。支持三种分词模式：

精确模式，试图将句子最精确地切开，适合文本分析。
全模式，将句子中所有的可能成词的词语都扫描出来，速度非常快，但是不能解决歧义。
搜索引擎模式：在精确模式的基础上，对长词再次切分，提高召回率，适用于搜索引擎分词。

另外 jieba 支持繁体分词，支持自定义词典。其使用的算法是基于统计的分词方法，主要有如下几种：

基于前缀词典实现高效的词图扫描，生成句子中汉字所有可能成词情况所构成的有向无环图 (DAG)
采用了动态规划查找最大概率路径, 找出基于词频的最大切分组合
对于未登录词，采用了基于汉字成词能力的 HMM 模型，使用了 Viterbi 算法

精确模式分词

首先我们来看下精确模式分词，使用 lcut() 方法，类似 cut() 方法，其参数和 cut() 是一致的，只不过返回结果是列表而不是生成器，默认使用精确模式，代码如下：

import jieba
string = '这个把手该换了，我不喜欢日本和服，别把手放在我的肩膀上，工信处女干事每月经过下属科室都要亲口交代24口交换机等技术性器件的安装工作'
result = jieba.lcut(string)
print(len(result), '/'.join(result))

结果：

38 这个/把手/该换/了/，/我/不/喜欢/日本/和服/，/别/把手/放在/我/的/肩膀/上/，/工信处/女干事/每月/经过/下属/科室/都/要/亲口/交代/24/口/交换机/等/技术性/器件/的/安装/工作

可见分词效果还是不错的。

全模式分词

使用全模式分词需要添加 cut_all 参数，将其设置为 True，代码如下：

1 2	result = jieba.lcut(string, cut_all=True) print(len(result), '/'.join(result))

结果如下：

51 这个/把手/该换/了///我/不/喜欢/日本/和服///别/把手/放在/我/的/肩膀/上///工信处/处女/女干事/干事/每月/月经/经过/下属/科室/都/要/亲口/口交/交代/24/口交/交换/交换机/换机/等/技术/技术性/性器/器件/的/安装/安装工/装工/工作

搜索引擎模式分词

使用搜索引擎模式分词需要调用 cut_for_search() 方法，代码如下：

1 2	result = jieba.lcut_for_search(string) print(len(result), '/'.join(result))

结果如下：

42 这个/把手/该换/了/，/我/不/喜欢/日本/和服/，/别/把手/放在/我/的/肩膀/上/，/工信处/干事/女干事/每月/经过/下属/科室/都/要/亲口/交代/24/口/交换/换机/交换机/等/技术/技术性/器件/的/安装/工作

另外可以加入自定义词典，如我们想把日本和服作为一个整体，可以把它添加到词典中，代码如下：

1
2
3

jieba.add_word('日本和服')
result = jieba.lcut(string)
print(len(result), '/'.join(result))

结果如下：

37 这个/把手/该换/了/，/我/不/喜欢/日本和服/，/别/把手/放在/我/的/肩膀/上/，/工信处/女干事/每月/经过/下属/科室/都/要/亲口/交代/24/口/交换机/等/技术性/器件/的/安装/工作

可以看到切分结果中，日本和服四个字就作为一个整体出现在结果中了，分词数量比精确模式少了一个。

词性标注

另外 jieba 还支持词性标注，可以输出分词后每个词的词性，实例如下：

1 2	words = pseg.lcut(string) print(list(map(lambda x: list(x), words)))

运行结果：

[['这个', 'r'], ['把手', 'v'], ['该', 'r'], ['换', 'v'], ['了', 'ul'], ['，', 'x'], ['我', 'r'], ['不', 'd'], ['喜欢', 'v'], ['日本和服', 'x'], ['，', 'x'], ['别', 'r'], ['把手', 'v'], ['放在', 'v'], ['我', 'r'], ['的', 'uj'], ['肩膀', 'n'], ['上', 'f'], ['，', 'x'], ['工信处', 'n'], ['女干事', 'n'], ['每月', 'r'], ['经过', 'p'], ['下属', 'v'], ['科室', 'n'], ['都', 'd'], ['要', 'v'], ['亲口', 'n'], ['交代', 'n'], ['24', 'm'], ['口', 'n'], ['交换机', 'n'], ['等', 'u'], ['技术性', 'n'], ['器件', 'n'], ['的', 'uj'], ['安装', 'v'], ['工作', 'vn']]

关于词性的说明可以参考：https://gist.github.com/luw2007/6016931。

2. SnowNLP

SnowNLP: Simplified Chinese Text Processing，可以方便的处理中文文本内容，是受到了 TextBlob 的启发而写的，由于现在大部分的自然语言处理库基本都是针对英文的，于是写了一个方便处理中文的类库，并且和 TextBlob 不同的是，这里没有用 NLTK，所有的算法都是自己实现的，并且自带了一些训练好的字典。GitHub地址：https://github.com/isnowfy/snownlp。

分词

这里的分词是基于 Character-Based Generative Model 来实现的，论文地址：http://aclweb.org/anthology//Y/Y09/Y09-2047.pdf，我们还是以上面的例子说明，相关使用说明如下：

from snownlp import SnowNLP

string = '这个把手该换了，我不喜欢日本和服，别把手放在我的肩膀上，工信处女干事每月经过下属科室都要亲口交代24口交换机等技术性器件的安装工作'
s = SnowNLP(string)
result = s.words
print(len(result), '/'.join(result))

运行结果：

40 这个/把手/该/换/了/，/我/不/喜欢/日本/和/服/，/别把手/放在/我/的/肩膀/上/，/工/信处女/干事/每月/经过/下属/科室/都/要/亲口/交代/24/口/交换机/等/技术性/器件/的/安装/工作

经过观察，可以发现分词效果其实不怎么理想，和服被分开了，工信处也被分开了，女干事也被分开了。另外 SnowNLP 还支持很多功能，例如词性标注（HMM）、情感分析、拼音转换（Trie树）、关键词和摘要生成（TextRank）。我们简单看一个实例：

1
2
3

print('Tags:', list(s.tags))
print('Sentiments:', s.sentiments)
print('Pinyin:', s.pinyin)

运行结果：

1
2
3

Tags: [('这个', 'r'), ('把手', 'Ng'), ('该', 'r'), ('换', 'v'), ('了', 'y'), ('，', 'w'), ('我', 'r'), ('不', 'd'), ('喜欢', 'v'), ('日本', 'ns'), ('和', 'c'), ('服', 'v'), ('，', 'w'), ('别把手', 'ad'), ('放在', 'v'), ('我', 'r'), ('的', 'u'), ('肩膀', 'n'), ('上', 'f'), ('，', 'w'), ('工', 'j'), ('信处女', 'j'), ('干事', 'n'), ('每月', 'r'), ('经过', 'p'), ('下属', 'v'), ('科室', 'n'), ('都', 'd'), ('要', 'v'), ('亲口', 'd'), ('交代', 'v'), ('24', 'm'), ('口', 'q'), ('交换机', 'n'), ('等', 'u'), ('技术性', 'n'), ('器件', 'n'), ('的', 'u'), ('安装', 'vn'), ('工作', 'vn')]
Sentiments: 0.015678817603646866
Pinyin: ['zhe', 'ge', 'ba', 'shou', 'gai', 'huan', 'liao', '，', 'wo', 'bu', 'xi', 'huan', 'ri', 'ben', 'he', 'fu', '，', 'bie', 'ba', 'shou', 'fang', 'zai', 'wo', 'de', 'jian', 'bang', 'shang', '，', 'gong', 'xin', 'chu', 'nv', 'gan', 'shi', 'mei', 'yue', 'jing', 'guo', 'xia', 'shu', 'ke', 'shi', 'dou', 'yao', 'qin', 'kou', 'jiao', 'dai', '24', 'kou', 'jiao', 'huan', 'ji', 'deng', 'ji', 'shu', 'xing', 'qi', 'jian', 'de', 'an', 'zhuang', 'gong', 'zuo']

3. THULAC

THULAC（THU Lexical Analyzer for Chinese）由清华大学自然语言处理与社会人文计算实验室研制推出的一套中文词法分析工具包，GitHub 链接：https://github.com/thunlp/THULAC-Python，具有中文分词和词性标注功能。THULAC具有如下几个特点：

能力强。利用集成的目前世界上规模最大的人工分词和词性标注中文语料库（约含5800万字）训练而成，模型标注能力强大。
准确率高。该工具包在标准数据集Chinese Treebank（CTB5）上分词的F1值可达97.3％，词性标注的F1值可达到92.9％，与该数据集上最好方法效果相当。
速度较快。同时进行分词和词性标注速度为300KB/s，每秒可处理约15万字。只进行分词速度可达到1.3MB/s。

我们用一个实例看一下分词效果：

import thulac

string = '这个把手该换了，我不喜欢日本和服，别把手放在我的肩膀上，工信处女干事每月经过下属科室都要亲口交代24口交换机等技术性器件的安装工作'
t = thulac.thulac()
result = t.cut(string)
print(result)

运行结果：

[['这个', 'r'], ['把手', 'n'], ['该', 'v'], ['换', 'v'], ['了', 'u'], ['，', 'w'], ['我', 'r'], ['不', 'd'], ['喜欢', 'v'], ['日本', 'ns'], ['和服', 'n'], ['，', 'w'], ['别把手', 'n'], ['放', 'v'], ['在', 'p'], ['我', 'r'], ['的', 'u'], ['肩膀', 'n'], ['上', 'f'], ['，', 'w'], ['工信处', 'n'], ['女', 'a'], ['干事', 'n'], ['每月', 'r'], ['经过', 'p'], ['下属', 'v'], ['科室', 'n'], ['都', 'd'], ['要', 'v'], ['亲口', 'd'], ['交代', 'v'], ['24', 'm'], ['口', 'q'], ['交换机', 'n'], ['等', 'u'], ['技术性', 'n'], ['器件', 'n'], ['的', 'u'], ['安装', 'v'], ['工作', 'v']]

4. NLPIR

NLPIR 分词系统，前身为2000年发布的 ICTCLAS 词法分析系统，GitHub 链接：https://github.com/NLPIR-team/NLPIR，是由北京理工大学张华平博士研发的中文分词系统，经过十余年的不断完善，拥有丰富的功能和强大的性能。NLPIR是一整套对原始文本集进行处理和加工的软件，提供了中间件处理效果的可视化展示，也可以作为小规模数据的处理加工工具。主要功能包括：中文分词，词性标注，命名实体识别，用户词典、新词发现与关键词提取等功能。另外对于分词功能，它有 Python 实现的版本，GitHub 链接：https://github.com/tsroten/pynlpir。使用方法如下：

import pynlpir

pynlpir.open()
string = '这个把手该换了，我不喜欢日本和服，别把手放在我的肩膀上，工信处女干事每月经过下属科室都要亲口交代24口交换机等技术性器件的安装工作'
result = pynlpir.segment(string)
print(result)

运行结果如下：

[('这个', 'pronoun'), ('把', 'preposition'), ('手', 'noun'), ('该', 'pronoun'), ('换', 'verb'), ('了', 'modal particle'), ('，', 'punctuation mark'), ('我', 'pronoun'), ('不', 'adverb'), ('喜欢', 'verb'), ('日本', 'noun'), ('和', 'conjunction'), ('服', 'verb'), ('，', 'punctuation mark'), ('别', 'adverb'), ('把', 'preposition'), ('手', 'noun'), ('放', 'verb'), ('在', 'preposition'), ('我', 'pronoun'), ('的', 'particle'), ('肩膀', 'noun'), ('上', 'noun of locality'), ('，', 'punctuation mark'), ('工', 'noun'), ('信', 'noun'), ('处女', 'noun'), ('干事', 'noun'), ('每月', 'pronoun'), ('经过', 'preposition'), ('下属', 'verb'), ('科室', 'noun'), ('都', 'adverb'), ('要', 'verb'), ('亲口', 'adverb'), ('交代', 'verb'), ('24', 'numeral'), ('口', 'classifier'), ('交换机', 'noun'), ('等', 'particle'), ('技术性', 'noun'), ('器件', 'noun'), ('的', 'particle'), ('安装', 'verb'), ('工作', 'verb')]

这里把手和和服也被分开了。

5. NLTK

NLTK，Natural Language Toolkit，是一个自然语言处理的包工具，各种多种 NLP 处理相关功能，GitHub 链接：https://github.com/nltk/nltk。但是 NLTK 对于中文分词是不支持的，示例如下：

from nltk import word_tokenize

string = '这个把手该换了，我不喜欢日本和服，别把手放在我的肩膀上，工信处女干事每月经过下属科室都要亲口交代24口交换机等技术性器件的安装工作'
result = word_tokenize(string)
print(result)

结果：

1	['这个把手该换了，我不喜欢日本和服，别把手放在我的肩膀上，工信处女干事每月经过下属科室都要亲口交代24口交换机等技术性器件的安装工作']

如果要用中文分词的话，可以使用 FoolNLTK，它使用 Bi-LSTM 训练而成，包含分词、词性标注、实体识别等功能，同时支持自定义词典，可以训练自己的模型，可以进行批量处理。使用方法如下：

import fool

string = '这个把手该换了，我不喜欢日本和服，别把手放在我的肩膀上，工信处女干事每月经过下属科室都要亲口交代24口交换机等技术性器件的安装工作'
result = fool.cut(string)
print(result)

运行结果：

[['这个', '把手', '该', '换', '了', '，', '我', '不', '喜欢', '日本', '和服', '，', '别', '把', '手', '放', '在', '我', '的', '肩膀', '上', '，', '工信处', '女', '干事', '每月', '经过', '下属', '科室', '都', '要', '亲', '口', '交代', '24', '口', '交换机', '等', '技术性', '器件', '的', '安装', '工作']]

可以看到这个分词效果还是不错的。另外还可以进行词性标注，实体识别：

result = fool.pos_cut(string)
print(result)
_, ners = fool.analysis(string)
print(ners)

运行结果：

1
2

[[('这个', 'r'), ('把手', 'n'), ('该', 'r'), ('换', 'v'), ('了', 'y'), ('，', 'wd'), ('我', 'r'), ('不', 'd'), ('喜欢', 'vi'), ('日本', 'ns'), ('和服', 'n'), ('，', 'wd'), ('别', 'd'), ('把', 'pba'), ('手', 'n'), ('放', 'v'), ('在', 'p'), ('我', 'r'), ('的', 'ude'), ('肩膀', 'n'), ('上', 'f'), ('，', 'wd'), ('工信处', 'ns'), ('女', 'b'), ('干事', 'n'), ('每月', 'r'), ('经过', 'p'), ('下属', 'v'), ('科室', 'n'), ('都', 'd'), ('要', 'v'), ('亲', 'a'), ('口', 'n'), ('交代', 'v'), ('24', 'm'), ('口', 'q'), ('交换机', 'n'), ('等', 'udeng'), ('技术性', 'n'), ('器件', 'n'), ('的', 'ude'), ('安装', 'n'), ('工作', 'n')]]
[[(12, 15, 'location', '日本')]]

6. LTP

语言技术平台（Language Technology Platform，LTP）是哈工大社会计算与信息检索研究中心历时十年开发的一整套中文语言处理系统。LTP制定了基于XML的语言处理结果表示，并在此基础上提供了一整套自底向上的丰富而且高效的中文语言处理模块（包括词法、句法、语义等6项中文处理核心技术），以及基于动态链接库（Dynamic Link Library, DLL）的应用程序接口、可视化工具，并且能够以网络服务（Web Service）的形式进行使用。 LTP 有 Python 版本，GitHub地址：https://github.com/HIT-SCIR/pyltp，另外运行的时候需要下载模型，模型还比较大，下载地址：http://ltp.ai/download.html。示例代码如下：

from pyltp import Segmentor

string = '这个把手该换了，我不喜欢日本和服，别把手放在我的肩膀上，工信处女干事每月经过下属科室都要亲口交代24口交换机等技术性器件的安装工作'
segmentor = Segmentor()
segmentor.load('./cws.model')
result = list(segmentor.segment(string))
segmentor.release()
print(result)

运行结果：

41 这个/把手/该/换/了/，/我/不/喜欢/日本/和服/，/别/把/手/放在/我/的/肩膀/上/，/工信/处女/干事/每月/经过/下属/科室/都/要/亲口/交代/24/口/交换机/等/技术性/器件/的/安装/工作

可以发现工信处、女干事没有正确分开。以上便是一些分词库的基本使用，个人比较推荐的有 jieba、THULAC、FoolNLTK。

参考来源

作者崔庆才发表于 2018-03-15 阅读次数：本文字数： 11k 阅读时长 ≈ 10 分钟

Python 深度学习 GPU环境 Ubuntu 16.04 + Nvidia GTX 1080 + Python 3.6 + CUDA 9.0 + cuDNN 7.1 + TensorFlow 1.6 环境配置

本节详细说明一下深度学习环境配置，Ubuntu 16.04 + Nvidia GTX 1080 + Python 3.6 + CUDA 9.0 + cuDNN 7.1 + TensorFlow 1.6。

Python 3.6

首先安装 Python 3.6，这里使用 Anaconda 3 来安装，下载地址：https://www.anaconda.com/download/#linux，点击 Download 按钮下载即可，这里下载的是 Anaconda 3-5.1 版本，如果下载速度过慢可以选择使用清华镜像：https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/。下载下来之后目录下会出现一个 Anaconda3-5.1.0-Linux-x86_64.sh 文件，然后直接执行即可安装：

1	bash Anaconda3-5.1.0-Linux-x86_64.sh

执行完毕之后按照默认设置走下来即可完成安装。这里默认它会安装到用户目录下，如果想全局安装，可以在这一步输入你要安装的地址：

Anaconda3 will now be installed into this location:
/home/cqc/anaconda3

  - Press ENTER to confirm the location
  - Press CTRL-C to abort the installation
  - Or specify a different location below

[/home/cqc/anaconda3] >>> /usr/local/anaconda3
PREFIX=/usr/local/anaconda3

这里我指定了将其安装到 /usr/local/anaconda3 目录下，全局安装，所有用户共享，当然如果只想本用户使用的话使用默认配置即可。安装完成之后添加 python3 和 pip3 的软链接：

1 2	sudo ln -s /usr/local/anaconda3/bin/python3 /usr/local/sbin/python3 sudo ln -s /usr/local/anaconda3/bin/pip /usr/local/sbin/pip3

这里是将软连接其添加到 /usr/local/sbin 目录下了，它默认会存在于环境变量中，因此可以直接调用。当然也可以选择把 /usr/local/anaconda3/bin 目录添加到环境变量中，可以修改 ~/.bashrc 文件，添加如下内容：

1	export PATH=/usr/local/anaconda3/bin${PATH:+:${PATH}}

然后执行：

1	source ~/.bashrc

即可生效，下次登录时也会默认执行 ~/.bashrc 文件，也会生效。接下来我们验证下 python3、pip3 命令是否都来自 Anaconda，命令如下：

1 2	pip3 -V pip 9.0.1 from /usr/local/anaconda3/lib/python3.6/site-packages (python 3.6)

which python3
/usr/local/anaconda3/bin/python3
python3
Python 3.6.4 |Anaconda, Inc.| (default, Jan 16 2018, 18:10:19) 
[GCC 7.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

如果输入 pip3 和 python3 命令能出现如上类似结果，路径都在 /usr/local/anaconda3，就证明 Python 3 安装成功了。

安装驱动

首先查看一下自己的电脑需要怎样的驱动，我们可以先到 http://www.nvidia.com/Download/index.aspx 查询下我们需要的是怎样的驱动，这里我的显卡是 GTX 1080，所以以此为例说明，勾选好对应的配置：点击 Search，可以看到查询结果如下所示：

Version:    390.25
Release Date:    2018.1.29
Operating System:    Linux 64-bit
Language:    English (US)
File Size:    77.48 MB

这里说明我们需要的版本是 390.25。接下来如果我们之前安装了驱动的话，可以重新安装一下，如果当前已经安装好了就不必了。如果要重装，需要首先卸载掉之前的显卡驱动：

1	sudo apt-get remove –purge nvidia*

运行之后 NVIDIA 的一些驱动就被卸载了。这时候 nvidia-smi 等命令已经不能用了，这就证明显卡驱动已经被卸载了。然后接下来添加一个 PPA 源，命令如下：

1	sudo add-apt-repository ppa:graphics-drivers/ppa

然后更新一下：

1	sudo apt-get update

随后重新安装显卡驱动：

1	sudo apt-get install nvidia-390

注意这里的 390 就是刚才我们查询出来的版本，以实际查询出来的版本为准。

CUDA 9.0

如果存在之前的旧版本，可以选择先卸载，以免和新的 CUDA 版本产生冲突，在 /usr/local/cuda/bin 目录下有一个 uninstallcuda*.pl 文件，可以直接运行卸载，命令如下：

1	sudo ./uninstall_cuda_*.pl

这样即可将 CUDA 全部卸载。接下来我们再下载 CUDA 9.0，注意 TensorFlow 1.5 和 1.6 版本依然只是兼容 CUDA 9.0，没有兼容 CUDA 9.1，所以不要下载 9.1，CUDA 9.0 的下载地址是：https://developer.nvidia.com/cuda-90-download-archive，然后依次勾选好系统的版本，如图所示：这里我们选择 Linux-x86_64-Ubuntu-16.04-runfile 的配置，然后点击 Base Installer 部分的 Download 按钮，下载 CUDA 9.0 安装包。对应的下载命令是：

1	wget https://developer.nvidia.com/compute/cuda/9.0/Prod/local_installers/cuda_9.0.176_384.81_linux-run

执行此命令，等待下载完成即可。接下来执行安装，运行如下命令：

1	sudo bash cuda_9.0.176_384.81_linux-run

安装过程需要输入一些确认选项，过程如下：

Description

The NVIDIA CUDA Toolkit provides command-line and graphical
tools for building, debugging and optimizing the performance
Do you accept the previously read EULA?
accept/decline/quit: accept

Install NVIDIA Accelerated Graphics Driver for Linux-x86_64 384.81?
(y)es/(n)o/(q)uit: n

Install the CUDA 9.0 Toolkit?
(y)es/(n)o/(q)uit: y

Enter Toolkit Location
 [ default is /usr/local/cuda-9.0 ]: 

Do you want to install a symbolic link at /usr/local/cuda?
(y)es/(n)o/(q)uit: y

Install the CUDA 9.0 Samples?
(y)es/(n)o/(q)uit: y

Enter CUDA Samples Location
 [ default is /home/cqc ]: 

Installing the CUDA Toolkit in /usr/local/cuda-9.0 ...

最后如果出现这样的提示，就证明 CUDA 安装好了：

Driver:   Not Selected
Toolkit:  Installed in /usr/local/cuda-9.0
Samples:  Installed in /home/cqc, but missing recommended libraries

Please make sure that
 -   PATH includes /usr/local/cuda-9.0/bin
 -   LD_LIBRARY_PATH includes /usr/local/cuda-9.0/lib64, or, add /usr/local/cuda-9.0/lib64 to /etc/ld.so.conf and run ldconfig as root

To uninstall the CUDA Toolkit, run the uninstall script in /usr/local/cuda-9.0/bin

Please see CUDA_Installation_Guide_Linux.pdf in /usr/local/cuda-9.0/doc/pdf for detailed information on setting up CUDA.

***WARNING: Incomplete installation! This installation did not install the CUDA Driver. A driver of version at least 384.00 is required for CUDA 9.0 functionality to work.
To install the driver using this installer, run the following command, replacing <CudaInstaller> with the name of this run file:
    sudo <CudaInstaller>.run -silent -driver

然后我们需要配置一下环境变量，更改 ~/.bashrc 文件，添加如下几行：

1
2
3

export PATH=/usr/local/cuda/bin${PATH:+:${PATH}}
export LD_LIBRARY_PATH=/usr/local/cuda/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}
export CUDA_HOME=/usr/local/cuda

修改完毕之后执行一下使其生效：

1	source ~/.bashrc

这时我们输出 CUDA_HOME、LD_LIBRARY_PATH 就可以看到对应的输出了：

echo $CUDA_HOME
/usr/local/cuda
echo $LD_LIBRARY_PATH
/usr/local/cuda/lib64

这样就代表环境变量生效了，CUDA 安装完成。

cuDNN 7.1

cuDNN 的全称是 The NVIDIA CUDA® Deep Neural Network library，是专门用来对深度学习加速的库，它支持 Caffe2, MATLAB, Microsoft Cognitive Toolkit, TensorFlow, Theano 及 PyTorch 等深度学习的加速优化，目前最新版本是 cuDNN 7.1，接下来我们来看下它的安装方式。下载链接：https://developer.nvidia.com/rdp/cudnn-download，需要注册之后才能打开，这里我们选择 cuDNN v7.1.1 (Feb 28, 2018), for CUDA 9.0，然后选择 cuDNN v7.1.1 Library for Linux，如图所示：下载下来之后解压安装即可：

tar -zxvf cudnn-9.0-linux-x64-v7.1.tgz
sudo cp cuda/include/cudnn.h /usr/local/cuda/include/
sudo cp cuda/lib64/libcudnn* /usr/local/cuda/lib64/ -d
sudo chmod a+r /usr/local/cuda/include/cudnn.h
sudo chmod a+r /usr/local/cuda/lib64/libcudnn*

执行完如上命令之后，cuDNN 就安装好了，这时我们可以发现在 /usr/local/cuda/include 目录下就多了 cudnn.h 头文件。

TensorFlow 1.6

到现在为止 Python 3.6、CUDA 9.0 和 cuDNN 7.1 就已经安装好了，而且环境变量也配置好了，接下来我们直接安装 TensorFlow 1.6 即可，TensorFlow 1.6 版本针对 CUDA 9 和 cuDNN 7 做了优化，可以预构建二进制文件。这里需要安装的是 TensorFlow 的 GPU 版本，命令如下：

1	pip3 install tensorflow-gpu==1.6.0

安装完成之后验证一下：

1	import tensorflow

如果没有报错，那就证明全部环境配置都成功了。以上便是 Ubuntu 16.04 + Nvidia GTX 1080 + Python 3.6 + CUDA 9.0 + cuDNN 7.1 + TensorFlow 1.6 完整环境配置过程。

作者崔庆才发表于 2018-03-12 阅读次数：本文字数： 5.5k 阅读时长 ≈ 5 分钟

Linux Linux常用命令总结

系统

查看系统版本：

1	cat /proc/version

实例结果：

1	Linux version 4.4.0-112-generic (buildd@lgw01-amd64-010) (gcc version 5.4.0 20160609 (Ubuntu 5.4.0-6ubuntu1~16.04.5) ) #135-Ubuntu SMP Fri Jan 19 11:48:36 UTC 2018

CPU

查看CPU信息：

1	cat /proc/cpuinfo

示例结果：

processor       : 0
vendor_id       : GenuineIntel
cpu family      : 6
model           : 63
model name      : Intel(R) Xeon(R) CPU E5-2673 v3 @ 2.40GHz
stepping        : 2
microcode       : 0x3a
cpu MHz         : 1200.000
cache size      : 30720 KB
physical id     : 0
siblings        : 24
core id         : 0
cpu cores       : 12
apicid          : 0
initial apicid  : 0
fpu             : yes
fpu_exception   : yes
cpuid level     : 15
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx pdpe1gb rdtscp lm constant_tsc arch_perfmon pebs bts rep_good nopl xtopology nonstop_tsc aperfmperf eagerfpu pni pclmulqdq dtes64 monitor ds_cpl vmx smx est tm2 ssse3 sdbg fma cx16 xtpr pdcm pcid dca sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand lahf_lm abm epb invpcid_single kaiser tpr_shadow vnmi flexpriority ept vpid fsgsbase tsc_adjust bmi1 avx2 smep bmi2 erms invpcid cqm xsaveopt cqm_llc cqm_occup_llc dtherm ida arat pln pts
bugs            :
bogomips        : 4800.24
clflush size    : 64
cache_alignment : 64
address sizes   : 46 bits physical, 48 bits virtual
power management:

processor       : 1
vendor_id       : GenuineIntel
cpu family      : 6
model           : 63
model name      : Intel(R) Xeon(R) CPU E5-2673 v3 @ 2.40GHz
stepping        : 2
microcode       : 0x3a
cpu MHz         : 1207.687
cache size      : 30720 KB
physical id     : 0
siblings        : 24
core id         : 1
cpu cores       : 12
apicid          : 2
initial apicid  : 2
fpu             : yes
fpu_exception   : yes
cpuid level     : 15
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx pdpe1gb rdtscp lm constant_tsc arch_perfmon pebs bts rep_good nopl xtopology nonstop_tsc aperfmperf eagerfpu pni pclmulqdq dtes64 monitor ds_cpl vmx smx est tm2 ssse3 sdbg fma cx16 xtpr pdcm pcid dca sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand lahf_lm abm epb invpcid_single kaiser tpr_shadow vnmi flexpriority ept vpid fsgsbase tsc_adjust bmi1 avx2 smep bmi2 erms invpcid cqm xsaveopt cqm_llc cqm_occup_llc dtherm ida arat pln pts
bugs            :
bogomips        : 4800.24
clflush size    : 64
cache_alignment : 64
address sizes   : 46 bits physical, 48 bits virtual
power management:

内存

查看内存及用量（M为单位）：

free -m

示例结果：

1
2
3

              total        used        free      shared  buff/cache   available
Mem:         128806        7115      115910          77        5780      120877
Swap:             0           0           0

查看内存及用量（G为单位）：

free -g

示例结果：

1
2
3

              total        used        free      shared  buff/cache   available
Mem:            125           6         113           0           5         118
Swap:             0           0           0

硬盘用量

查看各分区使用情况：

df -h

示例结果：

Filesystem      Size  Used Avail Use% Mounted on
udev             63G     0   63G   0% /dev
tmpfs            13G   66M   13G   1% /run
/dev/sda1       224G  101G  113G  48% /
tmpfs            63G  352K   63G   1% /dev/shm
tmpfs           5.0M  4.0K  5.0M   1% /run/lock

查看当前目录文件及文件夹大小：

du -sh *

示例结果：

6.9G    anaconda3
213M    cuda_samples
7.9M    Desktop
8.0K    Documents
7.1G    Downloads

GPU

查看 GPU 使用情况：

1	nvidia-smi

示例结果：

Sun Mar 11 15:34:14 2018       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 384.111                Driver Version: 384.111                   |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce GTX 1080    Off  | 00000000:02:00.0  On |                  N/A |
|  0%   36C    P8    15W / 320W |    224MiB /  8105MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Type   Process name                             Usage      |
|=============================================================================|
|    0      1322      G   /usr/lib/xorg/Xorg                           178MiB |
|    0      1880      G   compiz                                        43MiB |
+-----------------------------------------------------------------------------+

进程

查看所有进程：

ps -ef

示例结果：

UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 Feb09 ?        00:00:15 /sbin/init splash
root         2     0  0 Feb09 ?        00:00:00 [kthreadd]
root         3     2  0 Feb09 ?        00:00:05 [ksoftirqd/0]
root         5     2  0 Feb09 ?        00:00:00 [kworker/0:0H]
root         6     2  0 Feb09 ?        00:00:01 [kworker/u96:0]

筛选进程：

1	ps -ef \| grep python

示例结果：

1
2

chen      6466 44495  0 Mar09 ?        00:01:56 /usr/bin/python2 -m ipykernel_launcher -f /run/user/1000/jupyter/kernel-218926a1-f3b9-4410-bffb-1de1341732be.json
chen     11630 44495  0 Mar09 ?        00:00:13 /home/chen/anaconda3/bin/python -m ipykernel_launcher -f /run/user/1000/jupyter/kernel-c2942b7d-d73c-420a-b6be-78f0169e68c9.json

根据名称强制杀死进程：

1	ps -ef \| grep python \| cut -c 9-15 \| xargs kill -9

用户

添加用户：

1	sudo adduser username

添加用户并设置目录：

1	sudo adduser username --home /home/username

将用户设置超级用户组（如添加到 sudo 用户组）：

1	sudo usermod -aG sudo username

查看所有用户组：

groups

查看某个用户组下所有用户：

1 2	sudo apt-get install members members sudo

作者崔庆才发表于 2018-03-11 阅读次数：本文字数： 4.3k 阅读时长 ≈ 4 分钟

Python 正则表达式中零宽断言的用法

了解了正则表达式，想必一般情况下的匹配都不会出现什么问题，但是如果一些特殊情况，可能需要用到一些更高级的正则表达式匹配操作，本节我们来说明一下正则表达式的一个较常用又比较重要的知识点——零宽断言。

实例引入

首先我们来看一个例子，这里有一段问答对话：

问：我用的是Windows XP+Service Pack 2，为什么无法安装输入卡号和密码的控件？答：在Windows XP+Service Pack 2、Windows 2003等操作系统中，用户可以自己选择是否安装控件。问：为什么我看到的卡号输入框显示为*符号？答：您的浏览器禁止下载执行ActiveX控件 , 对于这种情况 , 您必须打开浏览器的ActiveX的相关权限。操作方法：在浏览器菜单中选择“工具”|“Internet选项”，在弹出的对话框中选择”安全” |”Internet”|”自定义级别”，在弹出的对话框中选择”重置为安全级-中” , 点”重置”按钮，确定。问：看了以上几个问题，还是不能登录，怎么办？答：您的浏览器由于其他原因不能安装招商银行登录控件，请下载并安装招商银行登录控件下载版。问：无法出现个人网上银行大众版登录界面。答：这种情况是由于您的机器无法和我行服务器建立安全连接，通常是因为代理服务器设置错误引起。如果您是拨号上网，请不要使用代理服务器；如果您过去安装过我行SSL安全代理，请调用“添加-删除程序”删除SSL安全代理；如果您是经过代理访问Internet，请联系您所在网的网络管理员设置代理服务器。IE5.0浏览器设置代理服务器的步骤： Internet选项—>连接—>局域网设置—>使用代理服务器—>高级。问：我在输入账号和卡号时，总出错，该怎样输？答：存折账号为10位，按存折本上的账号输入，密码为6位。如果一卡通是12位卡号的，只需输入地区码后面的8位卡号，不需要输入前面4位的地区码，密码为6位。如果一卡通是16位卡号的，请将16位卡号全部输入，密码为6位。问：我的存折没有设密码，怎样在个人网上银行大众版中查询余额？答：存折必须设有密码方可在个人网上银行大众版中查询，因此请您到存折开户行给您的存折设置密码。注：网上个人银行是招商银行为个人客户提供的网上银行。本页面内容仅供参考，部分业务以当地网点的公告与具体规定为准。

我们需要将这段对话中的问题和答案对提取出来，即提取出如下内容：

Q：我用的是Windows XP+Service Pack 2，为什么无法安装输入卡号和密码的控件？ A：在Windows XP+Service Pack 2、Windows 2003等操作系统中，用户可以自己选择是否安装控件。 Q：为什么我看到的卡号输入框显示为*符号？ A：您的浏览器禁止下载执行ActiveX控件 , 对于这种情况 , 您必须打开浏览器的ActiveX的相关权限。操作方法：在浏览器菜单中选择“工具”|“Internet选项”，在弹出的对话框中选择”安全” |”Internet”|”自定义级别”，在弹出的对话框中选择”重置为安全级-中” , 点”重置”按钮，确定。 …

如果要用 Python 实现的话，那么我们很可能自然而然想到 split() 或 findall() 方法，如果用 split() 方法，我们可能会这么写：

import re
results = re.split('问：| 答：', text)
for index, result in enumerate(results[1:]):
    print(('Q' if index%2 == 0 else 'A') + ': ' + result)

这里 split() 方法的第一个参数传入了 问：| 答： 这个正则表达式，意思是将这段话用 问： 或者 答： 分开，这个功能是正则表达式对字符串进行分割的方法，相比直接字符串的 split() 方法功能更为强大。这里其实得到的结果是一个列表，长度是一个奇数，如果我们把 results 打印出来，结果是这样的：

['', '我用的是Windows XP+Service Pack 2，为什么无法安装输入卡号和密码的控件？', '在Windows XP+Service Pack 2、Windows 2003等操作系统中，用户可以自己选择是否安装控件。 ', '为什么我看到的卡号输入框显示为*符号？', '您的浏览器禁止下载执行ActiveX控件 , 对于这种情况 , 您必须打开浏览器的ActiveX的相关权限。 操作方法：在浏览器菜单中选择“工具”|“Internet选项”，在弹出的对话框中选择"安全" |"Internet"|"自定义级别"，在弹出的对话框中选择"重置为 安全级-中" , 点"重置"按钮，确定。 ', '看了以上几个问题，还是不能登录，怎么办？', '您的浏览器由于其他原因不能安装招商银行登录控件， 请下载并安装招商银行登录控件下载版。 ', '无法出现个人网上银行大众版登录界面。', '这种情况是由于您的机器无法和我行服务器建立安全连接，通常是因为代理服务器设置错误引起。如果您是拨号上网，请不要使用代理服务器；如果您过去安装过我行SSL安全代理，请调用“添加-删除程序”删除SSL安全代理；如果您是经过代理访问Internet，请联系您所在网的网络管理员设置代理服务器。IE5.0浏览器设置代理服务器的步骤： Internet选项-->连接-->局域网设置-->使用代理服务器-->高级。 ', '我在输入账号和卡号时，总出错，该怎样输？', '存折账号为10位，按存折本上的账号输入， 密码为6位。如果一卡通是12位卡号的，只需输入地区码后面的8位卡号，不需要输入前面4位的地区码，密码为6位。如果一卡通是16位卡号的，请将16位卡号全部输入，密码为6位。 ', '我的存折没有设密码，怎样在个人网上银行大众版中查询余额？', '存折必须设有密码方可在 个人网上银行大众版 中查询，因此请您到存折开户行给您的存折设置密码。 注：网上个人银行是招商银行为个人客户提供的网上银行。 本页面内容仅供参考，部分业务以当地网点的公告与具体规定为准。 ']

这是因为我们分割使用的字符本身就处于整个文本的字符，所以一上来就找到了分割的标志 问：，所以它左侧的结果就是空字符串了，所以最终得到的结果第一个内容就是空字符串，后续的内容便是正常的一问一答的短句。所以这里我们还需要对结果进行切片操作，去除第一个元素，然后将其遍历打印输出，最终结果如下：

Q: 我用的是Windows XP+Service Pack 2，为什么无法安装输入卡号和密码的控件？
A: 在Windows XP+Service Pack 2、Windows 2003等操作系统中，用户可以自己选择是否安装控件。 
Q: 为什么我看到的卡号输入框显示为*符号？
A: 您的浏览器禁止下载执行ActiveX控件 , 对于这种情况 , 您必须打开浏览器的ActiveX的相关权限。 操作方法：在浏览器菜单中选择“工具”|“Internet选项”，在弹出的对话框中选择"安全" |"Internet"|"自定义级别"，在弹出的对话框中选择"重置为 安全级-中" , 点"重置"按钮，确定。 
Q: 看了以上几个问题，还是不能登录，怎么办？
A: 您的浏览器由于其他原因不能安装招商银行登录控件， 请下载并安装招商银行登录控件下载版。 
Q: 无法出现个人网上银行大众版登录界面。
A: 这种情况是由于您的机器无法和我行服务器建立安全连接，通常是因为代理服务器设置错误引起。如果您是拨号上网，请不要使用代理服务器；如果您过去安装过我行SSL安全代理，请调用“添加-删除程序”删除SSL安全代理；如果您是经过代理访问Internet，请联系您所在网的网络管理员设置代理服务器。IE5.0浏览器设置代理服务器的步骤： Internet选项-->连接-->局域网设置-->使用代理服务器-->高级。 
Q: 我在输入账号和卡号时，总出错，该怎样输？
A: 存折账号为10位，按存折本上的账号输入， 密码为6位。如果一卡通是12位卡号的，只需输入地区码后面的8位卡号，不需要输入前面4位的地区码，密码为6位。如果一卡通是16位卡号的，请将16位卡号全部输入，密码为6位。 
Q: 我的存折没有设密码，怎样在个人网上银行大众版中查询余额？
A: 存折必须设有密码方可在 个人网上银行大众版 中查询，因此请您到存折开户行给您的存折设置密码。 注：网上个人银行是招商银行为个人客户提供的网上银行。 本页面内容仅供参考，部分业务以当地网点的公告与具体规定为准。

这样确实没问题，我们可以顺利地提取出来，但是总感觉这个解法并不那么优雅，因为我们这里是将问题和答案的内容都单独切出来了，并没有将问答对一块提取，而且 split() 方法返回的结果的第一个元素还不是我们想要的结果，所以还需要进行一些切片操作来去除，所以整个写法感觉实现起来并不完美。所以我们又想到了 findall() 方法，这时我们会这么写：

import re
results = re.findall('问：(.*?) 答：(.*?)', text, re.S)
for result in results:
    print('Q: ' + result[0], 'A: ' + result[1], sep='\n')

表面上看似乎是把问题答案对用正则表示出来了，而且使用了非贪婪匹配，但是很明显，在末尾我们并没有指定匹配的终点，所以整个的结果就会导致回答是完全匹配不到的，运行结果如下：

Q: 我用的是Windows XP+Service Pack 2，为什么无法安装输入卡号和密码的控件？
A: 
Q: 为什么我看到的卡号输入框显示为*符号？
A: 
Q: 看了以上几个问题，还是不能登录，怎么办？
A: 
Q: 无法出现个人网上银行大众版登录界面。
A: 
Q: 我在输入账号和卡号时，总出错，该怎样输？
A: 
Q: 我的存折没有设密码，怎样在个人网上银行大众版中查询余额？
A:

好，那么我们加上匹配的终点吧，以下一个的 问： 作为我们正则表达式匹配的终点总可以了吧？所以我们可能会改写成这样子：

import re
results = re.findall('问：(.*?) 答：(.*?)问：', text, re.S)
for result in results:
    print('Q: ' + result[0], 'A: ' + result[1], sep='\n')

这样写似乎看起来是可以了，但结果却是这样的：

Q: 我用的是Windows XP+Service Pack 2，为什么无法安装输入卡号和密码的控件？
A: 在Windows XP+Service Pack 2、Windows 2003等操作系统中，用户可以自己选择是否安装控件。 
Q: 看了以上几个问题，还是不能登录，怎么办？
A: 您的浏览器由于其他原因不能安装招商银行登录控件， 请下载并安装招商银行登录控件下载版。 
Q: 我在输入账号和卡号时，总出错，该怎样输？
A: 存折账号为10位，按存折本上的账号输入， 密码为6位。如果一卡通是12位卡号的，只需输入地区码后面的8位卡号，不需要输入前面4位的地区码，密码为6位。如果一卡通是16位卡号的，请将16位卡号全部输入，密码为6位。

结果只剩三个问题答案对了，有三个问答对被“吃”掉了，其实这是因为我们的正则表达式最后加了 问:的缘故，findall() 方法它会查找所有符合正则表达式的结果，但其中匹配的时候它内部也是有一个查找索引在扫描的。在查找第一个符合要求的结果时，由于我们是根据正则表达式结尾的 问：来作为结束标志，所以在找到第一个符合要求的结果时，我们的查找索引就已经移动到了第二个问答对开头的 问： 上面，即查找索引就已经进入到了第二个问答对的位置了，而在下一次查找符合要求的结果时，索引会继续往后移动进行扫描，所以它是从第二个问答对的 问： 后面继续扫描的，所以对于第二个问答对，实际上已经被割裂了，所以它只能查找到第三个问答对的时候才可以发现符合正则表达式的内容。因此，我们可以观察到，返回的结果只是第一、三、五三个问答对。所以，如果我们想要用该方法找到完整的留个问答对，就需要用到零宽断言了。解法如下：

import re
results = re.findall('问：(.*?) 答：(.*?)(?=问：|\Z)', text, re.S)
for result in results:
    print('Q: ' + result[0], 'A: ' + result[1], sep='\n')

运行结果如下：

Q: 我用的是Windows XP+Service Pack 2，为什么无法安装输入卡号和密码的控件？
A: 在Windows XP+Service Pack 2、Windows 2003等操作系统中，用户可以自己选择是否安装控件。 
Q: 为什么我看到的卡号输入框显示为*符号？
A: 您的浏览器禁止下载执行ActiveX控件 , 对于这种情况 , 您必须打开浏览器的ActiveX的相关权限。 操作方法：在浏览器菜单中选择“工具”|“Internet选项”，在弹出的对话框中选择"安全" |"Internet"|"自定义级别"，在弹出的对话框中选择"重置为 安全级-中" , 点"重置"按钮，确定。 
Q: 看了以上几个问题，还是不能登录，怎么办？
A: 您的浏览器由于其他原因不能安装招商银行登录控件， 请下载并安装招商银行登录控件下载版。 
Q: 无法出现个人网上银行大众版登录界面。
A: 这种情况是由于您的机器无法和我行服务器建立安全连接，通常是因为代理服务器设置错误引起。如果您是拨号上网，请不要使用代理服务器；如果您过去安装过我行SSL安全代理，请调用“添加-删除程序”删除SSL安全代理；如果您是经过代理访问Internet，请联系您所在网的网络管理员设置代理服务器。IE5.0浏览器设置代理服务器的步骤： Internet选项-->连接-->局域网设置-->使用代理服务器-->高级。 
Q: 我在输入账号和卡号时，总出错，该怎样输？
A: 存折账号为10位，按存折本上的账号输入， 密码为6位。如果一卡通是12位卡号的，只需输入地区码后面的8位卡号，不需要输入前面4位的地区码，密码为6位。如果一卡通是16位卡号的，请将16位卡号全部输入，密码为6位。 
Q: 我的存折没有设密码，怎样在个人网上银行大众版中查询余额？
A: 存折必须设有密码方可在 个人网上银行大众版 中查询，因此请您到存折开户行给您的存折设置密码。 注：网上个人银行是招商银行为个人客户提供的网上银行。 本页面内容仅供参考，部分业务以当地网点的公告与具体规定为准。

这里我们实际上是使用了 (?=)这样的形式来构建了整个表达式，等号后面的内容是 问：或者结束符 \\Z，这样其实就保证了在匹配的时候，查找索引不会继续向后移，但这也同时标志了结束标志，因此它就可以查找到完整的内容了。

零宽断言

零宽断言，顾名思义，是一种零宽度的匹配，它匹配的内容不会保存到匹配结果中，表达式的匹配内容只是代表了一个位置而已，如标明某个字符的右边界是怎样的构造。在前面我们使用了 ?=来进行了实例讲解，这是其中一个用法，另外还有 ?<=、?!、?<!，下面我们来依次进行讲解说明。

?=代表零宽度正预测先行断言，它断言自身出现的位置的后面可以匹配后面跟的表达式。
?<=代表零宽度正回顾后发断言，它断言自身出现的位置的前面可以匹配后面跟的表达式。
?!代表零宽度负预测先行断言，它断言自身出现的位置的后面不可以匹配后面跟的表达式。
?<!代表零宽度负回顾后发断言，它断言自身出现的位置的后面不可以匹配后面跟的表达式。

?=

首先我们来看下 ?=的用法，它断言自身出现的位置的后面可以匹配后面跟的表达式。比如我们这里有这样的一个字符串：

1	str = '我的个人邮箱是cqc@cuiqingcai.com，个人博客是cuiqingcai.com，个人公众号是进击的Coder'

在这里我们想把我的个人邮箱这句话和个人邮箱单独摘出来，假如我们不使用零宽断言的话，我们需要给个人邮箱后面这一句加一个结束标识符或者单独匹配邮箱作为标识符，我们可能会这么写：

import re
str = '我的个人邮箱是cqc@cuiqingcai.com，个人博客是cuiqingcai.com，个人公众号是进击的Coder'
result = re.search('我的个人邮箱是(.*?)，个人博客', str)
print('整句结果：' + result.group(), '第一个匹配结果：' + result.group(1), sep='\n')

在正则表达式的最后我们加了，个人博客作为匹配的结束符，然后邮箱部分用非贪婪匹配的模式进行匹配，我们看下运行结果：

1 2	整句结果：我的个人邮箱是cqc@cuiqingcai.com，个人博客第一个匹配结果：cqc@cuiqingcai.com

我们可以看到第一个匹配结果成功得到了邮箱信息，但是我们看整句结果缺并不理想，它多匹配了我们加入的结尾标识，并没有得到正常的一句话。这时候如果我们改用 ?=来匹配，结果就不会带有此标识符了，改写如下：

import re
str = '我的个人邮箱是cqc@cuiqingcai.com，个人博客是cuiqingcai.com，个人公众号是进击的Coder'
result = re.search('我的个人邮箱是(.*?)(?=，个人博客)', str)
print('整句结果：' + result.group(), '第一个匹配结果：' + result.group(1), sep='\n')

在这里我们将结尾标识符改成了 (?=，个人博客) ，这样就将此部分内容作为零宽度匹配，它代表后面需要跟 ，个人博客，但是它不会出现在匹配结果中。运行结果如下：

1 2	整句结果：我的个人邮箱是cqc@cuiqingcai.com 第一个匹配结果：cqc@cuiqingcai.com

可以看到整句结果中已经没有无用的后缀字符了。

?<=

接下来我们再看下 ?<=的用法，它代表零宽度正回顾后发断言，其实就是匹配前面的标识，比如这里我们还是以上面的例子为例，匹配出个人博客这句话，代码如下：

import re
str = '我的个人邮箱是cqc@cuiqingcai.com，个人博客是cuiqingcai.com，个人公众号是进击的Coder'
result = re.search('(?<=，)个人博客是(.*?)(?=，)', str)
print('整句结果：' + result.group(), '第一个匹配结果：' + result.group(1), sep='\n')

这里我们在个人博客 前面加了一个零宽断言的逗号符号作为开头，使用的就是 ?<=，句子结尾是用的 ?=，这样前后的标识都不会匹配到了，运行结果如下：

1 2	整句结果：个人博客是cuiqingcai.com 第一个匹配结果：cuiqingcai.com

可以看到得到的整句结果也是完整的一句话。

?!

?!代表代表零宽度负预测先行断言，它断言自身出现的位置的后面不可以匹配后面跟的表达式。也是用来匹配后面的文本，但这里是取反，它指定了后面出现的内容不匹配该标识，我们在前面的例子基础上修改如下：

import re
str = '我的个人邮箱是cqc@cuiqingcai.com，个人博客是cuiqingcai.com，个人公众号是进击的Coder'
result = re.search('我的个人邮箱是(.*?)(?!，个人公众号)(?=，个人博客)', str)
print('整句结果：' + result.group(), '第一个匹配结果：' + result.group(1), sep='\n')

本来是 (?=，个人博客)的标识符，不过这里我们使用 ?!来指定了另一个标识符，个人公众号，这就代表这句话后面跟的需要是(?=，个人博客)而不是，个人公众号，运行结果如下：

1 2	整句结果：我的个人邮箱是cqc@cuiqingcai.com 第一个匹配结果：cqc@cuiqingcai.com

?<!

?<!代表零宽度负回顾后发断言，它断言自身出现的位置的后面不可以匹配后面跟的表达式。我们在前面的例子基础上加以修改：

import re
str = '我的个人邮箱是cqc@cuiqingcai.com，个人博客是cuiqingcai.com，个人公众号是进击的Coder'
result = re.search('(?<=，)(?<!。)个人博客是(.*?)(?=，)', str)
print('整句结果：' + result.group(), '第一个匹配结果：' + result.group(1), sep='\n')

这里我们写了 ?<!标识符，后面跟了一个句号，这代表前面不应该出现句号。运行结果如下：

1 2	整句结果：个人博客是cuiqingcai.com 第一个匹配结果：cuiqingcai.com

常用用法

其实上面的示例中我们使用了 search() 方法进行了内容匹配，其实这并不常用，因为一般我们更关注的是匹配分组结果的内容，其实更多的用法是用在了 findall() 方法上，它用来匹配多个结果，也就类似于我们一开始的实例一样，这里我们还是以刚才的字符串为例，来输出一下个人邮箱、个人博客、个人公众号三个内容，代码如下：

import re
str = '我的个人邮箱是cqc@cuiqingcai.com，个人博客是cuiqingcai.com，个人公众号是进击的Coder'
results = re.findall('个人(.*?)是(.*?)(?=，|\Z)', str)
for result in results:
    print(result[0] + ': ' + result[1])

这里我们匹配了个人二字，然后后面跟了非贪婪匹配，然后加了一个是字，最关键的是结尾标识符，这里必须要使用零宽断言才可以匹配出三个结果，这里匹配的内容是 ，|\\Z，意思是匹配逗号或结束符。运行结果如下：

1
2
3

邮箱: cqc@cuiqingcai.com
博客: cuiqingcai.com
公众号: 进击的Coder

这样我们就成功输出了邮箱、博客及公众号的内容了，匹配非常顺利方便。

结语

通过本节，我们应该大体可以了解了正则表达式中零宽断言的基本用法和适用场景，相信理解了零宽断言之后，我们再做正则匹配时会更加得心应手。

作者崔庆才发表于 2018-03-03 阅读次数：本文字数： 9.1k 阅读时长 ≈ 8 分钟

Python 机器学习主要术语

什么是（监督式）机器学习？简单来说，它的定义如下：

机器学习系统通过学习如何组合输入信息来对从未见过的数据做出有用的预测。

下面我们来了解一下机器学习的基本术语。

特征

在简单线性回归中，特征是输入变量，即 x 变量。简单的机器学习项目可能会使用单个特征，而比较复杂的机器学习项目可能会使用数百万个特征，按如下方式指定：

{x1,x2,…xN}

在垃圾邮件检测器示例中，特征可能包括：

电子邮件文本中的字词
发件人的地址
发送电子邮件的时段
电子邮件中包含“一种奇怪的把戏”这样的短语。

样本

样本是指数据的特定实例：x。（我们采用粗体 x 表示它是一个矢量。）我们将样本分为以下两类：

有标签样本
无标签样本

有标签样本同时包含特征和标签。即：

1	labeled examples: {features, label}: (x, y)

我们使用有标签样本来训练模型。在我们的垃圾邮件检测器示例中，有标签样本是用户明确标记为“垃圾邮件”或“非垃圾邮件”的各个电子邮件。例如，下表显示了从包含加利福尼亚州房价信息的数据集中抽取的 5 个有标签样本：

housingMedianAge （特征）

totalRooms （特征）

totalBedrooms （特征）

medianHouseValue （标签）

5612

1283

66900

7650

1901

80100

720

174

85700

1501

337

73400

1454

326

65500

无标签样本包含特征，但不包含标签。即：

1	unlabeled examples: {features, ?}: (x, ?)

在使用有标签样本训练了我们的模型之后，我们会使用该模型来预测无标签样本的标签。在垃圾邮件检测器示例中，无标签样本是用户尚未添加标签的新电子邮件。

模型

模型定义了特征与标签之间的关系。例如，垃圾邮件检测模型可能会将某些特征与“垃圾邮件”紧密联系起来。我们来重点介绍一下模型生命周期的两个阶段：

训练表示创建或学习模型。也就是说，您向模型展示有标签样本，让模型逐渐学习特征与标签之间的关系。
推断表示将训练后的模型应用于无标签样本。也就是说，您使用训练后的模型来做出有用的预测 (y’)。例如，在推断期间，您可以针对新的无标签样本预测 medianHouseValue。

回归与分类

回归模型可预测连续值。例如，回归模型做出的预测可回答如下问题：

加利福尼亚州一栋房产的价值是多少？
用户点击此广告的概率是多少？

分类模型可预测离散值。例如，分类模型做出的预测可回答如下问题：

某个指定电子邮件是垃圾邮件还是非垃圾邮件？
这是一张狗、猫还是仓鼠图片？

原文地址

本节原文地址：问题构建 (Framing)：机器学习主要术语

作者崔庆才发表于 2018-03-01 阅读次数：本文字数： 1.2k 阅读时长 ≈ 1 分钟

Paper [论文笔记] Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation

我们知道，Seq2Seq 现在已经成为了机器翻译、对话聊天、文本摘要等工作的重要模型，真正提出 Seq2Seq 的文章是《Sequence to Sequence Learning with Neural Networks》，但本篇《Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation》比前者更早使用了 Seq2Seq 模型来解决机器翻译的问题，本文是该篇论文的概述。

发布信息

Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation 2014 年 6 月发布于 Arxiv 上，一作是 Kyunghyun Cho，当时来自蒙特利尔大学，现在在纽约大学任教。

摘要

这篇论文中提出了一种新的模型，叫做 RNN Encoder-Decoder，并将它用来进行机器翻译和比较不同语言的短语/词组之间的语义近似程度。这个模型由两个 RNN 组成，其中 Encoder 用来将输入的序列表示成一个固定长度的向量，Decoder 则使用这个向量重建出目标序列，另外该论文提出了 GRU 的基本结构，为后来的研究奠定了基础。因此本文的主要贡献是：

提出了一种类似于 LSTM 的 GRU 结构，并且具有比 LSTM 更少的参数，更不容易过拟合。
较早地将 Seq2Seq 应用在了机器翻译领域，并且取得了不错的效果。

模型

本文提出的模型结构如下图所示：

这里首先对输入上文 x 走一遍 RNN，然后得到一个固定长度的向量 c，作为 Encoder，然后接下来再根据 c 和后续隐状态和输入状态来得到后续状态，Encoder 的行为比较简单，重点在 Decoder 上。

Decoder 中 t 时刻的内部状态的 ht 为:

该时刻的输出概率则为: 模型训练时则去最大化给定输入序列 x 时输出序列为 y 的条件概率: 以上便是核心的公式，上面的这个就是该模型的优化目标。在机器翻译上，作者用 Moses (一个 SMT 系统) 建立了一个 phrase based 的翻译模型作为 baseline system ，然后对比了以下四个模型的 BLEU 值

Baseline configuration
Baseline + RNN
Baseline + CSLM + RNN
Baseline + CSLM + RNN + Word penalty

四种不同的模型的 BLEU 值如下表所示：

phrase pair 打分的结果如下：其中第一栏是输入的英语 phrase ，第二栏是用传统的模型得到的最近似的三个法语 phrase，第三栏是用 Encoder-Decoder 模型得到的最近似的三个 phrase。另外作者还说明该模型可以学习到一个比较好的效果的 Word Embedding 结果，附图如下：左上角的图代表全局的 Embedding 结果，另外三个图是局部结果，可以看到类似的名词都被聚到了一起。

GRU

另外本文的一个主要贡献是提出了 GRU 的门结构，相比 LSTM 更加简洁，而且效果不输 LSTM，关于它的详细公式推导，可以直接参考论文的最后的附录部分，有详细的介绍，在此截图如下：

结语

本篇论文算是为 Seq2Seq 的研究开了先河，而且其提出的 GRU 结构也为后来的研究做好了铺垫，得到了广泛应用，非常值得一读。

参考

作者崔庆才发表于 2018-02-27 阅读次数：本文字数： 1.5k 阅读时长 ≈ 1 分钟

Python TensorFlow layers模块用法

TensorFlow 中的 layers 模块提供用于深度学习的更高层次封装的 API，利用它我们可以轻松地构建模型，这一节我们就来看下这个模块的 API 的具体用法。

概览

layers 模块的路径写法为 tf.layers，这个模块定义在 tensorflow/python/layers/layers.py，其官方文档地址为：https://www.tensorflow.org/api_docs/python/tf/layers，TensorFlow 版本为 1.5。这里面提供了多个类和方法以供使用，下面我们分别予以介绍。

方法

tf.layers 模块提供的方法有：

Input(…): 用于实例化一个输入 Tensor，作为神经网络的输入。
average_pooling1d(…): 一维平均池化层
average_pooling2d(…): 二维平均池化层
average_pooling3d(…): 三维平均池化层
batch_normalization(…): 批量标准化层
conv1d(…): 一维卷积层
conv2d(…): 二维卷积层
conv2d_transpose(…): 二维反卷积层
conv3d(…): 三维卷积层
conv3d_transpose(…): 三维反卷积层
dense(…): 全连接层
dropout(…): Dropout层
flatten(…): Flatten层，即把一个 Tensor 展平
max_pooling1d(…): 一维最大池化层
max_pooling2d(…): 二维最大池化层
max_pooling3d(…): 三维最大池化层
separable_conv2d(…): 二维深度可分离卷积层

Input

tf.layers.Input() 这个方法是用于输入数据的方法，其实类似于 tf.placeholder，相当于一个占位符的作用，当然也可以通过传入 tensor 参数来进行赋值。

Input(
    shape=None,
    batch_size=None,
    name=None,
    dtype=tf.float32,
    sparse=False,
    tensor=None
)

参数说明如下：

shape：可选，默认 None，是一个数字组成的元组或列表，但是这个 shape 比较特殊，它不包含 batch_size，比如传入的 shape 为 [32]，那么它会将 shape 转化为 [?, 32]，这里一定需要注意。
batch_size：可选，默认 None，代表输入数据的 batch size，可以是数字或者 None。
name：可选，默认 None，输入层的名称。
dtype：可选，默认 tf.float32，元素的类型。
sparse：可选，默认 False，指定是否以稀疏矩阵的形式来创建 placeholder。
tensor：可选，默认 None，如果指定，那么创建的内容便不再是一个 placeholder，会用此 Tensor 初始化。

返回值：返回一个包含历史 Meta Data 的 Tensor。我们用一个实例来感受一下：

x = tf.layers.Input(shape=[32])
print(x)
y = tf.layers.dense(x, 16, activation=tf.nn.softmax)
print(y)

首先我们用 Input() 方法初始化了一个 placeholder，这时我们没有传入 tensor 参数，然后调用了 dense() 方法构建了一个全连接网络，激活函数使用 softmax，然后将二者输出，结果如下：

1 2	Tensor("input_layer_1:0", shape=(?, 32), dtype=float32) Tensor("dense/Softmax:0", shape=(?, 16), dtype=float32)

这时我们发现，shape 它给我们做了转化，本来是 [32]，结果它给转化成了 [?, 32]，即第一维代表 batch_size，所以我们需要注意，在调用此方法的时候不需要去关心 batch_size 这一维。如果我们在初始化的时候传入一个已有 Tensor，例如：

1
2
3

data = tf.constant([1, 2, 3])
x = tf.layers.Input(tensor=data)
print(x)

结果如下：

1	Tensor("Const:0", shape=(3,), dtype=int32)

可以看到它可以自动计算出其 shape 和 dtype。

batch_normalization

此方法是批量标准化的方法，经过处理之后可以加速训练速度，其定义在 tensorflow/python/layers/normalization.py，论文可以参考：http://arxiv.org/abs/1502.03167 “Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift”。

batch_normalization(
    inputs,
    axis=-1,
    momentum=0.99,
    epsilon=0.001,
    center=True,
    scale=True,
    beta_initializer=tf.zeros_initializer(),
    gamma_initializer=tf.ones_initializer(),
    moving_mean_initializer=tf.zeros_initializer(),
    moving_variance_initializer=tf.ones_initializer(),
    beta_regularizer=None,
    gamma_regularizer=None,
    beta_constraint=None,
    gamma_constraint=None,
    training=False,
    trainable=True,
    name=None,
    reuse=None,
    renorm=False,
    renorm_clipping=None,
    renorm_momentum=0.99,
    fused=None,
    virtual_batch_size=None,
    adjustment=None
)

参数说明如下：

inputs：必需，即输入数据。
axis：可选，默认 -1，即进行标注化操作时操作数据的哪个维度。
momentum：可选，默认 0.99，即动态均值的动量。
epsilon：可选，默认 0.01，大于0的小浮点数，用于防止除0错误。
center：可选，默认 True，若设为True，将会将 beta 作为偏置加上去，否则忽略参数 beta
scale：可选，默认 True，若设为True，则会乘以gamma，否则不使用gamma。当下一层是线性的时，可以设False，因为scaling的操作将被下一层执行。
beta_initializer：可选，默认 zeros_initializer，即 beta 权重的初始方法。
gamma_initializer：可选，默认 ones_initializer，即 gamma 的初始化方法。
moving_mean_initializer：可选，默认 zeros_initializer，即动态均值的初始化方法。
moving_variance_initializer：可选，默认 ones_initializer，即动态方差的初始化方法。
beta_regularizer: 可选，默认None，beta 的正则化方法。
gamma_regularizer: 可选，默认None，gamma 的正则化方法。
beta_constraint: 可选，默认None，加在 beta 上的约束项。
gamma_constraint: 可选，默认None，加在 gamma 上的约束项。
training：可选，默认 False，返回结果是 training 模式。
trainable：可选，默认为 True，布尔类型，如果为 True，则将变量添加 GraphKeys.TRAINABLE_VARIABLES 中。
name：可选，默认 None，层名称。
reuse：可选，默认 None，根据层名判断是否重复利用。
renorm：可选，默认 False，是否要用 Batch Renormalization (https://arxiv.org/abs/1702.03275)
renorm_clipping：可选，默认 None，是否要用 rmax、rmin、dmax 来 scalar Tensor。
renorm_momentum，可选，默认 0.99，用来更新动态均值和标准差的 Momentum 值。
fused，可选，默认 None，是否使用一个更快的、融合的实现方法。
virtual_batch_size，可选，默认 None，是一个 int 数字，指定一个虚拟 batch size。
adjustment，可选，默认 None，对标准化后的结果进行适当调整的方法。

最后的一些参数说明不够详尽，更详细的用法参考：https://www.tensorflow.org/api_docs/python/tf/layers/batch_normalization。其用法很简单，在输入数据后面加一层 batch_normalization() 即可：

1
2
3

x = tf.layers.Input(shape=[32])
x = tf.layers.batch_normalization(x)
y = tf.layers.dense(x, 20)

dense

dense，即全连接网络，layers 模块提供了一个 dense() 方法来实现此操作，定义在 tensorflow/python/layers/core.py 中，下面我们来说明一下它的用法。

dense(
    inputs,
    units,
    activation=None,
    use_bias=True,
    kernel_initializer=None,
    bias_initializer=tf.zeros_initializer(),
    kernel_regularizer=None,
    bias_regularizer=None,
    activity_regularizer=None,
    kernel_constraint=None,
    bias_constraint=None,
    trainable=True,
    name=None,
    reuse=None
)

参数说明如下：

inputs：必需，即需要进行操作的输入数据。
units：必须，即神经元的数量。
activation：可选，默认为 None，如果为 None 则是线性激活。
use_bias：可选，默认为 True，是否使用偏置。
kernel_initializer：可选，默认为 None，即权重的初始化方法，如果为 None，则使用默认的 Xavier 初始化方法。
bias_initializer：可选，默认为零值初始化，即偏置的初始化方法。
kernel_regularizer：可选，默认为 None，施加在权重上的正则项。
bias_regularizer：可选，默认为 None，施加在偏置上的正则项。
activity_regularizer：可选，默认为 None，施加在输出上的正则项。
kernel_constraint，可选，默认为 None，施加在权重上的约束项。
bias_constraint，可选，默认为 None，施加在偏置上的约束项。
trainable：可选，默认为 True，布尔类型，如果为 True，则将变量添加到 GraphKeys.TRAINABLE_VARIABLES 中。
name：可选，默认为 None，卷积层的名称。
reuse：可选，默认为 None，布尔类型，如果为 True，那么如果 name 相同时，会重复利用。

返回值：全连接网络处理后的 Tensor。下面我们用一个实例来感受一下它的用法：

x = tf.layers.Input(shape=[32])
print(x)
y1 = tf.layers.dense(x, 16, activation=tf.nn.relu)
print(y1)
y2 = tf.layers.dense(y1, 5, activation=tf.nn.sigmoid)
print(y2)

首先我们用 Input 定义了 [?, 32] 的输入数据，然后经过第一层全连接网络，此时指定了神经元个数为 16，激活函数为 relu，接着输出结果经过第二层全连接网络，此时指定了神经元个数为 5，激活函数为 sigmoid，最后输出，结果如下：

1
2
3

Tensor("input_layer_1:0", shape=(?, 32), dtype=float32)
Tensor("dense/Relu:0", shape=(?, 16), dtype=float32)
Tensor("dense_2/Sigmoid:0", shape=(?, 5), dtype=float32)

可以看到输出结果的最后一维度就等于神经元的个数，这是非常容易理解的。

convolution

convolution，即卷积，这里提供了多个卷积方法，如 conv1d()、conv2d()、conv3d()，分别代表一维、二维、三维卷积，另外还有 conv2d_transpose()、conv3d_transpose()，分别代表二维和三维反卷积，还有 separable_conv2d() 方法代表二维深度可分离卷积。它们定义在 tensorflow/python/layers/convolutional.py 中，其用法都是类似的，在这里以 conv2d() 方法为例进行说明。

conv2d(
    inputs,
    filters,
    kernel_size,
    strides=(1, 1),
    padding='valid',
    data_format='channels_last',
    dilation_rate=(1, 1),
    activation=None,
    use_bias=True,
    kernel_initializer=None,
    bias_initializer=tf.zeros_initializer(),
    kernel_regularizer=None,
    bias_regularizer=None,
    activity_regularizer=None,
    kernel_constraint=None,
    bias_constraint=None,
    trainable=True,
    name=None,
    reuse=None
)

参数说明如下：

inputs：必需，即需要进行操作的输入数据。
filters：必需，是一个数字，代表了输出通道的个数，即 output_channels。
kernel_size：必需，卷积核大小，必须是一个数字（高和宽都是此数字）或者长度为 2 的列表（分别代表高、宽）。
strides：可选，默认为 (1, 1)，卷积步长，必须是一个数字（高和宽都是此数字）或者长度为 2 的列表（分别代表高、宽）。
padding：可选，默认为 valid，padding 的模式，有 valid 和 same 两种，大小写不区分。
data_format：可选，默认 channels_last，分为 channels_last 和 channels_first 两种模式，代表了输入数据的维度类型，如果是 channels_last，那么输入数据的 shape 为 (batch, height, width, channels)，如果是 channels_first，那么输入数据的 shape 为 (batch, channels, height, width)。
dilation_rate：可选，默认为 (1, 1)，卷积的扩张率，如当扩张率为 2 时，卷积核内部就会有边距，3x3 的卷积核就会变成 5x5。
activation：可选，默认为 None，如果为 None 则是线性激活。
use_bias：可选，默认为 True，是否使用偏置。
kernel_initializer：可选，默认为 None，即权重的初始化方法，如果为 None，则使用默认的 Xavier 初始化方法。
bias_initializer：可选，默认为零值初始化，即偏置的初始化方法。
kernel_regularizer：可选，默认为 None，施加在权重上的正则项。
bias_regularizer：可选，默认为 None，施加在偏置上的正则项。
activity_regularizer：可选，默认为 None，施加在输出上的正则项。
kernel_constraint，可选，默认为 None，施加在权重上的约束项。
bias_constraint，可选，默认为 None，施加在偏置上的约束项。
trainable：可选，默认为 True，布尔类型，如果为 True，则将变量添加到 GraphKeys.TRAINABLE_VARIABLES 中。
name：可选，默认为 None，卷积层的名称。
reuse：可选，默认为 None，布尔类型，如果为 True，那么如果 name 相同时，会重复利用。

返回值：卷积后的 Tensor。下面我们用实例感受一下它的用法：

1
2
3

x = tf.layers.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=2, padding='same')
print(y)

这里我们首先声明了一个 [?, 20, 20, 3] 的输入 x，然后将其传给 conv2d() 方法，filters 设定为 6，即输出通道为 6，kernel_size 为 2，即卷积核大小为 2 x 2，padding 方式设置为 same，那么输出结果的宽高和原来一定是相同的，但是输出通道就变成了 6，结果如下：

1	Tensor("conv2d/BiasAdd:0", shape=(?, 20, 20, 6), dtype=float32)

但如果我们将 padding 方式不传入，使用默认的 valid 模式，代码改写如下：

1
2
3

x = tf.layers.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=2)
print(y)

结果如下：

1	Tensor("conv2d/BiasAdd:0", shape=(?, 19, 19, 6), dtype=float32)

结果就变成了 [?, 19, 19, 6]，这是因为步长默认为 1，卷积核大小为 2 x 2，所以得到的结果的高宽即为 (20 - (2 - 1)) x (20 - (2 - 1)) = 19 x 19。当然卷积核我们也可以变换大小，传入一个列表形式：

1
2
3

x = tf.layers.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=[2, 3])
print(y)

这时我们的卷积核大小变成了 2 x 3，即高为 2，宽为 3，结果就变成了 [?, 19, 18, 6]，这是因为步长默认为 1，卷积核大小为 2 x 2，所以得到的结果的高宽即为 (20 - (2 - 1)) x (20 - (3 - 1)) = 19 x 18。如果我们将步长也设置一下，也传入列表形式：

1
2
3

x = tf.layers.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=[2, 3], strides=[2, 2])
print(y)

这时卷积核大小变成了 2 x 3，步长变成了 2 x 2，所以结果的高宽为 ceil(20 - (2- 1)) / 2 x ceil(20 - (3- 1)) / 2 = 10 x 9，得到的结果即为 [?, 10, 9, 6]。运行结果如下：

1	Tensor("conv2d_4/BiasAdd:0", shape=(?, 10, 9, 6), dtype=float32)

另外我们还可以传入激活函数，或者禁用 bias 等操作，实例如下：

1
2
3

x = tf.layers.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=2, activation=tf.nn.relu, use_bias=False)
print(y)

这样我们就将激活函数改成了 relu，同时禁用了 bias，运行结果如下：

1	Tensor("conv2d_5/Relu:0", shape=(?, 19, 19, 6), dtype=float32)

另外还有反卷积操作，反卷积顾名思义即卷积的反向操作，即输入卷积的结果，得到卷积前的结果，其参数用法是完全一样的，例如：

1
2
3

x = tf.layers.Input(shape=[20, 20, 3])
y = tf.layers.conv2d_transpose(x, filters=6, kernel_size=2, strides=2)
print(y)

例如此处输入的图像高宽为 20 x 20，经过卷积核为 2，步长为 2 的反卷积处理，得到的结果高宽就变为了 40 x 40，结果如下：

1	Tensor("conv2d_transpose/BiasAdd:0", shape=(?, 40, 40, 6), dtype=float32)

pooling

pooling，即池化，layers 模块提供了多个池化方法，这几个池化方法都是类似的，包括 max_pooling1d()、max_pooling2d()、max_pooling3d()、average_pooling1d()、average_pooling2d()、average_pooling3d()，分别代表一维二维三维最大和平均池化方法，它们都定义在 tensorflow/python/layers/pooling.py 中，这里以 max_pooling2d() 方法为例进行介绍。

max_pooling2d(
    inputs,
    pool_size,
    strides,
    padding='valid',
    data_format='channels_last',
    name=None
)

参数说明如下：

inputs: 必需，即需要池化的输入对象，必须是 4 维的。
pool_size：必需，池化窗口大小，必须是一个数字（高和宽都是此数字）或者长度为 2 的列表（分别代表高、宽）。
strides：必需，池化步长，必须是一个数字（高和宽都是此数字）或者长度为 2 的列表（分别代表高、宽）。
padding：可选，默认 valid，padding 的方法，valid 或者 same，大小写不区分。
data_format：可选，默认 channels_last，分为 channels_last 和 channels_first 两种模式，代表了输入数据的维度类型，如果是 channels_last，那么输入数据的 shape 为 (batch, height, width, channels)，如果是 channels_first，那么输入数据的 shape 为 (batch, channels, height, width)。
name：可选，默认 None，池化层的名称。

返回值：经过池化处理后的 Tensor。下面我们用一个实例来感受一下：

x = tf.layers.Input(shape=[20, 20, 3])
print(x)
y = tf.layers.conv2d(x, filters=6, kernel_size=3, padding='same')
print(y)
p = tf.layers.max_pooling2d(y, pool_size=2, strides=2)
print(p)

在这里我们首先指定了输入 x，shape 为 [20, 20, 3]，然后对其进行了卷积计算，然后池化，最后得到池化后的结果。结果如下：

1
2
3

Tensor("input_layer_1:0", shape=(?, 20, 20, 3), dtype=float32)
Tensor("conv2d/BiasAdd:0", shape=(?, 20, 20, 6), dtype=float32)
Tensor("max_pooling2d/MaxPool:0", shape=(?, 10, 10, 6), dtype=float32)

可以看到这里池化窗口用的是 2，步长也是 2，所以原本卷积后 shape 为 [?, 20, 20, 6] 的结果就变成了 [?, 10, 10, 6]。

dropout

dropout 是指在深度学习网络的训练过程中，对于神经网络单元，按照一定的概率将其暂时从网络中丢弃，可以用来防止过拟合，layers 模块中提供了 dropout() 方法来实现这一操作，定义在 tensorflow/python/layers/core.py。下面我们来说明一下它的用法。

dropout(
    inputs,
    rate=0.5,
    noise_shape=None,
    seed=None,
    training=False,
    name=None
)

参数说明如下：

inputs：必须，即输入数据。
rate：可选，默认为 0.5，即 dropout rate，如设置为 0.1，则意味着会丢弃 10% 的神经元。
noise_shape：可选，默认为 None，int32 类型的一维 Tensor，它代表了 dropout mask 的 shape，dropout mask 会与 inputs 相乘对 inputs 做转换，例如 inputs 的 shape 为 (batch_size, timesteps, features)，但我们想要 droput mask 在所有 timesteps 都是相同的，我们可以设置 noise_shape=[batch_size, 1, features]。
seed：可选，默认为 None，即产生随机熟的种子值。
training：可选，默认为 False，布尔类型，即代表了是否标志位 training 模式。
name：可选，默认为 None，dropout 层的名称。

返回：经过 dropout 层之后的 Tensor。我们用一个实例来感受一下：

x = tf.layers.Input(shape=[32])
print(x)
y = tf.layers.dense(x, 16, activation=tf.nn.softmax)
print(y)
d = tf.layers.dropout(y, rate=0.2)
print(d)

运行结果：

1
2
3

Tensor("input_layer_1:0", shape=(?, 32), dtype=float32)
Tensor("dense/Softmax:0", shape=(?, 16), dtype=float32)
Tensor("dropout/Identity:0", shape=(?, 16), dtype=float32)

在这里我们使用 dropout() 方法实现了 droput 操作，并制定 dropout rate 为 0.2，最后输出结果的 shape 和原来是一致的。

flatten

flatten() 方法可以对 Tensor 进行展平操作，定义在 tensorflow/python/layers/core.py。

flatten(
    inputs,
    name=None
)

参数说明如下：

inputs：必需，即输入数据。
name：可选，默认为 None，即该层的名称。

返回结果：展平后的 Tensor。下面我们用一个实例来感受一下：

x = tf.layers.Input(shape=[5, 6])
print(x)
y = tf.layers.flatten(x)
print(y)

运行结果：

1 2	Tensor("input_layer_1:0", shape=(?, 5, 6), dtype=float32) Tensor("flatten/Reshape:0", shape=(?, 30), dtype=float32)

这里输入数据的 shape 为 [?, 5, 6]，经过 flatten 层之后，就会变成 [?, 30]，即将除了第一维的数据维度相乘，对原 Tensor 进行展平。假如第一维是一个已知的数的话，它依然还是同样的处理，示例如下：

x = tf.placeholder(shape=[5, 6, 2], dtype=tf.float32)
print(x)
y = tf.layers.flatten(x)
print(y)

结果如下：

1 2	Tensor("Placeholder:0", shape=(5, 6, 2), dtype=float32) Tensor("flatten_2/Reshape:0", shape=(5, 12), dtype=float32)

类

除了如上的方法，其实我们还可以直接使用类来进行操作，实际上看方法的实现就是实例化了其对应的类，下面我们首先说明一下有哪些类可以使用：

class AveragePooling1D: 一维平均池化层类
class AveragePooling2D: 二维平均池化层类
class AveragePooling3D: 三维平均池化层类
class BatchNormalization: 批量标准化层类
class Conv1D: 一维卷积层类
class Conv2D: 二维卷积层类
class Conv2DTranspose: 二维反卷积层类
class Conv3D: 三维卷积层类
class Conv3DTranspose: 三维反卷积层类
class Dense: 全连接层类
class Dropout: Dropout 层类
class Flatten: Flatten 层类
class InputSpec: Input 层类
class Layer: 基类、父类
class MaxPooling1D: 一维最大池化层类
class MaxPooling2D: 二维最大池化层类
class MaxPooling3D: 三维最大池化层类
class SeparableConv2D: 二维深度可分离卷积层类

其实类这些类都和上文介绍的方法是一一对应的，关于它的用法我们可以在方法的源码实现里面找到，下面我们以 Dense 类的用法为例来说明一下这些类的具体调用方法：

x = tf.layers.Input(shape=[32])
dense = tf.layers.Dense(16, activation=tf.nn.relu)
y = dense.apply(x)
print(y)

这里我们初始化了一个 Dense 类，它只接受一个必须参数，那就是 units，相比 dense() 方法来说它没有了 inputs，因此这个实例化的类和 inputs 是无关的，这样就相当于创建了一个 16 个神经元的全连接层。但创建了不调用是没有用的，我们要将这个层构建到网络之中，需要调用它的 apply() 方法，而 apply() 方法就接收 inputs 这个参数，返回计算结果，运行结果如下：

1	Tensor("dense/Relu:0", shape=(?, 16), dtype=float32)

因此我们可以发现，这些类在初始化的时候实际上是比其对应的方法少了 inputs 参数，其他的参数都是完全一致的，另外需要调用 apply() 方法才可以应用该层并将其构建到模型中。所以其他的类的用法在此就不一一赘述了，初始化的参数可以类比其对应的方法，实例化类之后，调用 apply() 方法，可以达到同样的构建模型的效果。

结语

以上便是 TensorFlow layers 模块的详细用法说明，更加详细的用法可以参考官方文档：https://www.tensorflow.org/api_docs/python/tf/layers。本节代码地址：https://github.com/AIDeepLearning/TensorFlowLayers。

作者崔庆才发表于 2018-02-23 阅读次数：本文字数： 13k 阅读时长 ≈ 12 分钟

Python TensorFlow验证码识别

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

验证码

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

1	pip3 install captcha pillow

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

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 形式的数组：

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)

内容如下：

[[[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 编码和文本的互相转换：

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)

运行结果如下：

[ 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 编码，生成内容如下：

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() 方法将数据分为三部分，训练集、开发集、验证集：

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 对象：

# 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)

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

# 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 模块：

# 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 就好计算了：

# 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))

再接下来执行训练即可：

# 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 等结果并输出。

训练

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

...
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 一下模型，然后进行验证：

# 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。

作者崔庆才发表于 2018-02-21 阅读次数：本文字数： 8.2k 阅读时长 ≈ 7 分钟

Python 利用python库twilio来免费发送短信

大家好，我是四毛，最近开通了个人公众号“用 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. 写代码

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

#!/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.打电话

打电话的代码也很简单

# 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

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

欢迎大家关注我。

作者四毛发表于 2018-02-12 阅读次数：本文字数： 2.5k 阅读时长 ≈ 2 分钟

Python [Python3网络爬虫开发实战] 后续章节

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

全书预览图：

作者崔庆才发表于 2018-02-07 阅读次数：本文字数： 191 阅读时长 ≈ 1 分钟

Python [Python3网络爬虫开发实战] 7.4-使用Selenium爬取淘宝商品

在前一章中，我们已经成功尝试分析 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 进行抓取了。我们实现如下抓取列表页的方法：

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 进行解析，实现如下：

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，实现代码如下：

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代表页码。这里我们实现页码遍历即可，代码如下：

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 请求，真正做到可见即可爬。

作者崔庆才发表于 2018-01-31 阅读次数：本文字数： 6.6k 阅读时长 ≈ 6 分钟

Python [Python3网络爬虫开发实战] 7.3-Splash负载均衡配置

用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，添加如下内容：

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代表最少链接负载均衡，它适合处理请求处理时间长短不一造成服务器过载的情况。

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

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;
}

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

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

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散列负载均衡，配置如下：

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字段，具体配置如下：

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测试即可，实现代码如下：

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服务共同合作，减轻单个服务的负载，这还是比较有用的。

作者崔庆才发表于 2018-01-31 阅读次数：本文字数： 2.9k 阅读时长 ≈ 3 分钟

Python [Python3网络爬虫开发实战] 7.2-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 的加载等过程，呈现的页面和我们在浏览器中得到的结果完全一致。

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

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 脚本的入口和执行方式。

入口及返回值

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

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 内部完成的。示例如下：

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 代码：

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 代码，此时运行结果就会抛出异常：

{
    "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），代表不检测超时。示例如下：

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

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

{
    "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 即可。

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

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`

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

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变量中包含了错误的原因，否则证明页面加载成功。示例如下：

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 的表单数据，如果成功，则返回页面的源代码。

运行结果如下：

<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的组合。

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

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

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

`jsfunc()`

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

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()的功能类似，但是更偏向于执行某些动作或声明某些方法。例如：

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()来调用得到的结果。

运行结果如下：

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()方法。示例如下：

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 方法。

运行结果如下：

百度一下，你就知道

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

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()方法重新执行定时任务。示例如下：

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。

示例如下：

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

运行结果如下：

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：可选参数，即表单数据，默认为空。

我们用实例感受一下：

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

运行结果如下：

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()`

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

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

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

图 7-12 运行结果

`html()`

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

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

运行结果如下：

<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 格式的网页截图，示例如下：

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

`jpeg()`

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

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

`har()`

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

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

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

图 7-13 运行结果

`url()`

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

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

运行结果如下：

1	https://www.baidu.com/

`get_cookies()`

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

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

运行结果如下：

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 的各个属性。

示例如下：

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

`clear_cookies()`

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

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()`

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

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)

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

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()`

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

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

`set_user_agent()`

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

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

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

<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()`

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

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属性，运行结果如下：

<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 选择器。示例如下：

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 选择器。示例如下：

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 选择器选中了节点的正文内容，随后遍历了所有节点，将其中的文本获取下来。

运行结果如下：

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。此外，也可以直接选中某个节点，然后调用此方法，示例如下：

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 实现的话，代码如下：

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

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

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

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 格式的图片，具体如下：

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

运行结果如下：

hello

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

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

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)

运行结果如下：

hello

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

我们再通过实例看一下：

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)

运行结果如下：

{"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 同样可以做到非常强大的渲染功能，同时它也不需要浏览器即可渲染，使用非常方便。

作者崔庆才发表于 2018-01-31 阅读次数：本文字数： 22k 阅读时长 ≈ 20 分钟

Python [Python3网络爬虫开发实战] 7.1-Selenium的使用

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

1. 准备工作

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

2. 基本使用

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

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。

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

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()方法访问淘宝，然后打印出源代码，代码如下：

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 选择器等获取的方式。

我们用代码实现一下：

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类型，是完全一致的。

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

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)，二者得到的结果完全一致。我们用代码实现一下：

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 导航栏

就可以这样来实现：

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()

运行结果如下：

[<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类型。

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

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()方法。示例如下：

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. 动作链

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

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

from selenium import webdriver
from selenium.webdriver import ActionChains

browser = webdriver.Chrome()
url = 'http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable'
browser.get(url)
browser.switch_to.frame('iframeResult')
source = browser.find_element_by_css_selector('#draggable')
target = browser.find_element_by_css_selector('#droppable')
actions = ActionChains(browser)
actions.drag_and_drop(source, target)
actions.perform()

首先，打开网页中的一个拖曳实例，然后依次选中要拖曳的节点和拖曳到的目标节点，接着声明ActionChains对象并将其赋值为actions变量，然后通过调用actions变量的drag_and_drop()方法，再调用perform()方法执行动作，此时就完成了拖曳操作，如图 7-4 和图 7-5 所示。

图 7-4 拖曳前的页面

图 7-5 拖曳后的页面

更多的动作链操作可以参考官方文档：http://selenium-python.readthedocs.io/api.html#module-selenium.webdriver.common.action_chains。

8. 执行 JavaScript

对于某些操作，Selenium API 并没有提供。比如，下拉进度条，它可以直接模拟运行 JavaScript，此时使用execute_script()方法即可实现，代码如下：

from selenium import webdriver

browser = webdriver.Chrome()
browser.get('https://www.zhihu.com/explore')
browser.execute_script('window.scrollTo(0, document.body.scrollHeight)')
browser.execute_script('alert("To Bottom")')

这里就利用execute_script()方法将进度条下拉到最底部，然后弹出 alert 提示框。

所以说有了这个方法，基本上 API 没有提供的所有功能都可以用执行 JavaScript 的方式来实现了。

9. 获取节点信息

前面说过，通过page_source属性可以获取网页的源代码，接着就可以使用解析库（如正则表达式、Beautiful Soup、pyquery 等）来提取信息了。

不过，既然 Selenium 已经提供了选择节点的方法，返回的是WebElement类型，那么它也有相关的方法和属性来直接提取节点信息，如属性、文本等。这样的话，我们就可以不用通过解析源代码来提取信息了，非常方便。

接下来，就看看通过怎样的方式来获取节点信息吧。

获取属性

我们可以使用get_attribute()方法来获取节点的属性，但是其前提是先选中这个节点，示例如下：

from selenium import webdriver
from selenium.webdriver import ActionChains

browser = webdriver.Chrome()
url = 'https://www.zhihu.com/explore'
browser.get(url)
logo = browser.find_element_by_id('zh-top-link-logo')
print(logo)
print(logo.get_attribute('class'))

运行之后，程序便会驱动浏览器打开知乎页面，然后获取知乎的 logo 节点，最后打印出它的class。

控制台的输出结果如下：

1 2	<selenium.webdriver.remote.webelement.WebElement (session="e08c0f28d7f44d75ccd50df6bb676104", element="0.7236390660048155-1")> zu-top-link-logo

通过get_attribute()方法，然后传入想要获取的属性名，就可以得到它的值了。

获取文本值

每个WebElement节点都有text属性，直接调用这个属性就可以得到节点内部的文本信息，这相当于 Beautiful Soup 的get_text()方法、pyquery 的text()方法，示例如下：

from selenium import webdriver

browser = webdriver.Chrome()
url = 'https://www.zhihu.com/explore'
browser.get(url)
input = browser.find_element_by_class_name('zu-top-add-question')
print(input.text)

这里依然先打开知乎页面，然后获取“提问”按钮这个节点，再将其文本值打印出来。

控制台的输出结果如下：

提问

获取 id、位置、标签名和大小

另外，WebElement节点还有一些其他属性，比如id属性可以获取节点id，location属性可以获取该节点在页面中的相对位置，tag_name属性可以获取标签名称，size属性可以获取节点的大小，也就是宽高，这些属性有时候还是很有用的。示例如下：

 from selenium import webdriver

browser = webdriver.Chrome()
url = 'https://www.zhihu.com/explore'
browser.get(url)
input = browser.find_element_by_class_name('zu-top-add-question')
print(input.id)
print(input.location)
print(input.tag_name)
print(input.size)

这里首先获得“提问”按钮这个节点，然后调用其id、location、tag_name、size属性来获取对应的属性值。

10. 切换 Frame

我们知道网页中有一种节点叫作 iframe，也就是子 Frame，相当于页面的子页面，它的结构和外部网页的结构完全一致。Selenium 打开页面后，它默认是在父级 Frame 里面操作，而此时如果页面中还有子 Frame，它是不能获取到子 Frame 里面的节点的。这时就需要使用switch_to.frame()方法来切换 Frame。示例如下：

import time
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException

browser = webdriver.Chrome()
url = 'http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable'
browser.get(url)
browser.switch_to.frame('iframeResult')
try:
    logo = browser.find_element_by_class_name('logo')
except NoSuchElementException:
    print('NO LOGO')
browser.switch_to.parent_frame()
logo = browser.find_element_by_class_name('logo')
print(logo)
print(logo.text)

控制台的输出如下：

1
2
3

NO LOGO
<selenium.webdriver.remote.webelement.WebElement (session="4bb8ac03ced4ecbdefef03ffdc0e4ccd", element="0.13792611320464965-2")>
RUNOOB.COM

这里还是以前面演示动作链操作的网页为实例，首先通过switch_to.frame()方法切换到子 Frame 里面，然后尝试获取父级 Frame 里的 logo 节点（这是不能找到的），如果找不到的话，就会抛出NoSuchElementException异常，异常被捕捉之后，就会输出NO LOGO。接下来，重新切换回父级 Frame，然后再次重新获取节点，发现此时可以成功获取了。

所以，当页面中包含子 Frame 时，如果想获取子 Frame 中的节点，需要先调用switch_to.frame()方法切换到对应的 Frame，然后再进行操作。

11. 延时等待

在 Selenium 中，get()方法会在网页框架加载结束后结束执行，此时如果获取page_source，可能并不是浏览器完全加载完成的页面，如果某些页面有额外的 Ajax 请求，我们在网页源代码中也不一定能成功获取到。所以，这里需要延时等待一定时间，确保节点已经加载出来。

这里等待的方式有两种：一种是隐式等待，一种是显式等待。

隐式等待

当使用隐式等待执行测试的时候，如果 Selenium 没有在 DOM 中找到节点，将继续等待，超出设定时间后，则抛出找不到节点的异常。换句话说，当查找节点而节点并没有立即出现的时候，隐式等待将等待一段时间再查找 DOM，默认的时间是 0。示例如下：

from selenium import webdriver

browser = webdriver.Chrome()
browser.implicitly_wait(10)
browser.get('https://www.zhihu.com/explore')
input = browser.find_element_by_class_name('zu-top-add-question')
print(input)

这里我们用implicitly_wait()方法实现了隐式等待。

显式等待

隐式等待的效果其实并没有那么好，因为我们只规定了一个固定时间，而页面的加载时间会受到网络条件的影响。

这里还有一种更合适的显式等待方法，它指定要查找的节点，然后指定一个最长等待时间。如果在规定时间内加载出来了这个节点，就返回查找的节点；如果到了规定时间依然没有加载出该节点，则抛出超时异常。示例如下：

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

browser = webdriver.Chrome()
browser.get('https://www.taobao.com/')
wait = WebDriverWait(browser, 10)
input = wait.until(EC.presence_of_element_located((By.ID, 'q')))
button = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, '.btn-search')))
print(input, button)

这里首先引入WebDriverWait这个对象，指定最长等待时间，然后调用它的until()方法，传入要等待条件expected_conditions。比如，这里传入了presence_of_element_located这个条件，代表节点出现的意思，其参数是节点的定位元组，也就是ID为q的节点搜索框。

这样可以做到的效果就是，在 10 秒内如果ID为q的节点（即搜索框）成功加载出来，就返回该节点；如果超过 10 秒还没有加载出来，就抛出异常。

对于按钮，可以更改一下等待条件，比如改为element_to_be_clickable，也就是可点击，所以查找按钮时查找 CSS 选择器为.btn-search 的按钮，如果 10 秒内它是可点击的，也就是成功加载出来了，就返回这个按钮节点；如果超过 10 秒还不可点击，也就是没有加载出来，就抛出异常。

运行代码，在网速较佳的情况下是可以成功加载出来的。

控制台的输出如下：

1
2

<selenium.webdriver.remote.webelement.WebElement (session="07dd2fbc2d5b1ce40e82b9754aba8fa8", element="0.5642646294074107-1")>
<selenium.webdriver.remote.webelement.WebElement (session="07dd2fbc2d5b1ce40e82b9754aba8fa8", element="0.5642646294074107-2")>

可以看到，控制台成功输出了两个节点，它们都是WebElement类型。

如果网络有问题，10 秒内没有成功加载，那就抛出TimeoutException异常，此时控制台的输出如下：

TimeoutException Traceback (most recent call last)
<ipython-input-4-f3d73973b223> in <module>()
      7 browser.get('https://www.taobao.com/')
      8 wait = WebDriverWait(browser, 10)
----> 9 input = wait.until(EC.presence_of_element_located((By.ID, 'q')))

关于等待条件，其实还有很多，比如判断标题内容，判断某个节点内是否出现了某文字等。表 7-1 列出了所有的等待条件。

表 7-1 等待条件及其含义

等待条件

含义

title_is

标题是某内容

title_contains

标题包含某内容

presence_of_element_located

节点加载出来，传入定位元组，如(By.ID, 'p')

visibility_of_element_located

节点可见，传入定位元组

visibility_of

可见，传入节点对象

presence_of_all_elements_located

所有节点加载出来

text_to_be_present_in_element

某个节点文本包含某文字

text_to_be_present_in_element_value

某个节点值包含某文字

frame_to_be_available_and_switch_to_it

加载并切换

invisibility_of_element_located

节点不可见

element_to_be_clickable

节点可点击

staleness_of

判断一个节点是否仍在 DOM，可判断页面是否已经刷新

element_to_be_selected

节点可选择，传节点对象

element_located_to_be_selected

节点可选择，传入定位元组

element_selection_state_to_be

传入节点对象以及状态，相等返回True，否则返回False

element_located_selection_state_to_be

传入定位元组以及状态，相等返回True，否则返回False

alert_is_present

是否出现警告

关于更多等待条件的参数及用法，可以参考官方文档：http://selenium-python.readthedocs.io/api.html#module-selenium.webdriver.support.expected_conditions。

12. 前进和后退

平常使用浏览器时都有前进和后退功能，Selenium 也可以完成这个操作，它使用back()方法后退，使用forward()方法前进。示例如下：

import time
from selenium import webdriver

browser = webdriver.Chrome()
browser.get('https://www.baidu.com/')
browser.get('https://www.taobao.com/')
browser.get('https://www.python.org/')
browser.back()
time.sleep(1)
browser.forward()
browser.close()

这里我们连续访问 3 个页面，然后调用back()方法回到第二个页面，接下来再调用forward()方法又可以前进到第三个页面。

13. Cookies

使用 Selenium，还可以方便地对 Cookies 进行操作，例如获取、添加、删除 Cookies 等。示例如下：

from selenium import webdriver

browser = webdriver.Chrome()
browser.get('https://www.zhihu.com/explore')
print(browser.get_cookies())
browser.add_cookie({'name': 'name', 'domain': 'www.zhihu.com', 'value': 'germey'})
print(browser.get_cookies())
browser.delete_all_cookies()
print(browser.get_cookies())

首先，我们访问了知乎。加载完成后，浏览器实际上已经生成 Cookies 了。接着，调用get_cookies()方法获取所有的 Cookies。然后，我们添加一个 Cookie，这里传入一个字典，有name、domain和value等内容。接下来，再次获取所有的 Cookies。可以发现，结果就多了这一项新加的 Cookie。最后，调用delete_all_cookies()方法删除所有的 Cookies。再重新获取，发现结果就为空了。

控制台的输出如下：

1
2
3

[{'secure': False, 'value': '"NGM0ZTM5NDAwMWEyNDQwNDk5ODlkZWY3OTkxY2I0NDY=|1491604091|236e34290a6f407bfbb517888849ea509ac366d0"', 'domain': '.zhihu.com', 'path': '/', 'httpOnly': False, 'name': 'l_cap_id', 'expiry': 1494196091.403418}]
[{'secure': False, 'value': 'germey', 'domain': '.www.zhihu.com', 'path': '/', 'httpOnly': False, 'name': 'name'}, {'secure': False, 'value': '"NGM0ZTM5NDAwMWEyNDQwNDk5ODlkZWY3OTkxY2I0NDY=|1491604091|236e34290a6f407bfbb517888849ea509ac366d0"', 'domain': '.zhihu.com', 'path': '/', 'httpOnly': False, 'name': 'l_cap_id', 'expiry': 1494196091.403418}]
[]

14. 选项卡管理

在访问网页的时候，会开启一个个选项卡。在 Selenium 中，我们也可以对选项卡进行操作。示例如下：

import time
from selenium import webdriver

browser = webdriver.Chrome()
browser.get('https://www.baidu.com')
browser.execute_script('window.open()')
print(browser.window_handles)
browser.switch_to_window(browser.window_handles[1])
browser.get('https://www.taobao.com')
time.sleep(1)
browser.switch_to_window(browser.window_handles[0])
browser.get('https://python.org')

控制台的输出如下：

1	['CDwindow-4f58e3a7-7167-4587-bedf-9cd8c867f435', 'CDwindow-6e05f076-6d77-453a-a36c-32baacc447df']

首先访问了百度，然后调用了execute_script()方法，这里传入window.open()这个 JavaScript 语句新开启一个选项卡。接下来，我们想切换到该选项卡。这里调用window_handles属性获取当前开启的所有选项卡，返回的是选项卡的代号列表。要想切换选项卡，只需要调用switch_to_window()方法即可，其中参数是选项卡的代号。这里我们将第二个选项卡代号传入，即跳转到第二个选项卡，接下来在第二个选项卡下打开一个新页面，然后切换回第一个选项卡重新调用 switch_to_window()方法，再执行其他操作即可。

15. 异常处理

在使用 Selenium 的过程中，难免会遇到一些异常，例如超时、节点未找到等错误，一旦出现此类错误，程序便不会继续运行了。这里我们可以使用try except语句来捕获各种异常。

首先，演示一下节点未找到的异常，示例如下：

from selenium import webdriver

browser = webdriver.Chrome()
browser.get('https://www.baidu.com')
browser.find_element_by_id('hello')

这里首先打开百度页面，然后尝试选择一个并不存在的节点，此时就会遇到异常。

运行之后控制台的输出如下：

NoSuchElementException Traceback (most recent call last)
<ipython-input-23-978945848a1b> in <module>()
      3 browser = webdriver.Chrome()
      4 browser.get('https://www.baidu.com')
----> 5 browser.find_element_by_id('hello')

可以看到，这里抛出了NoSuchElementException异常，这通常是节点未找到的异常。为了防止程序遇到异常而中断，我们需要捕获这些异常，示例如下：

from selenium import webdriver
from selenium.common.exceptions import TimeoutException, NoSuchElementException

browser = webdriver.Chrome()
try:
    browser.get('https://www.baidu.com')
except TimeoutException:
    print('Time Out')
try:
    browser.find_element_by_id('hello')
except NoSuchElementException:
    print('No Element')
finally:
    browser.close()

这里我们使用try except来捕获各类异常。比如，我们对find_element_by_id()查找节点的方法捕获NoSuchElementException异常，这样一旦出现这样的错误，就进行异常处理，程序也不会中断了。

控制台的输出如下：

1	No Element

关于更多的异常类，可以参考官方文档：http://selenium-python.readthedocs.io/api.html#module-selenium.common.exceptions。

现在，我们基本对 Selenium 的常规用法有了大体的了解。使用 Selenium，处理 JavaScript 不再是难事。

作者崔庆才发表于 2018-01-31 阅读次数：本文字数： 17k 阅读时长 ≈ 15 分钟

Python [Python3网络爬虫开发实战] 7-动态渲染页面爬取

在前一章中，我们了解了Ajax的分析和抓取方式，这其实也是JavaScript动态渲染的页面的一种情形，通过直接分析Ajax，我们仍然可以借助requests或urllib来实现数据爬取。

不过JavaScript动态渲染的页面不止Ajax这一种。比如中国青年网（详见http://news.youth.cn/gn/），它的分页部分是由JavaScript生成的，并非原始HTML代码，这其中并不包含Ajax请求。比如ECharts的官方实例（详见http://echarts.baidu.com/demo.html#bar-negative），其图形都是经过JavaScript计算之后生成的。再有淘宝这种页面，它即使是Ajax获取的数据，但是其Ajax接口含有很多加密参数，我们难以直接找出其规律，也很难直接分析Ajax来抓取。

为了解决这些问题，我们可以直接使用模拟浏览器运行的方式来实现，这样就可以做到在浏览器中看到是什么样，抓取的源码就是什么样，也就是可见即可爬。这样我们就不用再去管网页内部的JavaScript用了什么算法渲染页面，不用管网页后台的Ajax接口到底有哪些参数。

Python提供了许多模拟浏览器运行的库，如Selenium、Splash、PyV8、Ghost等。本章中，我们就来介绍一下Selenium和Splash的用法。有了它们，就不用再为动态渲染的页面发愁了。

作者崔庆才发表于 2018-01-31 阅读次数：本文字数： 595 阅读时长 ≈ 1 分钟

Python [Python3网络爬虫开发实战] 6.4-分析Ajax爬取今日头条街拍美图

本节中，我们以今日头条为例来尝试通过分析 Ajax 请求来抓取网页数据的方法。这次要抓取的目标是今日头条的街拍美图，抓取完成之后，将每组图片分文件夹下载到本地并保存下来。

1. 准备工作

在本节开始之前，请确保已经安装好 requests 库。如果没有安装，可以参考第 1 章。

2. 抓取分析

在抓取之前，首先要分析抓取的逻辑。打开今日头条的首页http://www.toutiao.com/，如图 6-15 所示。

图 6-15 首页内容

右上角有一个搜索入口，这里尝试抓取街拍美图，所以输入“街拍”二字搜索一下，结果如图 6-16 所示。

图 6-16 搜索结果

这时打开开发者工具，查看所有的网络请求。首先，打开第一个网络请求，这个请求的 URL 就是当前的链接http://www.toutiao.com/search/?keyword=街拍，打开 Preview 选项卡查看 Response Body。如果页面中的内容是根据第一个请求得到的结果渲染出来的，那么第一个请求的源代码中必然会包含页面结果中的文字。为了验证，我们可以尝试搜索一下搜索结果的标题，比如“路人”二字，如图 6-17 所示。

图 6-17 搜索结果

我们发现，网页源代码中并没有包含这两个字，搜索匹配结果数目为 0。因此，可以初步判断这些内容是由 Ajax 加载，然后用 JavaScript 渲染出来的。接下来，我们可以切换到 XHR 过滤选项卡，查看一下有没有 Ajax 请求。

不出所料，此处出现了一个比较常规的 Ajax 请求，看看它的结果是否包含了页面中的相关数据。

点击data字段展开，发现这里有许多条数据。点击第一条展开，可以发现有一个title字段，它的值正好就是页面中第一条数据的标题。再检查一下其他数据，也正好是一一对应的，如图 6-18 所示。

图 6-18 对比结果

这就确定了这些数据确实是由 Ajax 加载的。

我们的目的是要抓取其中的美图，这里一组图就对应前面data字段中的一条数据。每条数据还有一个image_detail字段，它是列表形式，这其中就包含了组图的所有图片列表，如图 6-19 所示。

图 6-19 图片列表信息

因此，我们只需要将列表中的url字段提取出来并下载下来就好了。每一组图都建立一个文件夹，文件夹的名称就为组图的标题。

接下来，就可以直接用 Python 来模拟这个 Ajax 请求，然后提取出相关美图链接并下载。但是在这之前，我们还需要分析一下 URL 的规律。

切换回 Headers 选项卡，观察一下它的请求 URL 和 Headers 信息，如图 6-20 所示。

图 6-20 请求信息

可以看到，这是一个 GET 请求，请求 URL 的参数有offset、format、keyword、autoload、count和cur_tab。我们需要找出这些参数的规律，因为这样才可以方便地用程序构造出来。

接下来，可以滑动页面，多加载一些新结果。在加载的同时可以发现，Network 中又出现了许多 Ajax 请求，如图 6-21 所示。

图 6-21 Ajax 请求

这里观察一下后续链接的参数，发现变化的参数只有offset，其他参数都没有变化，而且第二次请求的offset值为 20，第三次为 40，第四次为 60，所以可以发现规律，这个offset值就是偏移量，进而可以推断出count参数就是一次性获取的数据条数。因此，我们可以用offset参数来控制数据分页。这样一来，我们就可以通过接口批量获取数据了，然后将数据解析，将图片下载下来即可。

3. 实战演练

我们刚才已经分析了一下 Ajax 请求的逻辑，下面就用程序来实现美图下载吧。

首先，实现方法get_page()来加载单个 Ajax 请求的结果。其中唯一变化的参数就是offset，所以我们将它当作参数传递，实现如下：

import requests
from urllib.parse import urlencode

def get_page(offset):
    params = {
        'offset': offset,
        'format': 'json',
        'keyword': '街拍',
        'autoload': 'true',
        'count': '20',
        'cur_tab': '1',
    }
    url = 'http://www.toutiao.com/search_content/?' + urlencode(params)
    try:
        response = requests.get(url)
        if response.status_code == 200:
            return response.json()
    except requests.ConnectionError:
        return None

这里我们用urlencode()方法构造请求的 GET 参数，然后用 requests 请求这个链接，如果返回状态码为 200，则调用response的json()方法将结果转为 JSON 格式，然后返回。

接下来，再实现一个解析方法：提取每条数据的image_detail字段中的每一张图片链接，将图片链接和图片所属的标题一并返回，此时可以构造一个生成器。实现代码如下：

def get_images(json):
    if json.get('data'):
        for item in json.get('data'):
            title = item.get('title')
            images = item.get('image_detail')
            for image in images:
                yield {
                    'image': image.get('url'),
                    'title': title
                }

接下来，实现一个保存图片的方法save_image()，其中item就是前面get_images()方法返回的一个字典。在该方法中，首先根据item的title来创建文件夹，然后请求这个图片链接，获取图片的二进制数据，以二进制的形式写入文件。图片的名称可以使用其内容的 MD5 值，这样可以去除重复。相关代码如下：

import os
from hashlib import md5

def save_image(item):
    if not os.path.exists(item.get('title')):
        os.mkdir(item.get('title'))
    try:
        response = requests.get(item.get('image'))
        if response.status_code == 200:
            file_path = '{0}/{1}.{2}'.format(item.get('title'), md5(response.content).hexdigest(), 'jpg')
            if not os.path.exists(file_path):
                with open(file_path, 'wb') as f:
                    f.write(response.content)
            else:
                print('Already Downloaded', file_path)
    except requests.ConnectionError:
        print('Failed to Save Image')

最后，只需要构造一个offset数组，遍历offset，提取图片链接，并将其下载即可：

from multiprocessing.pool import Pool

def main(offset):
    json = get_page(offset)
    for item in get_images(json):
        print(item)
        save_image(item)


GROUP_START = 1
GROUP_END = 20

if __name__ == '__main__':
    pool = Pool()
    groups = ([x * 20 for x in range(GROUP_START, GROUP_END + 1)])
    pool.map(main, groups)
    pool.close()
    pool.join()

这里定义了分页的起始页数和终止页数，分别为GROUP_START和GROUP_END，还利用了多线程的线程池，调用其map()方法实现多线程下载。

这样整个程序就完成了，运行之后可以发现街拍美图都分文件夹保存下来了，如图 6-22 所示。

图 6-22 保存结果

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

通过本节，我们了解了 Ajax 分析的流程、Ajax 分页的模拟以及图片的下载过程。

本节的内容需要熟练掌握，在后面的实战中我们还会用到很多次这样的分析和抓取。

作者崔庆才发表于 2018-01-30 阅读次数：本文字数： 3.6k 阅读时长 ≈ 3 分钟

Python [Python3网络爬虫开发实战] 6.3-Ajax结果提取

这里仍然以微博为例，接下来用 Python 来模拟这些 Ajax 请求，把我发过的微博爬取下来。

1. 分析请求

打开 Ajax 的 XHR 过滤器，然后一直滑动页面以加载新的微博内容。可以看到，会不断有 Ajax 请求发出。

选定其中一个请求，分析它的参数信息。点击该请求，进入详情页面，如图 6-11 所示。

图 6-11 详情页面

可以发现，这是一个 GET 类型的请求，请求链接为[https://m.weibo.cn/api/container/getIndex?type=uid&value=2830678474&containerid=1076032830678474&page=2)。请求的参数有4个：`type`、`value`、`containerid`和`page`。

随后再看看其他请求，可以发现，它们的type、value和containerid始终如一。type始终为uid，value的值就是页面链接中的数字，其实这就是用户的id。另外，还有containerid。可以发现，它就是 107603 加上用户id。改变的值就是page，很明显这个参数是用来控制分页的，page=1代表第一页，page=2代表第二页，以此类推。

2. 分析响应

随后，观察这个请求的响应内容，如图 6-12 所示。

图 6-12 响应内容

这个内容是 JSON 格式的，浏览器开发者工具自动做了解析以方便我们查看。可以看到，最关键的两部分信息就是cardlistInfo和cards：前者包含一个比较重要的信息total，观察后可以发现，它其实是微博的总数量，我们可以根据这个数字来估算分页数；后者则是一个列表，它包含 10 个元素，展开其中一个看一下，如图 6-13 所示。

图 6-13 列表内容

可以发现，这个元素有一个比较重要的字段mblog。展开它，可以发现它包含的正是微博的一些信息，比如attitudes_count（赞数目）、comments_count（评论数目）、reposts_count（转发数目）、created_at（发布时间）、text（微博正文）等，而且它们都是一些格式化的内容。

这样我们请求一个接口，就可以得到 10 条微博，而且请求时只需要改变page参数即可。

这样的话，我们只需要简单做一个循环，就可以获取所有微博了。

3. 实战演练

这里我们用程序模拟这些 Ajax 请求，将我的前 10 页微博全部爬取下来。

首先，定义一个方法来获取每次请求的结果。在请求时，page是一个可变参数，所以我们将它作为方法的参数传递进来，相关代码如下：

from urllib.parse import urlencode
import requests
base_url = 'https://m.weibo.cn/api/container/getIndex?'

headers = {
    'Host': 'm.weibo.cn',
    'Referer': 'https://m.weibo.cn/u/2830678474',
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36',
    'X-Requested-With': 'XMLHttpRequest',
}

def get_page(page):
    params = {
        'type': 'uid',
        'value': '2830678474',
        'containerid': '1076032830678474',
        'page': page
    }
    url = base_url + urlencode(params)
    try:
        response = requests.get(url, headers=headers)
        if response.status_code == 200:
            return response.json()
    except requests.ConnectionError as e:
        print('Error', e.args)

首先，这里定义了base_url来表示请求的 URL 的前半部分。接下来，构造参数字典，其中type、value和containerid是固定参数，page是可变参数。接下来，调用urlencode()方法将参数转化为 URL 的 GET 请求参数，即类似于type=uid&value=2830678474&containerid=1076032830678474&page=2这样的形式。随后，base_url与参数拼合形成一个新的 URL。接着，我们用 requests 请求这个链接，加入headers参数。然后判断响应的状态码，如果是 200，则直接调用json()方法将内容解析为 JSON 返回，否则不返回任何信息。如果出现异常，则捕获并输出其异常信息。

随后，我们需要定义一个解析方法，用来从结果中提取想要的信息，比如这次想保存微博的id、正文、赞数、评论数和转发数这几个内容，那么可以先遍历cards，然后获取mblog中的各个信息，赋值为一个新的字典返回即可：

from pyquery import PyQuery as pq

def parse_page(json):
    if json:
        items = json.get('data').get('cards')
        for item in items:
            item = item.get('mblog')
            weibo = {}
            weibo['id'] = item.get('id')
            weibo['text'] = pq(item.get('text')).text()
            weibo['attitudes'] = item.get('attitudes_count')
            weibo['comments'] = item.get('comments_count')
            weibo['reposts'] = item.get('reposts_count')
            yield weibo

这里我们借助 pyquery 将正文中的 HTML 标签去掉。

最后，遍历一下page，一共 10 页，将提取到的结果打印输出即可：

if __name__ == '__main__':
    for page in range(1, 11):
        json = get_page(page)
        results = parse_page(json)
        for result in results:
            print(result)

另外，我们还可以加一个方法将结果保存到 MongoDB 数据库：

from pymongo import MongoClient

client = MongoClient()
db = client['weibo']
collection = db['weibo']

def save_to_mongo(result):
    if collection.insert(result):
        print('Saved to Mongo')

这样所有功能就实现完成了。运行程序后，样例输出结果如下：

{'id': '4134879836735238', 'text': '惊不惊喜，刺不刺激，意不意外，感不感动', 'attitudes': 3, 'comments': 1, 'reposts': 0}
Saved to Mongo
{'id': '4143853554221385', 'text': '曾经梦想仗剑走天涯，后来过安检给收走了。分享单曲 远走高飞', 'attitudes': 5, 'comments': 1, 'reposts': 0}
Saved to Mongo

查看一下 MongoDB，相应的数据也被保存到 MongoDB，如图 6-14 所示。

图 6-14 保存结果

这样，我们就顺利通过分析 Ajax 并编写爬虫爬取下来了微博列表，最后，给出本节的代码地址：https://github.com/Python3WebSpider/WeiboList。

本节的目的是为了演示 Ajax 的模拟请求过程，爬取的结果不是重点。该程序仍有很多可以完善的地方，如页码的动态计算、微博查看全文等，若感兴趣，可以尝试一下。

通过这个实例，我们主要学会了怎样去分析 Ajax 请求，怎样用程序来模拟抓取 Ajax 请求。了解了抓取原理之后，下一节的 Ajax 实战演练会更加得心应手。

作者崔庆才发表于 2018-01-30 阅读次数：本文字数： 3.5k 阅读时长 ≈ 3 分钟

Python [Python3网络爬虫开发实战] 6.2-Ajax分析方法

这里还以前面的微博为例，我们知道拖动刷新的内容由 Ajax 加载，而且页面的 URL 没有变化，那么应该到哪里去查看这些 Ajax 请求呢？

1. 查看请求

这里还需要借助浏览器的开发者工具，下面以 Chrome 浏览器为例来介绍。

首先，用 Chrome 浏览器打开微博的链接https://m.weibo.cn/u/2830678474，随后在页面中点击鼠标右键，从弹出的快捷菜单中选择“检查”选项，此时便会弹出开发者工具，如图 6-2 所示：

图 6-2 开发者工具

此时在 Elements 选项卡中便会观察到网页的源代码，右侧便是节点的样式。

不过这不是我们想要寻找的内容。切换到 Network 选项卡，随后重新刷新页面，可以发现这里出现了非常多的条目，如图 6-3 所示。

图 6-3 Network 面板结果

前面也提到过，这里其实就是在页面加载过程中浏览器与服务器之间发送请求和接收响应的所有记录。

Ajax 其实有其特殊的请求类型，它叫作xhr。在图 6-3 中，我们可以发现一个名称以 getIndex 开头的请求，其 Type 为xhr，这就是一个 Ajax 请求。用鼠标点击这个请求，可以查看这个请求的详细信息，如图 6-4 所示。

图 6-4 详细信息

在右侧可以观察到其 Request Headers、URL 和 Response Headers 等信息。其中 Request Headers 中有一个信息为 X-Requested-With:XMLHttpRequest，这就标记了此请求是 Ajax 请求，如图 6-5 所示。

图 6-5 详细信息

随后点击一下 Preview，即可看到响应的内容，它是 JSON 格式的。这里 Chrome 为我们自动做了解析，点击箭头即可展开和收起相应内容，如图 6-6 所示。

图 6-6 JSON 结果

观察可以发现，这里的返回结果是我的个人信息，如昵称、简介、头像等，这也是用来渲染个人主页所使用的数据。JavaScript 接收到这些数据之后，再执行相应的渲染方法，整个页面就渲染出来了。

另外，也可以切换到 Response 选项卡，从中观察到真实的返回数据，如图 6-7 所示。

图 6-7 Response 内容

接下来，切回到第一个请求，观察一下它的 Response 是什么，如图 6-8 所示。

图 6-8 Response 内容

这是最原始的链接https://m.weibo.cn/u/2830678474返回的结果，其代码只有不到 50 行，结构也非常简单，只是执行了一些 JavaScript。

所以说，我们看到的微博页面的真实数据并不是最原始的页面返回的，而是后来执行 JavaScript 后再次向后台发送了 Ajax 请求，浏览器拿到数据后再进一步渲染出来的。

2. 过滤请求

接下来，再利用 Chrome 开发者工具的筛选功能筛选出所有的 Ajax 请求。在请求的上方有一层筛选栏，直接点击 XHR，此时在下方显示的所有请求便都是 Ajax 请求了，如图 6-9 所示。

图 6-9 Ajax 请求

接下来，不断滑动页面，可以看到页面底部有一条条新的微博被刷出，而开发者工具下方也一个个地出现 Ajax 请求，这样我们就可以捕获到所有的 Ajax 请求了。

随意点开一个条目，都可以清楚地看到其 Request URL、Request Headers、Response Headers、Response Body 等内容，此时想要模拟请求和提取就非常简单了。

图 6-10 所示的内容便是我的某一页微博的列表信息。

图 6-10 微博列表信息

到现在为止，我们已经可以分析出来 Ajax 请求的一些详细信息了，接下来只需要用程序模拟这些 Ajax 请求，就可以轻松提取我们所需要的信息了。

在下一节中，我们用 Python 实现 Ajax 请求的模拟，从而实现数据的抓取。

作者崔庆才发表于 2018-01-30 阅读次数：本文字数： 1.5k 阅读时长 ≈ 1 分钟

Python [Python3网络爬虫开发实战] 6.1-什么是Ajax

Ajax，全称为 Asynchronous JavaScript and XML，即异步的 JavaScript 和 XML。它不是一门编程语言，而是利用 JavaScript 在保证页面不被刷新、页面链接不改变的情况下与服务器交换数据并更新部分网页的技术。

对于传统的网页，如果想更新其内容，那么必须要刷新整个页面，但有了 Ajax，便可以在页面不被全部刷新的情况下更新其内容。在这个过程中，页面实际上是在后台与服务器进行了数据交互，获取到数据之后，再利用 JavaScript 改变网页，这样网页内容就会更新了。

可以到 W3School 上体验几个示例来感受一下：http://www.w3school.com.cn/ajax/ajax_xmlhttprequest_send.asp。

1. 实例引入

浏览网页的时候，我们会发现很多网页都有下滑查看更多的选项。比如，拿微博来说，我们以我的个人的主页为例：https://m.weibo.cn/u/2830678474，切换到微博页面，一直下滑，可以发现下滑几个微博之后，再向下就没有了，转而会出现一个加载的动画，不一会儿下方就继续出现了新的微博内容，这个过程其实就是 Ajax 加载的过程，如图 6-1 所示。

图 6-1 页面加载过程

我们注意到页面其实并没有整个刷新，也就意味着页面的链接没有变化，但是网页中却多了新内容，也就是后面刷出来的新微博。这就是通过 Ajax 获取新数据并呈现的过程。

2. 基本原理

初步了解了 Ajax 之后，我们再来详细了解它的基本原理。发送 Ajax 请求到网页更新的这个过程可以简单分为以下 3 步：

(1) 发送请求； (2) 解析内容； (3) 渲染网页。

下面我们分别来详细介绍这几个过程。

发送请求

我们知道 JavaScript 可以实现页面的各种交互功能，Ajax 也不例外，它也是由 JavaScript 实现的，实际上执行了如下代码：

var xmlhttp;
if (window.XMLHttpRequest) {
    // code for IE7+, Firefox, Chrome, Opera, Safari
    xmlhttp=new XMLHttpRequest();
} else {// code for IE6, IE5
    xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
}
xmlhttp.onreadystatechange=function() {
    if (xmlhttp.readyState==4 && xmlhttp.status==200) {
        document.getElementById("myDiv").innerHTML=xmlhttp.responseText;
    }
}
xmlhttp.open("POST","/ajax/",true);
xmlhttp.send();

这是 JavaScript 对 Ajax 最底层的实现，实际上就是新建了XMLHttpRequest对象，然后调用onreadystatechange属性设置了监听，然后调用open()和send()方法向某个链接（也就是服务器）发送了请求。前面用 Python 实现请求发送之后，可以得到响应结果，但这里请求的发送变成 JavaScript 来完成.由于设置了监听，所以当服务器返回响应时，onreadystatechange对应的方法便会被触发，然后在这个方法里面解析响应内容即可。

解析内容

得到响应之后，onreadystatechange属性对应的方法便会被触发，此时利用xmlhttp的responseText属性便可取到响应内容。这类似于 Python 中利用 requests 向服务器发起请求，然后得到响应的过程。那么返回内容可能是 HTML，可能是 JSON，接下来只需要在方法中用 JavaScript 进一步处理即可。比如，如果是 JSON 的话，可以进行解析和转化。

渲染网页

JavaScript 有改变网页内容的能力，解析完响应内容之后，就可以调用 JavaScript 来针对解析完的内容对网页进行下一步处理了。比如，通过document.getElementById().innerHTML这样的操作，便可以对某个元素内的源代码进行更改，这样网页显示的内容就改变了，这样的操作也被称作 DOM 操作，即对 Document 网页文档进行操作，如更改、删除等。

上例中，document.getElementById("myDiv").innerHTML=xmlhttp.responseText便将ID为myDiv的节点内部的 HTML 代码更改为服务器返回的内容，这样myDiv元素内部便会呈现出服务器返回的新数据，网页的部分内容看上去就更新了。

我们观察到，这 3 个步骤其实都是由 JavaScript 完成的，它完成了整个请求、解析和渲染的过程。

再回想微博的下拉刷新，这其实就是 JavaScript 向服务器发送了一个 Ajax 请求，然后获取新的微博数据，将其解析，并将其渲染在网页中。

因此，我们知道，真实的数据其实都是一次次 Ajax 请求得到的，如果想要抓取这些数据，需要知道这些请求到底是怎么发送的，发往哪里，发了哪些参数。如果我们知道了这些，不就可以用 Python 模拟这个发送操作，获取到其中的结果了吗？

在下一节中，我们就来了解下到哪里可以看到这些后台 Ajax 操作，去了解它到底是怎么发送的，发送了什么参数。

作者崔庆才发表于 2018-01-30 阅读次数：本文字数： 2.3k 阅读时长 ≈ 2 分钟

Python [Python3网络爬虫开发实战] 6-Ajax数据爬取

有时候我们在用requests抓取页面的时候，得到的结果可能和在浏览器中看到的不一样：在浏览器中可以看到正常显示的页面数据，但是使用requests得到的结果并没有。这是因为requests获取的都是原始的HTML文档，而浏览器中的页面则是经过JavaScript处理数据后生成的结果，这些数据的来源有多种，可能是通过Ajax加载的，可能是包含在HTML文档中的，也可能是经过JavaScript和特定算法计算后生成的。

对于第一种情况，数据加载是一种异步加载方式，原始的页面最初不会包含某些数据，原始页面加载完后，会再向服务器请求某个接口获取数据，然后数据才被处理从而呈现到网页上，这其实就是发送了一个Ajax请求。

照Web发展的趋势来看，这种形式的页面越来越多。网页的原始HTML文档不会包含任何数据，数据都是通过Ajax统一加载后再呈现出来的，这样在Web开发上可以做到前后端分离，而且降低服务器直接渲染页面带来的压力。

所以如果遇到这样的页面，直接利用requests等库来抓取原始页面，是无法获取到有效数据的，这时需要分析网页后台向接口发送的Ajax请求，如果可以用requests来模拟Ajax请求，那么就可以成功抓取了。

所以，本章我们的主要目的是了解什么是Ajax以及如何去分析和抓取Ajax请求。

作者崔庆才发表于 2018-01-30 阅读次数：本文字数： 554 阅读时长 ≈ 1 分钟

Python [Python3网络爬虫开发实战] 5.3.2-Redis存储

Redis是一个基于内存的高效的键值型非关系型数据库，存取效率极高，而且支持多种存储数据结构，使用也非常简单。本节中，我们就来介绍一下Python的Redis操作，主要介绍RedisPy这个库的用法。

1. 准备工作

在开始之前，请确保已经安装好了Redis及RedisPy库。如果要做数据导入/导出操作的话，还需要安装RedisDump。如果没有安装，可以参考第1章。

2. `Redis`和`StrictRedis`

RedisPy库提供两个类Redis和StrictRedis来实现Redis的命令操作。

StrictRedis实现了绝大部分官方的命令，参数也一一对应，比如set()方法就对应Redis命令的set方法。而Redis是StrictRedis的子类，它的主要功能是用于向后兼容旧版本库里的几个方法。为了做兼容，它将方法做了改写，比如lrem()方法就将value和num参数的位置互换，这和Redis命令行的命令参数不一致。

官方推荐使用StrictRedis，所以本节中我们也用StrictRedis类的相关方法作演示。

3. 连接Redis

现在我们已经在本地安装了Redis并运行在6379端口，密码设置为foobared。那么，可以用如下示例连接Redis并测试：

from redis import StrictRedis

redis = StrictRedis(host='localhost', port=6379, db=0, password='foobared')
redis.set('name', 'Bob')
print(redis.get('name'))

这里我们传入了Redis的地址、运行端口、使用的数据库和密码信息。在默认不传的情况下，这4个参数分别为localhost、6379、0和None。首先声明了一个StrictRedis对象，接下来调用set()方法，设置一个键值对，然后将其获取并打印。

运行结果如下：

b'Bob'

这说明我们连接成功，并可以执行set()和get()操作了。

当然，我们还可以使用ConnectionPool来连接，示例如下：

from redis import StrictRedis, ConnectionPool

pool = ConnectionPool(host='localhost', port=6379, db=0, password='foobared')
redis = StrictRedis(connection_pool=pool)

这样的连接效果是一样的。观察源码可以发现，StrictRedis内其实就是用host和port等参数又构造了一个ConnectionPool，所以直接将ConnectionPool当作参数传给StrictRedis也一样。

另外，ConnectionPool还支持通过URL来构建。URL的格式支持有如下3种：

1
2
3

redis://[:password]@host:port/db
rediss://[:password]@host:port/db
unix://[:password]@/path/to/socket.sock?db=db

这3种URL分别表示创建Redis TCP连接、Redis TCP+SSL连接、Redis UNIX socket连接。我们只需要构造上面任意一种URL即可，其中password部分如果有则可以写，没有则可以省略。下面再用URL连接演示一下：

1
2
3

url = 'redis://:foobared@localhost:6379/0'
pool = ConnectionPool.from_url(url)
redis = StrictRedis(connection_pool=pool)

这里我们使用第一种连接字符串进行连接。首先，声明一个Redis连接字符串，然后调用from_url()方法创建ConnectionPool，接着将其传给StrictRedis即可完成连接，所以使用URL的连接方式还是比较方便的。

4. 键操作

表5-5总结了键的一些判断和操作方法。

表5-5 键的一些判断和操作方法

方法

作用

参数说明

示例

示例说明

示例结果

exists(name)

判断一个键是否存在

name：键名

redis.exists('name')

是否存在name这个键

True

delete(name)

删除一个键

name：键名

redis.delete('name')

删除name这个键

type(name)

判断键类型

name：键名

redis.type('name')

判断name这个键类型

b'string'

keys(pattern)

获取所有符合规则的键

pattern：匹配规则

redis.keys('n*')

获取所有以n开头的键

[b'name']

randomkey()

获取随机的一个键

randomkey()

获取随机的一个键

b'name'

rename(src, dst)

重命名键

src：原键名；dst：新键名

redis.rename('name', 'nickname')

将name重命名为nickname

True

dbsize()

获取当前数据库中键的数目

dbsize()

获取当前数据库中键的数目

100

expire(name, time)

设定键的过期时间，单位为秒

name：键名；time：秒数

redis.expire('name', 2)

将name键的过期时间设置为2秒

True

ttl(name)

获取键的过期时间，单位为秒，-1表示永久不过期

name：键名

redis.ttl('name')

获取name这个键的过期时间

-1

move(name, db)

将键移动到其他数据库

name：键名；db：数据库代号

move('name', 2)

将name移动到2号数据库

True

flushdb()

删除当前选择数据库中的所有键

flushdb()

删除当前选择数据库中的所有键

True

flushall()

删除所有数据库中的所有键

flushall()

删除所有数据库中的所有键

True

5. 字符串操作

Redis支持最基本的键值对形式存储，用法总结如表5-6所示。

表5-6 键值对形式存储

方法

作用

参数说明

示例

示例说明

示例结果

set(name, value)

给数据库中键为name的string赋予值value

name: 键名；value: 值

redis.set('name', 'Bob')

给name这个键的value赋值为Bob

True

get(name)

返回数据库中键为name的string的value

name：键名

redis.get('name')

返回name这个键的value

b'Bob'

getset(name, value)

给数据库中键为name的string赋予值value并返回上次的value

name：键名；value：新值

redis.getset('name', 'Mike')

赋值name为Mike并得到上次的value

b'Bob'

mget(keys, *args)

返回多个键对应的value

keys：键的列表

redis.mget(['name', 'nickname'])

返回name和nickname的value

[b'Mike', b'Miker']

setnx(name, value)

如果不存在这个键值对，则更新value，否则不变

name：键名

redis.setnx('newname', 'James')

如果newname这个键不存在，则设置值为James

第一次运行结果是True，第二次运行结果是False

setex(name, time, value)

设置可以对应的值为string类型的value，并指定此键值对应的有效期

name: 键名；time: 有效期； value：值

redis.setex('name', 1, 'James')

将name这个键的值设为James，有效期为1秒

True

setrange(name, offset, value)

设置指定键的value值的子字符串

name：键名；offset：偏移量；value：值

redis.set('name', 'Hello') redis.setrange('name', 6, 'World')

设置name为Hello字符串，并在index为6的位置补World

11，修改后的字符串长度

mset(mapping)

批量赋值

mapping：字典

redis.mset({'name1': 'Durant', 'name2': 'James'})

将name1设为Durant，name2设为James

True

msetnx(mapping)

键均不存在时才批量赋值

mapping：字典

redis.msetnx({'name3': 'Smith', 'name4': 'Curry'})

在name3和name4均不存在的情况下才设置二者值

True

incr(name, amount=1)

键为name的value增值操作，默认为1，键不存在则被创建并设为amount

name：键名；amount：增长的值

redis.incr('age', 1)

age对应的值增1，若不存在，则会创建并设置为1

1，即修改后的值

decr(name, amount=1)

键为name的value减值操作，默认为1，键不存在则被创建并将value设置为\-amount

name：键名； amount：减少的值

redis.decr('age', 1)

age对应的值减1，若不存在，则会创建并设置为-1

-1，即修改后的值

append(key, value)

键为name的string的值附加value

key：键名

redis.append('nickname', 'OK')

向键为nickname的值后追加OK

13，即修改后的字符串长度

substr(name, start, end=-1)

返回键为name的string的子串

name：键名；start：起始索引；end：终止索引，默认为-1，表示截取到末尾

redis.substr('name', 1, 4)

返回键为name的值的字符串，截取索引为1~4的字符

b'ello'

getrange(key, start, end)

获取键的value值从start到end的子字符串

key：键名；start：起始索引；end：终止索引

redis.getrange('name', 1, 4)

返回键为name的值的字符串，截取索引为1~4的字符

b'ello'

6. 列表操作

Redis还提供了列表存储，列表内的元素可以重复，而且可以从两端存储，用法如表5-7所示。

表5-7 列表操作

方法

作用

参数说明

示例

示例说明

示例结果

rpush(name, *values)

在键为name的列表末尾添加值为value的元素，可以传多个

name：键名；values：值

redis.rpush('list', 1, 2, 3)

向键为list的列表尾添加1、2、3

3，列表大小

lpush(name, *values)

在键为name的列表头添加值为value的元素，可以传多个

name：键名；values：值

redis.lpush('list', 0)

向键为list的列表头部添加0

4，列表大小

llen(name)

返回键为name的列表的长度

name：键名

redis.llen('list')

返回键为list的列表的长度

lrange(name, start, end)

返回键为name的列表中start至end之间的元素

name：键名；start：起始索引；end：终止索引

redis.lrange('list', 1, 3)

返回起始索引为1终止索引为3的索引范围对应的列表

[b'3', b'2', b'1']

ltrim(name, start, end)

截取键为name的列表，保留索引为start到end的内容

name：键名；start：起始索引；end：终止索引

ltrim('list', 1, 3)

保留键为list的索引为1到3的元素

True

lindex(name, index)

返回键为name的列表中index位置的元素

name：键名；index：索引

redis.lindex('list', 1)

返回键为list的列表索引为1的元素

b’2’

lset(name, index, value)

给键为name的列表中index位置的元素赋值，越界则报错

name：键名；index：索引位置；value：值

redis.lset('list', 1, 5)

将键为list的列表中索引为1的位置赋值为5

True

lrem(name, count, value)

删除count个键的列表中值为value的元素

name：键名；count：删除个数；value：值

redis.lrem('list', 2, 3)

将键为list的列表删除两个3

1，即删除的个数

lpop(name)

返回并删除键为name的列表中的首元素

name：键名

redis.lpop('list')

返回并删除名为list的列表中的第一个元素

b'5'

rpop(name)

返回并删除键为name的列表中的尾元素

name：键名

redis.rpop('list')

返回并删除名为list的列表中的最后一个元素

b'2'

blpop(keys, timeout=0)

返回并删除名称在keys中的list中的首个元素，如果列表为空，则会一直阻塞等待

keys：键列表；timeout：超时等待时间，0为一直等待

redis.blpop('list')

返回并删除键为list的列表中的第一个元素

[b'5']

brpop(keys, timeout=0)

返回并删除键为name的列表中的尾元素，如果list为空，则会一直阻塞等待

keys：键列表；timeout：超时等待时间，0为一直等待

redis.brpop('list')

返回并删除名为list的列表中的最后一个元素

[b'2']

rpoplpush(src, dst)

返回并删除名称为src的列表的尾元素，并将该元素添加到名称为dst的列表头部

src：源列表的键；dst：目标列表的key

redis.rpoplpush('list', 'list2')

将键为list的列表尾元素删除并将其添加到键为list2的列表头部，然后返回

b'2'

7. 集合操作

Redis还提供了集合存储，集合中的元素都是不重复的，用法如表5-8所示。

表5-8 集合操作

方法

作用

参数说明

示例

示例说明

示例结果

sadd(name, *values)

向键为name的集合中添加元素

name：键名；values：值，可为多个

redis.sadd('tags', 'Book', 'Tea', 'Coffee')

向键为tags的集合中添加Book、Tea和Coffee这3个内容

3，即插入的数据个数

srem(name, *values)

从键为name的集合中删除元素

name：键名；values：值，可为多个

redis.srem('tags', 'Book')

从键为tags的集合中删除Book

1，即删除的数据个数

spop(name)

随机返回并删除键为name的集合中的一个元素

name：键名

redis.spop('tags')

从键为tags的集合中随机删除并返回该元素

b'Tea'

smove(src, dst, value)

从src对应的集合中移除元素并将其添加到dst对应的集合中

src：源集合；dst：目标集合；value：元素值

redis.smove('tags', 'tags2', 'Coffee')

从键为tags的集合中删除元素Coffee并将其添加到键为tags2的集合

True

scard(name)

返回键为name的集合的元素个数

name：键名

redis.scard('tags')

获取键为tags的集合中的元素个数

sismember(name, value)

测试member是否是键为name的集合的元素

name：键值

redis.sismember('tags', 'Book')

判断Book是否是键为tags的集合元素

True

sinter(keys, *args)

返回所有给定键的集合的交集

keys：键列表

redis.sinter(['tags', 'tags2'])

返回键为tags的集合和键为tags2的集合的交集

{b'Coffee'}

sinterstore(dest, keys, *args)

求交集并将交集保存到dest的集合

dest：结果集合；keys：键列表

redis.sinterstore('inttag', ['tags', 'tags2'])

求键为tags的集合和键为tags2的集合的交集并将其保存为inttag

sunion(keys, *args)

返回所有给定键的集合的并集

keys：键列表

redis.sunion(['tags', 'tags2'])

返回键为tags的集合和键为tags2的集合的并集

{b'Coffee', b'Book', b'Pen'}

sunionstore(dest, keys, *args)

求并集并将并集保存到dest的集合

dest：结果集合；keys：键列表

redis.sunionstore('inttag', ['tags', 'tags2'])

求键为tags的集合和键为tags2的集合的并集并将其保存为inttag

sdiff(keys, *args)

返回所有给定键的集合的差集

keys：键列表

redis.sdiff(['tags', 'tags2'])

返回键为tags的集合和键为tags2的集合的差集

{b'Book', b'Pen'}

sdiffstore(dest, keys, *args)

求差集并将差集保存到dest集合

dest：结果集合；keys：键列表

redis.sdiffstore('inttag', ['tags', 'tags2'])

求键为tags的集合和键为tags2的集合的差集并将其保存为inttag`

smembers(name)

返回键为name的集合的所有元素

name：键名

redis.smembers('tags')

返回键为tags的集合的所有元素

{b'Pen', b'Book', b'Coffee'}

srandmember(name)

随机返回键为name的集合中的一个元素，但不删除元素

name：键值

redis.srandmember('tags')

随机返回键为tags的集合中的一个元素

8. 有序集合操作

有序集合比集合多了一个分数字段，利用它可以对集合中的数据进行排序，其用法总结如表5-9所示。

表5-9 有序集合操作

方法

作用

参数说明

示例

示例说明

示例结果

zadd(name, *args, **kwargs)

向键为name的zset中添加元素member，score用于排序。如果该元素存在，则更新其顺序

name：键名；args：可变参数

redis.zadd('grade', 100, 'Bob', 98, 'Mike')

向键为grade的zset中添加Bob（其score为100），并添加Mike（其score为98）

2，即添加的元素个数

zrem(name, *values)

删除键为name的zset中的元素

name：键名；values：元素

redis.zrem('grade', 'Mike')

从键为grade的zset中删除Mike

1，即删除的元素个数

zincrby(name, value, amount=1)

如果在键为name的zset中已经存在元素value，则将该元素的score增加amount；否则向该集合中添加该元素，其score的值为amount

name：key名；value：元素；amount：增长的score值

redis.zincrby('grade', 'Bob', -2)

键为grade的zset中Bob的score减2

98.0，即修改后的值

zrank(name, value)

返回键为name的zset中元素的排名，按score从小到大排序，即名次

name：键名；value：元素值

redis.zrank('grade', 'Amy')

得到键为grade的zset中Amy的排名

zrevrank(name, value)

返回键为name的zset中元素的倒数排名（按score从大到小排序），即名次

name：键名；value：元素值

redis.zrevrank('grade', 'Amy')

得到键为grade的zset中Amy的倒数排名

zrevrange(name, start, end, withscores=False)

返回键为name的zset（按score从大到小排序）中index从start到end的所有元素

name：键值；start：开始索引；end：结束索引；withscores：是否带score

redis.zrevrange('grade', 0, 3)

返回键为grade的zset中前四名元素

[b'Bob', b'Mike', b'Amy', b'James']

zrangebyscore(name, min, max, start=None, num=None, withscores=False)

返回键为name的zset中score在给定区间的元素

name：键名；min：最低score；max：最高score； start：起始索引；num：个数；withscores：是否带score

redis.zrangebyscore('grade', 80, 95)

返回键为grade的zset中score在80和95之间的元素

[b'Bob', b'Mike', b'Amy', b'James']

zcount(name, min, max)

返回键为name的zset中score在给定区间的数量

name：键名；min：最低score；max：最高score

redis.zcount('grade', 80, 95)

返回键为grade的zset中score在80到95的元素个数

zcard(name)

返回键为name的zset的元素个数

name：键名

redis.zcard('grade')

获取键为grade的zset中元素的个数

zremrangebyrank(name, min, max)

删除键为name的zset中排名在给定区间的元素

name：键名；min：最低位次；max：最高位次

redis.zremrangebyrank('grade', 0, 0)

删除键为grade的zset中排名第一的元素

1，即删除的元素个数

zremrangebyscore(name, min, max)

删除键为name的zset中score在给定区间的元素

name：键名；min：最低score；max：最高score

redis.zremrangebyscore('grade', 80, 90)

删除score在80到90之间的元素

1，即删除的元素个数

9. 散列操作

Redis还提供了散列表的数据结构，我们可以用name指定一个散列表的名称，表内存储了各个键值对，用法总结如表5-10所示。

表5-10 散列操作

方法

作用

参数说明

示例

示例说明

示例结果

hset(name, key, value)

向键为name的散列表中添加映射

name：键名；key：映射键名；value：映射键值

hset('price', 'cake', 5)

向键为price的散列表中添加映射关系，cake的值为5

1，即添加的映射个数

hsetnx(name, key, value)

如果映射键名不存在，则向键为name的散列表中添加映射

name：键名；key：映射键名；value：映射键值

hsetnx('price', 'book', 6)

向键为price的散列表中添加映射关系，book的值为6

1，即添加的映射个数

hget(name, key)

返回键为name的散列表中key对应的值

name：键名；key：映射键名

redis.hget('price', 'cake')

获取键为price的散列表中键名为cake的值

hmget(name, keys, *args)

返回键为name的散列表中各个键对应的值

name：键名；keys：映射键名列表

redis.hmget('price', ['apple', 'orange'])

获取键为price的散列表中apple和orange的值

[b'3', b'7']

hmset(name, mapping)

向键为name的散列表中批量添加映射

name：键名；mapping：映射字典

redis.hmset('price', {'banana': 2, 'pear': 6})

向键为price的散列表中批量添加映射

True

hincrby(name, key, amount=1)

将键为name的散列表中映射的值增加amount

name：键名；key：映射键名；amount：增长量

redis.hincrby('price', 'apple', 3)

key为price的散列表中apple的值增加3

6，修改后的值

hexists(name, key)

键为name的散列表中是否存在键名为键的映射

name：键名；key：映射键名

redis.hexists('price', 'banana')

键为price的散列表中banana的值是否存在

True

hdel(name, *keys)

在键为name的散列表中，删除键名为键的映射

name：键名；keys：映射键名

redis.hdel('price', 'banana')

从键为price的散列表中删除键名为banana的映射

True

hlen(name)

从键为name的散列表中获取映射个数

name：键名

redis.hlen('price')

从键为price的散列表中获取映射个数

hkeys(name)

从键为name的散列表中获取所有映射键名

name：键名

redis.hkeys('price')

从键为price的散列表中获取所有映射键名

[b'cake', b'book', b'banana', b'pear']

hvals(name)

从键为name的散列表中获取所有映射键值

name：键名

redis.hvals('price')

从键为price的散列表中获取所有映射键值

[b'5', b'6', b'2', b'6']

hgetall(name)

从键为name的散列表中获取所有映射键值对

name：键名

redis.hgetall('price')

从键为price的散列表中获取所有映射键值对

{b'cake': b'5', b'book': b'6', b'orange': b'7', b'pear': b'6'}

10. RedisDump

RedisDump提供了强大的Redis数据的导入和导出功能，现在就来看下它的具体用法。

首先，确保已经安装好了RedisDump。

RedisDump提供了两个可执行命令：redis-dump用于导出数据，redis-load用于导入数据。

`redis-dump`

首先，可以输入如下命令查看所有可选项：

1	redis-dump -h

运行结果如下：

Usage: redis-dump [global options] COMMAND [command options] 
    -u, --uri=S                      Redis URI (e.g. redis://hostname[:port])
    -d, --database=S                 Redis database (e.g. -d 15)
    -s, --sleep=S                    Sleep for S seconds after dumping (for debugging)
    -c, --count=S                    Chunk size (default: 10000)
    -f, --filter=S                   Filter selected keys (passed directly to redis' KEYS command)
    -O, --without_optimizations      Disable run time optimizations
    -V, --version                    Display version
    -D, --debug
        --nosafe

其中\-u代表Redis连接字符串，\-d代表数据库代号，\-s代表导出之后的休眠时间，\-c代表分块大小，默认是10000，\-f代表导出时的过滤器，\-O代表禁用运行时优化，\-V用于显示版本，\-D表示开启调试。

我们拿本地的Redis做测试，运行在6379端口上，密码为foobared，导出命令如下：

1	redis-dump -u :foobared@localhost:6379

如果没有密码的话，可以不加密码前缀，命令如下：

1	redis-dump -u localhost:6379

运行之后，可以将本地0至15号数据库的所有数据输出出来，例如：

{"db":0,"key":"name","ttl":-1,"type":"string","value":"James","size":5}
{"db":0,"key":"name2","ttl":-1,"type":"string","value":"Durant","size":6}
{"db":0,"key":"name3","ttl":-1,"type":"string","value":"Durant","size":6}
{"db":0,"key":"name4","ttl":-1,"type":"string","value":"HelloWorld","size":10}
{"db":0,"key":"name5","ttl":-1,"type":"string","value":"James","size":5}
{"db":0,"key":"name6","ttl":-1,"type":"string","value":"James","size":5}
{"db":0,"key":"age","ttl":-1,"type":"string","value":"1","size":1}
{"db":0,"key":"age2","ttl":-1,"type":"string","value":"-5","size":2}

每条数据都包含6个字段，其中db即数据库代号，key即键名，ttl即该键值对的有效时间，type即键值类型，value即内容，size即占用空间。

如果想要将其输出为JSON行文件，可以使用如下命令：

1	redis-dump -u :foobared@localhost:6379 > ./redis_data.jl

这样就可以成功将Redis的所有数据库的所有数据导出成JSON行文件了。

另外，可以使用\-d参数指定某个数据库的导出，例如只导出1号数据库的内容：

1	redis-dump -u :foobared@localhost:6379 -d 1 > ./redis.data.jl

如果只想导出特定的内容，比如想导出以adsl开头的数据，可以加入\-f参数用来过滤，命令如下：

1	redis-dump -u :foobared@localhost:6379 -f adsl:* > ./redis.data.jl

其中\-f参数即Redis的keys命令的参数，可以写一些过滤规则。

`redis-load`

同样，我们可以首先输入如下命令查看所有可选项：

1	redis-load -h

运行结果如下：

redis-load --help
  Try: redis-load [global options] COMMAND [command options] 
    -u, --uri=S                      Redis URI (e.g. redis://hostname[:port])
    -d, --database=S                 Redis database (e.g. -d 15)
    -s, --sleep=S                    Sleep for S seconds after dumping (for debugging)
    -n, --no_check_utf8
    -V, --version                    Display version
    -D, --debug
        --nosafe

其中\-u代表Redis连接字符串，\-d代表数据库代号，默认是全部，\-s代表导出之后的休眠时间，\-n代表不检测UTF-8编码，\-V表示显示版本，\-D表示开启调试。

我们可以将JSON行文件导入到Redis数据库中：

1	< redis_data.json redis-load -u :foobared@localhost:6379

这样就可以成功将JSON行文件导入到数据库中了。

另外，下面的命令同样可以达到同样的效果：

1	cat redis_data.json \| redis-load -u :foobared@localhost:6379

本节中，我们不仅了解了RedisPy对Redis数据库的一些基本操作，还演示了RedisDump对数据的导入导出操作。由于其便捷性和高效性，后面我们会利用Redis实现很多架构，如维护代理池、Cookies池、ADSL拨号代理池、Scrapy-Redis分布式架构等，所以Redis的操作需要好好掌握。

作者崔庆才发表于 2018-01-29 阅读次数：本文字数： 15k 阅读时长 ≈ 14 分钟

Python [Python3网络爬虫开发实战] 5.3.1-MongoDB存储

MongoDB是由C++语言编写的非关系型数据库，是一个基于分布式文件存储的开源数据库系统，其内容存储形式类似JSON对象，它的字段值可以包含其他文档、数组及文档数组，非常灵活。在这一节中，我们就来看看Python 3下MongoDB的存储操作。

1. 准备工作

在开始之前，请确保已经安装好了MongoDB并启动了其服务，并且安装好了Python的PyMongo库。如果没有安装，可以参考第1章。

2. 连接MongoDB

连接MongoDB时，我们需要使用PyMongo库里面的MongoClient。一般来说，传入MongoDB的IP及端口即可，其中第一个参数为地址host，第二个参数为端口port（如果不给它传递参数，默认是27017）：

1 2	import pymongo client = pymongo.MongoClient(host='localhost', port=27017)

这样就可以创建MongoDB的连接对象了。

另外，MongoClient的第一个参数host还可以直接传入MongoDB的连接字符串，它以mongodb开头，例如：

1	client = MongoClient('mongodb://localhost:27017/')

这也可以达到同样的连接效果。

3. 指定数据库

MongoDB中可以建立多个数据库，接下来我们需要指定操作哪个数据库。这里我们以test数据库为例来说明，下一步需要在程序中指定要使用的数据库：

1	db = client.test

这里调用client的test属性即可返回test数据库。当然，我们也可以这样指定：

1	db = client['test']

这两种方式是等价的。

4. 指定集合

MongoDB的每个数据库又包含许多集合（collection），它们类似于关系型数据库中的表。

下一步需要指定要操作的集合，这里指定一个集合名称为students。与指定数据库类似，指定集合也有两种方式：

1	collection = db.students

1	collection = db['students']

这样我们便声明了一个Collection对象。

5. 插入数据

接下来，便可以插入数据了。对于students这个集合，新建一条学生数据，这条数据以字典形式表示：

student = {
    'id': '20170101',
    'name': 'Jordan',
    'age': 20,
    'gender': 'male'
}

这里指定了学生的学号、姓名、年龄和性别。接下来，直接调用collection的insert()方法即可插入数据，代码如下：

1 2	result = collection.insert(student) print(result)

在MongoDB中，每条数据其实都有一个_id属性来唯一标识。如果没有显式指明该属性，MongoDB会自动产生一个ObjectId类型的_id属性。insert()方法会在执行后返回_id值。

运行结果如下：

1	5932a68615c2606814c91f3d

当然，我们也可以同时插入多条数据，只需要以列表形式传递即可，示例如下：

student1 = {
    'id': '20170101',
    'name': 'Jordan',
    'age': 20,
    'gender': 'male'
}

student2 = {
    'id': '20170202',
    'name': 'Mike',
    'age': 21,
    'gender': 'male'
}

result = collection.insert([student1, student2])
print(result)

返回结果是对应的_id的集合：

1	[ObjectId('5932a80115c2606a59e8a048'), ObjectId('5932a80115c2606a59e8a049')]

实际上，在PyMongo 3.x版本中，官方已经不推荐使用insert()方法了。当然，继续使用也没有什么问题。官方推荐使用insert_one()和insert_many()方法来分别插入单条记录和多条记录，示例如下：

student = {
    'id': '20170101',
    'name': 'Jordan',
    'age': 20,
    'gender': 'male'
}

result = collection.insert_one(student)
print(result)
print(result.inserted_id)

运行结果如下：

1 2	<pymongo.results.InsertOneResult object at 0x10d68b558> 5932ab0f15c2606f0c1cf6c5

与insert()方法不同，这次返回的是InsertOneResult对象，我们可以调用其inserted_id属性获取_id。

对于insert_many()方法，我们可以将数据以列表形式传递，示例如下：

student1 = {
    'id': '20170101',
    'name': 'Jordan',
    'age': 20,
    'gender': 'male'
}

student2 = {
    'id': '20170202',
    'name': 'Mike',
    'age': 21,
    'gender': 'male'
}

result = collection.insert_many([student1, student2])
print(result)
print(result.inserted_ids)

运行结果如下：

1 2	<pymongo.results.InsertManyResult object at 0x101dea558> [ObjectId('5932abf415c2607083d3b2ac'), ObjectId('5932abf415c2607083d3b2ad')]

该方法返回的类型是InsertManyResult，调用inserted_ids属性可以获取插入数据的_id列表。

6. 查询

插入数据后，我们可以利用find_one()或find()方法进行查询，其中find_one()查询得到的是单个结果，find()则返回一个生成器对象。示例如下：

1
2
3

result = collection.find_one({'name': 'Mike'})
print(type(result))
print(result)

这里我们查询name为Mike的数据，它的返回结果是字典类型，运行结果如下：

1 2	<class 'dict'> {'_id': ObjectId('5932a80115c2606a59e8a049'), 'id': '20170202', 'name': 'Mike', 'age': 21, 'gender': 'male'}

可以发现，它多了_id属性，这就是MongoDB在插入过程中自动添加的。

此外，我们也可以根据ObjectId来查询，此时需要使用bson库里面的objectid：

from bson.objectid import ObjectId

result = collection.find_one({'_id': ObjectId('593278c115c2602667ec6bae')})
print(result)

其查询结果依然是字典类型，具体如下：

1	{'_id': ObjectId('593278c115c2602667ec6bae'), 'id': '20170101', 'name': 'Jordan', 'age': 20, 'gender': 'male'}

当然，如果查询结果不存在，则会返回None。

对于多条数据的查询，我们可以使用find()方法。例如，这里查找年龄为20的数据，示例如下：

results = collection.find({'age': 20})
print(results)
for result in results:
    print(result)

运行结果如下：

<pymongo.cursor.Cursor object at 0x1032d5128>
{'_id': ObjectId('593278c115c2602667ec6bae'), 'id': '20170101', 'name': 'Jordan', 'age': 20, 'gender': 'male'}
{'_id': ObjectId('593278c815c2602678bb2b8d'), 'id': '20170102', 'name': 'Kevin', 'age': 20, 'gender': 'male'}
{'_id': ObjectId('593278d815c260269d7645a8'), 'id': '20170103', 'name': 'Harden', 'age': 20, 'gender': 'male'}

返回结果是Cursor类型，它相当于一个生成器，我们需要遍历取到所有的结果，其中每个结果都是字典类型。

如果要查询年龄大于20的数据，则写法如下：

1	results = collection.find({'age': {'$gt': 20}})

这里查询的条件键值已经不是单纯的数字了，而是一个字典，其键名为比较符号$gt，意思是大于，键值为20。

这里将比较符号归纳为表5-3。

表5-3 比较符号

符号

含义

示例

$lt

小于

{'age': {'$lt': 20}}

$gt

大于

{'age': {'$gt': 20}}

$lte

小于等于

{'age': {'$lte': 20}}

$gte

大于等于

{'age': {'$gte': 20}}

$ne

不等于

{'age': {'$ne': 20}}

$in

在范围内

{'age': {'$in': [20, 23]}}

$nin

不在范围内

{'age': {'$nin': [20, 23]}}

另外，还可以进行正则匹配查询。例如，查询名字以M开头的学生数据，示例如下：

1	results = collection.find({'name': {'$regex': '^M.*'}})

这里使用$regex来指定正则匹配，^M.*代表以M开头的正则表达式。

这里将一些功能符号再归类为表5-4。

表5-4 功能符号

符号

含义

示例

示例含义

$regex

匹配正则表达式

{'name': {'$regex': '^M.*'}}

name以M开头

$exists

属性是否存在

{'name': {'$exists': True}}

name属性存在

$type

类型判断

{'age': {'$type': 'int'}}

age的类型为int

$mod

数字模操作

{'age': {'$mod': [5, 0]}}

年龄模5余0

$text

文本查询

{'$text': {'$search': 'Mike'}}

text类型的属性中包含Mike字符串

$where

高级条件查询

{'$where': 'obj.fans_count == obj.follows_count'}

自身粉丝数等于关注数

关于这些操作的更详细用法，可以在MongoDB官方文档找到：https://docs.mongodb.com/manual/reference/operator/query/。

7. 计数

要统计查询结果有多少条数据，可以调用count()方法。比如，统计所有数据条数：

1 2	count = collection.find().count() print(count)

或者统计符合某个条件的数据：

1 2	count = collection.find({'age': 20}).count() print(count)

运行结果是一个数值，即符合条件的数据条数。

8. 排序

排序时，直接调用sort()方法，并在其中传入排序的字段及升降序标志即可。示例如下：

1 2	results = collection.find().sort('name', pymongo.ASCENDING) print([result['name'] for result in results])

运行结果如下：

1	['Harden', 'Jordan', 'Kevin', 'Mark', 'Mike']

这里我们调用pymongo.ASCENDING指定升序。如果要降序排列，可以传入pymongo.DESCENDING。

9. 偏移

在某些情况下，我们可能想只取某几个元素，这时可以利用skip()方法偏移几个位置，比如偏移2，就忽略前两个元素，得到第三个及以后的元素：

1 2	results = collection.find().sort('name', pymongo.ASCENDING).skip(2) print([result['name'] for result in results])

运行结果如下：

1	['Kevin', 'Mark', 'Mike']

另外，还可以用limit()方法指定要取的结果个数，示例如下：

1 2	results = collection.find().sort('name', pymongo.ASCENDING).skip(2).limit(2) print([result['name'] for result in results])

运行结果如下：

1	['Kevin', 'Mark']

如果不使用limit()方法，原本会返回三个结果，加了限制后，会截取两个结果返回。

值得注意的是，在数据库数量非常庞大的时候，如千万、亿级别，最好不要使用大的偏移量来查询数据，因为这样很可能导致内存溢出。此时可以使用类似如下操作来查询：

1 2	from bson.objectid import ObjectId collection.find({'_id': {'$gt': ObjectId('593278c815c2602678bb2b8d')}})

这时需要记录好上次查询的_id。

10. 更新

对于数据更新，我们可以使用update()方法，指定更新的条件和更新后的数据即可。例如：

condition = {'name': 'Kevin'}
student = collection.find_one(condition)
student['age'] = 25
result = collection.update(condition, student)
print(result)

这里我们要更新name为Kevin的数据的年龄：首先指定查询条件，然后将数据查询出来，修改年龄后调用update()方法将原条件和修改后的数据传入。

运行结果如下：

1	{'ok': 1, 'nModified': 1, 'n': 1, 'updatedExisting': True}

返回结果是字典形式，ok代表执行成功，nModified代表影响的数据条数。

另外，我们也可以使用$set操作符对数据进行更新，代码如下：

1	result = collection.update(condition, {'$set': student})

这样可以只更新student字典内存在的字段。如果原先还有其他字段，则不会更新，也不会删除。而如果不用$set的话，则会把之前的数据全部用student字典替换；如果原本存在其他字段，则会被删除。

另外，update()方法其实也是官方不推荐使用的方法。这里也分为update_one()方法和update_many()方法，用法更加严格，它们的第二个参数需要使用$类型操作符作为字典的键名，示例如下：

condition = {'name': 'Kevin'}
student = collection.find_one(condition)
student['age'] = 26
result = collection.update_one(condition, {'$set': student})
print(result)
print(result.matched_count, result.modified_count)

这里调用了update_one()方法，第二个参数不能再直接传入修改后的字典，而是需要使用{'$set': student}这样的形式，其返回结果是UpdateResult类型。然后分别调用matched_count和modified_count属性，可以获得匹配的数据条数和影响的数据条数。

运行结果如下：

1 2	<pymongo.results.UpdateResult object at 0x10d17b678> 1 0

我们再看一个例子：

condition = {'age': {'$gt': 20}}
result = collection.update_one(condition, {'$inc': {'age': 1}})
print(result)
print(result.matched_count, result.modified_count)

这里指定查询条件为年龄大于20，然后更新条件为{'$inc': {'age': 1}}，也就是年龄加1，执行之后会将第一条符合条件的数据年龄加1。

运行结果如下：

1 2	<pymongo.results.UpdateResult object at 0x10b8874c8> 1 1

可以看到匹配条数为1条，影响条数也为1条。

如果调用update_many()方法，则会将所有符合条件的数据都更新，示例如下：

condition = {'age': {'$gt': 20}}
result = collection.update_many(condition, {'$inc': {'age': 1}})
print(result)
print(result.matched_count, result.modified_count)

这时匹配条数就不再为1条了，运行结果如下：

1 2	<pymongo.results.UpdateResult object at 0x10c6384c8> 3 3

可以看到，这时所有匹配到的数据都会被更新。

11. 删除

删除操作比较简单，直接调用remove()方法指定删除的条件即可，此时符合条件的所有数据均会被删除。示例如下：

1 2	result = collection.remove({'name': 'Kevin'}) print(result)

运行结果如下：

1	{'ok': 1, 'n': 1}

另外，这里依然存在两个新的推荐方法——delete_one()和delete_many()。示例如下：

result = collection.delete_one({'name': 'Kevin'})
print(result)
print(result.deleted_count)
result = collection.delete_many({'age': {'$lt': 25}})
print(result.deleted_count)

运行结果如下：

1
2
3

<pymongo.results.DeleteResult object at 0x10e6ba4c8>
1
4

delete_one()即删除第一条符合条件的数据，delete_many()即删除所有符合条件的数据。它们的返回结果都是DeleteResult类型，可以调用deleted_count属性获取删除的数据条数。

12. 其他操作

另外，PyMongo还提供了一些组合方法，如find_one_and_delete()、find_one_and_replace()和find_one_and_update()，它们是查找后删除、替换和更新操作，其用法与上述方法基本一致。

另外，还可以对索引进行操作，相关方法有create_index()、create_indexes()和drop_index()等。

关于PyMongo的详细用法，可以参见官方文档：http://api.mongodb.com/python/current/api/pymongo/collection.html。

另外，还有对数据库和集合本身等的一些操作，这里不再一一讲解，可以参见官方文档：http://api.mongodb.com/python/current/api/pymongo/。

本节讲解了使用PyMongo操作MongoDB进行数据增删改查的方法，后面我们会在实战案例中应用这些操作进行数据存储。

作者崔庆才发表于 2018-01-29 阅读次数：本文字数： 8.9k 阅读时长 ≈ 8 分钟

Python [Python3网络爬虫开发实战] 5.3-非关系型数据库存储

NoSQL，全称Not Only SQL，意为不仅仅是SQL，泛指非关系型数据库。NoSQL是基于键值对的，而且不需要经过SQL层的解析，数据之间没有耦合性，性能非常高。

非关系型数据库又可细分如下。

键值存储数据库：代表有Redis、Voldemort和Oracle BDB等。
列存储数据库：代表有Cassandra、HBase和Riak等。
文档型数据库：代表有CouchDB和MongoDB等。
图形数据库：代表有Neo4J、InfoGrid和Infinite Graph等。

对于爬虫的数据存储来说，一条数据可能存在某些字段提取失败而缺失的情况，而且数据可能随时调整。另外，数据之间还存在嵌套关系。如果使用关系型数据库存储，一是需要提前建表，二是如果存在数据嵌套关系的话，需要进行序列化操作才可以存储，这非常不方便。如果用了非关系型数据库，就可以避免一些麻烦，更简单高效。

本节中，我们主要介绍MongoDB和Redis的数据存储操作。

作者崔庆才发表于 2018-01-29 阅读次数：本文字数： 412 阅读时长 ≈ 1 分钟

Python [Python3网络爬虫开发实战] 5.2.1-MySQL存储

在Python 2中，连接MySQL的库大多是使用MySQLdb，但是此库的官方并不支持Python 3，所以这里推荐使用的库是PyMySQL。

本节中，我们就来讲解使用PyMySQL操作MySQL数据库的方法。

1. 准备工作

在开始之前，请确保已经安装好了MySQL数据库并保证它能正常运行，而且需要安装好PyMySQL库。如果没有安装，可以参考第1章。

2. 连接数据库

这里，首先尝试连接一下数据库。假设当前的MySQL运行在本地，用户名为root，密码为123456，运行端口为3306。这里利用PyMySQL先连接MySQL，然后创建一个新的数据库，名字叫作spiders，代码如下：

import pymysql

db = pymysql.connect(host='localhost',user='root', password='123456', port=3306)
cursor = db.cursor()
cursor.execute('SELECT VERSION()')
data = cursor.fetchone()
print('Database version:', data)
cursor.execute("CREATE DATABASE spiders DEFAULT CHARACTER SET utf8")
db.close()

运行结果如下：

1	Database version: ('5.6.22',)

这里通过PyMySQL的connect()方法声明一个MySQL连接对象db，此时需要传入MySQL运行的host（即IP）。由于MySQL在本地运行，所以传入的是localhost。如果MySQL在远程运行，则传入其公网IP地址。后续的参数user即用户名，password即密码，port即端口（默认为3306）。

连接成功后，需要再调用cursor()方法获得MySQL的操作游标，利用游标来执行SQL语句。这里我们执行了两句SQL，直接用execute()方法执行即可。第一句SQL用于获得MySQL的当前版本，然后调用fetchone()方法获得第一条数据，也就得到了版本号。第二句SQL执行创建数据库的操作，数据库名叫作spiders，默认编码为UTF-8。由于该语句不是查询语句，所以直接执行后就成功创建了数据库spiders。接着，再利用这个数据库进行后续的操作。

3. 创建表

一般来说，创建数据库的操作只需要执行一次就好了。当然，我们也可以手动创建数据库。以后，我们的操作都在spiders数据库上执行。

创建数据库后，在连接时需要额外指定一个参数db。

接下来，新创建一个数据表students，此时执行创建表的SQL语句即可。这里指定3个字段，结构如表5-1所示。

表5-1 数据表students

字段名

含义

类型

id

学号

varchar

name

姓名

varchar

age

年龄

int

创建该表的示例代码如下：

import pymysql

db = pymysql.connect(host='localhost', user='root', password='123456', port=3306, db='spiders')
cursor = db.cursor()
sql = 'CREATE TABLE IF NOT EXISTS students (id VARCHAR(255) NOT NULL, name VARCHAR(255) NOT NULL, age INT NOT NULL, PRIMARY KEY (id))'
cursor.execute(sql)
db.close()

运行之后，我们便创建了一个名为students的数据表。

当然，为了演示，这里只指定了最简单的几个字段。实际上，在爬虫过程中，我们会根据爬取结果设计特定的字段。

4. 插入数据

下一步就是向数据库中插入数据了。例如，这里爬取了一个学生信息，学号为20120001，名字为Bob，年龄为20，那么如何将该条数据插入数据库呢？示例代码如下：

import pymysql

id = '20120001'
user = 'Bob'
age = 20

db = pymysql.connect(host='localhost', user='root', password='123456', port=3306, db='spiders')
cursor = db.cursor()
sql = 'INSERT INTO students(id, name, age) values(%s, %s, %s)'
try:
    cursor.execute(sql, (id, user, age))
    db.commit()
except:
    db.rollback()
db.close()

这里首先构造了一个SQL语句，其Value值没有用字符串拼接的方式来构造，如：

1	sql = 'INSERT INTO students(id, name, age) values(' + id + ', ' + name + ', ' + age + ')'

这样的写法烦琐而且不直观，所以我们选择直接用格式化符%s来实现。有几个Value写几个%s，我们只需要在execute()方法的第一个参数传入该SQL语句，Value值用统一的元组传过来就好了。这样的写法既可以避免字符串拼接的麻烦，又可以避免引号冲突的问题。

之后值得注意的是，需要执行db对象的commit()方法才可实现数据插入，这个方法才是真正将语句提交到数据库执行的方法。对于数据插入、更新、删除操作，都需要调用该方法才能生效。

接下来，我们加了一层异常处理。如果执行失败，则调用rollback()执行数据回滚，相当于什么都没有发生过。

这里涉及事务的问题。事务机制可以确保数据的一致性，也就是这件事要么发生了，要么没有发生。比如插入一条数据，不会存在插入一半的情况，要么全部插入，要么都不插入，这就是事务的原子性。另外，事务还有3个属性——一致性、隔离性和持久性。这4个属性通常称为ACID特性，具体如表5-2所示。

表5-2 事务的4个属性

属性

解释

原子性（atomicity）

事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做

一致性（consistency）

事务必须使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的

隔离性（isolation）

一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰

持久性（durability）

持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响

插入、更新和删除操作都是对数据库进行更改的操作，而更改操作都必须为一个事务，所以这些操作的标准写法就是：

try:
    cursor.execute(sql)
    db.commit()
except:
    db.rollback()

这样便可以保证数据的一致性。这里的commit()和rollback()方法就为事务的实现提供了支持。

上面数据插入的操作是通过构造SQL语句实现的，但是很明显，这有一个极其不方便的地方，比如突然增加了性别字段gender，此时SQL语句就需要改成：

1	INSERT INTO students(id, name, age, gender) values(%s, %s, %s, %s)

相应的元组参数则需要改成：

1	(id, name, age, gender)

这显然不是我们想要的。在很多情况下，我们要达到的效果是插入方法无需改动，做成一个通用方法，只需要传入一个动态变化的字典就好了。比如，构造这样一个字典：

{
    'id': '20120001',
    'name': 'Bob',
    'age': 20
}

然后SQL语句会根据字典动态构造，元组也动态构造，这样才能实现通用的插入方法。所以，这里我们需要改写一下插入方法：

data = {
    'id': '20120001',
    'name': 'Bob',
    'age': 20
}
table = 'students'
keys = ', '.join(data.keys())
values = ', '.join(['%s'] * len(data))
sql = 'INSERT INTO {table}({keys}) VALUES ({values})'.format(table=table, keys=keys, values=values)
try:
   if cursor.execute(sql, tuple(data.values())):
       print('Successful')
       db.commit()
except:
    print('Failed')
    db.rollback()
db.close()

这里我们传入的数据是字典，并将其定义为data变量。表名也定义成变量table。接下来，就需要构造一个动态的SQL语句了。

首先，需要构造插入的字段id、name和age。这里只需要将data的键名拿过来，然后用逗号分隔即可。所以', '.join(data.keys())的结果就是id, name, age，然后需要构造多个%s当作占位符，有几个字段构造几个即可。比如，这里有三个字段，就需要构造%s, %s, %s。这里首先定义了长度为1的数组['%s']，然后用乘法将其扩充为['%s', '%s', '%s']，再调用join()方法，最终变成%s, %s, %s。最后，我们再利用字符串的format()方法将表名、字段名和占位符构造出来。最终的SQL语句就被动态构造成了：

1	INSERT INTO students(id, name, age) VALUES (%s, %s, %s)

最后，为execute()方法的第一个参数传入sql变量，第二个参数传入data的键值构造的元组，就可以成功插入数据了。

如此以来，我们便实现了传入一个字典来插入数据的方法，不需要再去修改SQL语句和插入操作了。

5. 更新数据

数据更新操作实际上也是执行SQL语句，最简单的方式就是构造一个SQL语句，然后执行：

sql = 'UPDATE students SET age = %s WHERE name = %s'
try:
   cursor.execute(sql, (25, 'Bob'))
   db.commit()
except:
   db.rollback()
db.close()

这里同样用占位符的方式构造SQL，然后执行execute()方法，传入元组形式的参数，同样执行commit()方法执行操作。如果要做简单的数据更新的话，完全可以使用此方法。

但是在实际的数据抓取过程中，大部分情况下需要插入数据，但是我们关心的是会不会出现重复数据，如果出现了，我们希望更新数据而不是重复保存一次。另外，就像前面所说的动态构造SQL的问题，所以这里可以再实现一种去重的方法，如果数据存在，则更新数据；如果数据不存在，则插入数据。另外，这种做法支持灵活的字典传值。示例如下：

data = {
    'id': '20120001',
    'name': 'Bob',
    'age': 21
}

table = 'students'
keys = ', '.join(data.keys())
values = ', '.join(['%s'] * len(data))

sql = 'INSERT INTO {table}({keys}) VALUES ({values}) ON DUPLICATE KEY UPDATE'.format(table=table, keys=keys, values=values)
update = ','.join([" {key} = %s".format(key=key) for key in data])
sql += update
try:
    if cursor.execute(sql, tuple(data.values())*2):
        print('Successful')
        db.commit()
except:
    print('Failed')
    db.rollback()
db.close()

这里构造的SQL语句其实是插入语句，但是我们在后面加了ON DUPLICATE KEY UPDATE。这行代码的意思是如果主键已经存在，就执行更新操作。比如，我们传入的数据id仍然为20120001，但是年龄有所变化，由20变成了21，此时这条数据不会被插入，而是直接更新id为20120001的数据。完整的SQL构造出来是这样的：

1	INSERT INTO students(id, name, age) VALUES (%s, %s, %s) ON DUPLICATE KEY UPDATE id = %s, name = %s, age = %s

这里就变成了6个%s。所以在后面的execute()方法的第二个参数元组就需要乘以2变成原来的2倍。

如此一来，我们就可以实现主键不存在便插入数据，存在则更新数据的功能了。

6. 删除数据

删除操作相对简单，直接使用DELETE语句即可，只是需要指定要删除的目标表名和删除条件，而且仍然需要使用db的commit()方法才能生效。示例如下：

table = 'students'
condition = 'age > 20'

sql = 'DELETE FROM  {table} WHERE {condition}'.format(table=table, condition=condition)
try:
    cursor.execute(sql)
    db.commit()
except:
    db.rollback()

db.close()

因为删除条件有多种多样，运算符有大于、小于、等于、LIKE等，条件连接符有AND、OR等，所以不再继续构造复杂的判断条件。这里直接将条件当作字符串来传递，以实现删除操作。

7. 查询数据

说完插入、修改和删除等操作，还剩下非常重要的一个操作，那就是查询。查询会用到SELECT语句，示例如下：

sql = 'SELECT * FROM students WHERE age >= 20'

try:
    cursor.execute(sql)
    print('Count:', cursor.rowcount)
    one = cursor.fetchone()
    print('One:', one)
    results = cursor.fetchall()
    print('Results:', results)
    print('Results Type:', type(results))
    for row in results:
        print(row)
except:
    print('Error')

运行结果如下：

Count: 4
One: ('20120001', 'Bob', 25)
Results: (('20120011', 'Mary', 21), ('20120012', 'Mike', 20), ('20120013', 'James', 22))
Results Type: <class 'tuple'>
('20120011', 'Mary', 21)
('20120012', 'Mike', 20)
('20120013', 'James', 22)

这里我们构造了一条SQL语句，将年龄20岁及以上的学生查询出来，然后将其传给execute()方法。注意，这里不再需要db的commit()方法。接着，调用cursor的rowcount属性获取查询结果的条数，当前示例中是4条。

然后我们调用了fetchone()方法，这个方法可以获取结果的第一条数据，返回结果是元组形式，元组的元素顺序跟字段一一对应，即第一个元素就是第一个字段id，第二个元素就是第二个字段name，以此类推。随后，我们又调用了fetchall()方法，它可以得到结果的所有数据。然后将其结果和类型打印出来，它是二重元组，每个元素都是一条记录，我们将其遍历输出出来。

但是这里需要注意一个问题，这里显示的是3条数据而不是4条，fetchall()方法不是获取所有数据吗？这是因为它的内部实现有一个偏移指针用来指向查询结果，最开始偏移指针指向第一条数据，取一次之后，指针偏移到下一条数据，这样再取的话，就会取到下一条数据了。我们最初调用了一次fetchone()方法，这样结果的偏移指针就指向下一条数据，fetchall()方法返回的是偏移指针指向的数据一直到结束的所有数据，所以该方法获取的结果就只剩3个了。

此外，我们还可以用while循环加fetchone()方法来获取所有数据，而不是用fetchall()全部一起获取出来。fetchall()会将结果以元组形式全部返回，如果数据量很大，那么占用的开销会非常高。因此，推荐使用如下方法来逐条取数据：

sql = 'SELECT * FROM students WHERE age >= 20'
try:
    cursor.execute(sql)
    print('Count:', cursor.rowcount)
    row = cursor.fetchone()
    while row:
        print('Row:', row)
        row = cursor.fetchone()
except:
    print('Error')

这样每循环一次，指针就会偏移一条数据，随用随取，简单高效。

本节中，我们介绍了如何使用PyMySQL操作MySQL数据库以及一些SQL语句的构造方法，后面会在实战案例中应用这些操作来存储数据。

作者崔庆才发表于 2018-01-29 阅读次数：本文字数： 7.3k 阅读时长 ≈ 7 分钟

Python [Python3网络爬虫开发实战] 5.2-关系型数据库存储

关系型数据库是基于关系模型的数据库，而关系模型是通过二维表来保存的，所以它的存储方式就是行列组成的表，每一列是一个字段，每一行是一条记录。表可以看作某个实体的集合，而实体之间存在联系，这就需要表与表之间的关联关系来体现，如主键外键的关联关系。多个表组成一个数据库，也就是关系型数据库。

关系型数据库有多种，如SQLite、MySQL、Oracle、SQL Server、DB2等。

本节中，我们主要介绍Python 3下MySQL的存储。

作者崔庆才发表于 2018-01-29 阅读次数：本文字数： 215 阅读时长 ≈ 1 分钟

Python [Python3网络爬虫开发实战] 5.1.3-CSV文件存储

CSV，全称为 Comma-Separated Values，中文可以叫作逗号分隔值或字符分隔值，其文件以纯文本形式存储表格数据。该文件是一个字符序列，可以由任意数目的记录组成，记录间以某种换行符分隔。每条记录由字段组成，字段间的分隔符是其他字符或字符串，最常见的是逗号或制表符。不过所有记录都有完全相同的字段序列，相当于一个结构化表的纯文本形式。它比 Excel 文件更加简介，XLS 文本是电子表格，它包含了文本、数值、公式和格式等内容，而 CSV 中不包含这些内容，就是特定字符分隔的纯文本，结构简单清晰。所以，有时候用 CSV 来保存数据是比较方便的。本节中，我们来讲解 Python 读取和写入 CSV 文件的过程。

1. 写入

这里先看一个最简单的例子：

import csv

with open('data.csv', 'w') as csvfile:
    writer = csv.writer(csvfile)
    writer.writerow(['id', 'name', 'age'])
    writer.writerow(['10001', 'Mike', 20])
    writer.writerow(['10002', 'Bob', 22])
    writer.writerow(['10003', 'Jordan', 21])

首先，打开 data.csv 文件，然后指定打开的模式为w（即写入），获得文件句柄，随后调用 csv 库的writer()方法初始化写入对象，传入该句柄，然后调用writerow()方法传入每行的数据即可完成写入。

运行结束后，会生成一个名为 data.csv 的文件，此时数据就成功写入了。直接以文本形式打开的话，其内容如下：

id,name,age
10001,Mike,20
10002,Bob,22
10003,Jordan,21

可以看到，写入的文本默认以逗号分隔，调用一次writerow()方法即可写入一行数据。用 Excel 打开的结果如图 5-6 所示。

图 5-6 打开结果

如果想修改列与列之间的分隔符，可以传入delimiter参数，其代码如下：

import csv

with open('data.csv', 'w') as csvfile:
    writer = csv.writer(csvfile, delimiter=' ')
    writer.writerow(['id', 'name', 'age'])
    writer.writerow(['10001', 'Mike', 20])
    writer.writerow(['10002', 'Bob', 22])
    writer.writerow(['10003', 'Jordan', 21])

这里在初始化写入对象时传入delimiter为空格，此时输出结果的每一列就是以空格分隔了，内容如下：

id name age
10001 Mike 20
10002 Bob 22
10003 Jordan 21

另外，我们也可以调用writerows()方法同时写入多行，此时参数就需要为二维列表，例如：

import csv

with open('data.csv', 'w') as csvfile:
    writer = csv.writer(csvfile)
    writer.writerow(['id', 'name', 'age'])
    writer.writerows([['10001', 'Mike', 20], ['10002', 'Bob', 22], ['10003', 'Jordan', 21]])

输出效果是相同的，内容如下：

id,name,age
10001,Mike,20
10002,Bob,22
10003,Jordan,21

但是一般情况下，爬虫爬取的都是结构化数据，我们一般会用字典来表示。在 csv 库中也提供了字典的写入方式，示例如下：

import csv

with open('data.csv', 'w') as csvfile:
    fieldnames = ['id', 'name', 'age']
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writeheader()
    writer.writerow({'id': '10001', 'name': 'Mike', 'age': 20})
    writer.writerow({'id': '10002', 'name': 'Bob', 'age': 22})
    writer.writerow({'id': '10003', 'name': 'Jordan', 'age': 21})

这里先定义 3 个字段，用fieldnames表示，然后将其传给DictWriter来初始化一个字典写入对象，接着可以调用writeheader()方法先写入头信息，然后再调用writerow()方法传入相应字典即可。最终写入的结果是完全相同的，内容如下：

id,name,age
10001,Mike,20
10002,Bob,22
10003,Jordan,21

这样就可以完成字典到 CSV 文件的写入了。

另外，如果想追加写入的话，可以修改文件的打开模式，即将open()函数的第二个参数改成a，代码如下：

import csv

with open('data.csv', 'a') as csvfile:
    fieldnames = ['id', 'name', 'age']
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writerow({'id': '10004', 'name': 'Durant', 'age': 22})

这样在上面的基础上再执行这段代码，文件内容便会变成：

id,name,age
10001,Mike,20
10002,Bob,22
10003,Jordan,21
10004,Durant,22

可见，数据被追加写入到文件中。

如果要写入中文内容的话，可能会遇到字符编码的问题，此时需要给open()参数指定编码格式。比如，这里再写入一行包含中文的数据，代码需要改写如下：

import csv

with open('data.csv', 'a', encoding='utf-8') as csvfile:
    fieldnames = ['id', 'name', 'age']
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writerow({'id': '10005', 'name': '王伟', 'age': 22})

这里需要给open()函数指定编码，否则可能发生编码错误。

另外，如果接触过 pandas 等库的话，可以调用DataFrame对象的to_csv()方法来将数据写入 CSV 文件中。

2. 读取

我们同样可以使用 csv 库来读取 CSV 文件。例如，将刚才写入的文件内容读取出来，相关代码如下：

import csv

with open('data.csv', 'r', encoding='utf-8') as csvfile:
    reader = csv.reader(csvfile)
    for row in reader:
        print(row)

运行结果如下：

['id', 'name', 'age']
['10001', 'Mike', '20']
['10002', 'Bob', '22']
['10003', 'Jordan', '21']
['10004', 'Durant', '22']
['10005', '王伟', '22']

这里我们构造的是Reader对象，通过遍历输出了每行的内容，每一行都是一个列表形式。注意，如果 CSV 文件中包含中文的话，还需要指定文件编码。

另外，如果接触过 pandas 的话，可以利用read_csv()方法将数据从 CSV 中读取出来，例如：

import pandas  as pd

df = pd.read_csv('data.csv')
print(df)

运行结果如下：

      id    name  age
0  10001    Mike   20
1  10002     Bob   22
2  10003  Jordan   21
3  10004  Durant   22
4  10005      王伟   22

在做数据分析的时候，此种方法用得比较多，也是一种比较方便地读取 CSV 文件的方法。

本节中，我们了解了 CSV 文件的写入和读取方式。这也是一种常用的数据存储方式，需要熟练掌握。

作者崔庆才发表于 2018-01-29 阅读次数：本文字数： 3.5k 阅读时长 ≈ 3 分钟

Python [Python3网络爬虫开发实战] 5.1.2-JSON文件存储

JSON，全称为 JavaScript Object Notation, 也就是 JavaScript 对象标记，它通过对象和数组的组合来表示数据，构造简洁但是结构化程度非常高，是一种轻量级的数据交换格式。本节中，我们就来了解如何利用 Python 保存数据到 JSON 文件。

1. 对象和数组

在 JavaScript 语言中，一切都是对象。因此，任何支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等，但是对象和数组是比较特殊且常用的两种类型，下面简要介绍一下它们。

对象：它在 JavaScript 中是使用花括号{}包裹起来的内容，数据结构为{key1：value1, key2：value2, ...}的键值对结构。在面向对象的语言中，key为对象的属性，value为对应的值。键名可以使用整数和字符串来表示。值的类型可以是任意类型。
数组：数组在 JavaScript 中是方括号[]包裹起来的内容，数据结构为["java", "javascript", "vb", ...]的索引结构。在 JavaScript 中，数组是一种比较特殊的数据类型，它也可以像对象那样使用键值对，但还是索引用得多。同样，值的类型可以是任意类型。

所以，一个 JSON 对象可以写为如下形式：

[{
    "name": "Bob",
    "gender": "male",
    "birthday": "1992-10-18"
}, {
     "name": "Selina",
    "gender": "female",
    "birthday": "1995-10-18"
}]

由中括号包围的就相当于列表类型，列表中的每个元素可以是任意类型，这个示例中它是字典类型，由大括号包围。

JSON 可以由以上两种形式自由组合而成，可以无限次嵌套，结构清晰，是数据交换的极佳方式。

2. 读取 JSON

Python 为我们提供了简单易用的库来实现 JSON 文件的读写操作，我们可以调用库的loads()方法将 JSON 文本字符串转为 JSON 对象，可以通过dumps()方法将 JSON 对象转为文本字符串。

例如，这里有一段 JSON 形式的字符串，它是str类型，我们用 Python 将其转换为可操作的数据结构，如列表或字典：

import json

str = '''
[{
    "name": "Bob",
    "gender": "male",
    "birthday": "1992-10-18"
}, {
    "name": "Selina",
    "gender": "female",
    "birthday": "1995-10-18"
}]
'''
print(type(str))
data = json.loads(str)
print(data)
print(type(data))

运行结果如下：

1
2
3

<class 'str'>
[{'name': 'Bob', 'gender': 'male', 'birthday': '1992-10-18'}, {'name': 'Selina', 'gender': 'female', 'birthday': '1995-10-18'}]
<class 'list'>

这里使用loads()方法将字符串转为 JSON 对象。由于最外层是中括号，所以最终的类型是列表类型。

这样一来，我们就可以用索引来获取对应的内容了。例如，如果想取第一个元素里的name属性，就可以使用如下方式：

1 2	data[0]['name'] data[0].get('name')

得到的结果都是：

Bob

通过中括号加 0 索引，可以得到第一个字典元素，然后再调用其键名即可得到相应的键值。获取键值时有两种方式，一种是中括号加键名，另一种是通过get()方法传入键名。这里推荐使用get()方法，这样如果键名不存在，则不会报错，会返回None。另外，get()方法还可以传入第二个参数（即默认值），示例如下：

1 2	data[0].get('age') data[0].get('age', 25)

运行结果如下：

1
2

None
25

这里我们尝试获取年龄age，其实在原字典中该键名不存在，此时默认会返回None。如果传入第二个参数（即默认值），那么在不存在的情况下返回该默认值。

值得注意的是，JSON 的数据需要用双引号来包围，不能使用单引号。例如，若使用如下形式表示，则会出现错误：

import json

str = '''
[{
    'name': 'Bob',
    'gender': 'male',
    'birthday': '1992-10-18'
}]
'''
data = json.loads(str)

运行结果如下：

1	json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes: line 3 column 5 (char 8)

这里会出现 JSON 解析错误的提示。这是因为这里数据用单引号来包围，请千万注意 JSON 字符串的表示需要用双引号，否则loads()方法会解析失败。

如果从 JSON 文本中读取内容，例如这里有一个 data.文本文件，其内容是刚才定义的 JSON 字符串，我们可以先将文本文件内容读出，然后再利用loads()方法转化：

import json

with open('data.json', 'r') as file:
    str = file.read()
    data = json.loads(str)
    print(data)

运行结果如下：

1	[{'name': 'Bob', 'gender': 'male', 'birthday': '1992-10-18'}, {'name': 'Selina', 'gender': 'female', 'birthday': '1995-10-18'}]

3. 输出 JSON

另外，我们还可以调用dumps()方法将 JSON 对象转化为字符串。例如，将上例中的列表重新写入文本：

import json

data = [{
    'name': 'Bob',
    'gender': 'male',
    'birthday': '1992-10-18'
}]
with open('data.json', 'w') as file:
    file.write(json.dumps(data))

利用dumps()方法，我们可以将 JSON 对象转为字符串，然后再调用文件的write()方法写入文本，结果如图 5-2 所示。

图 5-2 写入结果

另外，如果想保存 JSON 的格式，可以再加一个参数indent，代表缩进字符个数。示例如下：

1 2	with open('data.json', 'w') as file: file.write(json.dumps(data, indent=2))

此时写入结果如图 5-3 所示。

图 5-3 写入结果

这样得到的内容会自动带缩进，格式会更加清晰。

另外，如果 JSON 中包含中文字符，会怎么样呢？例如，我们将之前的 JSON 的部分值改为中文，再用之前的方法写入到文本：

import json

data = [{
    'name': '王伟',
    'gender': '男',
    'birthday': '1992-10-18'
}]
with open('data.json', 'w') as file:
    file.write(json.dumps(data, indent=2))

写入结果如图 5-4 所示。

图 5-4 写入结果

可以看到，中文字符都变成了 Unicode 字符，这并不是我们想要的结果。

为了输出中文，还需要指定参数ensure_ascii为False，另外还要规定文件输出的编码：

1 2	with open('data.json', 'w', encoding='utf-8') as file: file.write(json.dumps(data, indent=2, ensure_ascii=False))

写入结果如图 5-5 所示。

图 5-5 写入结果

可以发现，这样就可以输出 JSON 为中文了。

本节中，我们了解了用 Python 进行 JSON 文件读写的方法，后面做数据解析时经常会用到，建议熟练掌握。

作者崔庆才发表于 2018-01-29 阅读次数：本文字数： 3.4k 阅读时长 ≈ 3 分钟

Python [Python3网络爬虫开发实战] 5.1.1-TXT文本存储

将数据保存到 TXT 文本的操作非常简单，而且 TXT 文本几乎兼容任何平台，但是这有个缺点，那就是不利于检索。所以如果对检索和数据结构要求不高，追求方便第一的话，可以采用 TXT 文本存储。本节中，我们就来看下如何利用 Python 保存 TXT 文本文件。

1. 本节目标

本节中，我们要保存知乎上“发现”页面的“热门话题”部分，将其问题和答案统一保存成文本形式。

2. 基本实例

首先，可以用 requests 将网页源代码获取下来，然后使用 pyquery 解析库解析，接下来将提取的标题、回答者、回答保存到文本，代码如下：

import requests
from pyquery import PyQuery as pq

url = 'https://www.zhihu.com/explore'
headers = {
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36'
}
html = requests.get(url, headers=headers).text
doc = pq(html)
items = doc('.explore-tab .feed-item').items()
for item in items:
    question = item.find('h2').text()
    author = item.find('.author-link-line').text()
    answer = pq(item.find('.content').html()).text()
    file = open('explore.txt', 'a', encoding='utf-8')
    file.write('\n'.join([question, author, answer]))
    file.write('\n' + '=' * 50 + '\n')
    file.close()

这里主要是为了演示文件保存的方式，因此 requests 异常处理部分在此省去。首先，用 requests 提取知乎的“发现”页面，然后将热门话题的问题、回答者、答案全文提取出来，然后利用 Python 提供的open()方法打开一个文本文件，获取一个文件操作对象，这里赋值为file，接着利用file对象的write()方法将提取的内容写入文件，最后调用close()方法将其关闭，这样抓取的内容即可成功写入文本中了。

运行程序，可以发现在本地生成了一个 explore.txt 文件，其内容如图 5-1 所示。

图 5-1 文件内容

这样热门问答的内容就被保存成文本形式了。

这里open()方法的第一个参数即要保存的目标文件名称，第二个参数为a，代表以追加方式写入到文本。另外，我们还指定了文件的编码为utf-8。最后，写入完成后，还需要调用close()方法来关闭文件对象。

3. 打开方式

在刚才的实例中，open()方法的第二个参数设置成了a，这样在每次写入文本时不会清空源文件，而是在文件末尾写入新的内容，这是一种文件打开方式。关于文件的打开方式，其实还有其他几种，这里简要介绍一下。

r：以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb：以二进制只读方式打开一个文件。文件指针将会放在文件的开头。
r+：以读写方式打开一个文件。文件指针将会放在文件的开头。
rb+：以二进制读写方式打开一个文件。文件指针将会放在文件的开头。
w：以写入方式打开一个文件。如果该文件已存在，则将其覆盖。如果该文件不存在，则创建新文件。
wb：以二进制写入方式打开一个文件。如果该文件已存在，则将其覆盖。如果该文件不存在，则创建新文件。
w+：以读写方式打开一个文件。如果该文件已存在，则将其覆盖。如果该文件不存在，则创建新文件。
wb+：以二进制读写格式打开一个文件。如果该文件已存在，则将其覆盖。如果该文件不存在，则创建新文件。
a：以追加方式打开一个文件。如果该文件已存在，文件指针将会放在文件结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，则创建新文件来写入。
ab：以二进制追加方式打开一个文件。如果该文件已存在，则文件指针将会放在文件结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，则创建新文件来写入。
a+：以读写方式打开一个文件。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，则创建新文件来读写。
ab+：以二进制追加方式打开一个文件。如果该文件已存在，则文件指针将会放在文件结尾。如果该文件不存在，则创建新文件用于读写。

4. 简化写法

另外，文件写入还有一种简写方法，那就是使用with as语法。在with控制块结束时，文件会自动关闭，所以就不需要再调用close()方法了。这种保存方式可以简写如下：

1
2
3

with open('explore.txt', 'a', encoding='utf-8') as file:
    file.write('\n'.join([question, author, answer]))
    file.write('\n' + '=' * 50 + '\n')

如果想保存时将原文清空，那么可以将第二个参数改写为w，代码如下：

1
2
3

with open('explore.txt', 'w', encoding='utf-8') as file:
    file.write('\n'.join([question, author, answer]))
    file.write('\n' + '=' * 50 + '\n')

上面便是利用 Python 将结果保存为 TXT 文件的方法，这种方法简单易用，操作高效，是一种最基本的保存数据的方法。

作者崔庆才发表于 2018-01-29 阅读次数：本文字数： 2.4k 阅读时长 ≈ 2 分钟

Python [Python3网络爬虫开发实战] 5.1-文件存储

文件存储形式多种多样，比如可以保存成TXT纯文本形式，也可以保存为JSON格式、CSV格式等，本节就来了解一下文本文件的存储方式。

作者崔庆才发表于 2018-01-29 阅读次数：本文字数： 65 阅读时长 ≈ 1 分钟

Python [Python3网络爬虫开发实战] 5-数据存储

用解析器解析出数据之后，接下来就是存储数据了。保存的形式可以多种多样，最简单的形式是直接保存为文本文件，如TXT、JSON、CSV等。另外，还可以保存到数据库中，如关系型数据库MySQL，非关系型数据库MongoDB、Redis等。

作者崔庆才发表于 2018-01-29 阅读次数：本文字数： 116 阅读时长 ≈ 1 分钟

Python [Python3网络爬虫开发实战] 4.3-使用pyquery

在上一节中，我们介绍了Beautiful Soup的用法，它是一个非常强大的网页解析库，你是否觉得它的一些方法用起来有点不适应？有没有觉得它的CSS选择器的功能没有那么强大？

如果你对Web有所涉及，如果你比较喜欢用CSS选择器，如果你对jQuery有所了解，那么这里有一个更适合你的解析库——pyquery。

接下来，我们就来感受一下pyquery的强大之处。

1. 准备工作

在开始之前，请确保已经正确安装好了pyquery。若没有安装，可以参考第1章的安装过程。

2. 初始化

像Beautiful Soup一样，初始化pyquery的时候，也需要传入HTML文本来初始化一个PyQuery对象。它的初始化方式有多种，比如直接传入字符串，传入URL，传入文件名，等等。下面我们来详细介绍一下。

字符串初始化

首先，我们用一个实例来感受一下：

html = '''
<div>
    <ul>
         <li class="item-0">first item</li>
         <li class="item-1"><a href="link2.html">second item</a></li>
         <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
         <li class="item-1 active"><a href="link4.html">fourth item</a></li>
         <li class="item-0"><a href="link5.html">fifth item</a></li>
     </ul>
 </div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
print(doc('li'))

运行结果如下：

<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>

这里首先引入PyQuery这个对象，取别名为pq。然后声明了一个长HTML字符串，并将其当作参数传递给PyQuery类，这样就成功完成了初始化。接下来，将初始化的对象传入CSS选择器。在这个实例中，我们传入li节点，这样就可以选择所有的li节点。

URL初始化

初始化的参数不仅可以以字符串的形式传递，还可以传入网页的URL，此时只需要指定参数为url即可：

1
2
3

from pyquery import PyQuery as pq
doc = pq(url='http://cuiqingcai.com')
print(doc('title'))

运行结果如下：

1	<title>静觅丨崔庆才的个人博客</title>

这样的话，PyQuery对象会首先请求这个URL，然后用得到的HTML内容完成初始化，这其实就相当于用网页的源代码以字符串的形式传递给PyQuery类来初始化。

它与下面的功能是相同的：

from pyquery import PyQuery as pq
import requests
doc = pq(requests.get('http://cuiqingcai.com').text)
print(doc('title'))

文件初始化

当然，除了传递URL，还可以传递本地的文件名，此时将参数指定为filename即可：

1
2
3

from pyquery import PyQuery as pq
doc = pq(filename='demo.html')
print(doc('li'))

当然，这里需要有一个本地HTML文件demo.html，其内容是待解析的HTML字符串。这样它会首先读取本地的文件内容，然后用文件内容以字符串的形式传递给PyQuery类来初始化。

以上3种初始化方式均可，当然最常用的初始化方式还是以字符串形式传递。

3. 基本CSS选择器

首先，用一个实例来感受pyquery的CSS选择器的用法：

html = '''
<div id="container">
    <ul class="list">
         <li class="item-0">first item</li>
         <li class="item-1"><a href="link2.html">second item</a></li>
         <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
         <li class="item-1 active"><a href="link4.html">fourth item</a></li>
         <li class="item-0"><a href="link5.html">fifth item</a></li>
     </ul>
 </div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
print(doc('#container .list li'))
print(type(doc('#container .list li')))

运行结果如下：

<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
<class 'pyquery.pyquery.PyQuery'>

这里我们初始化PyQuery对象之后，传入了一个CSS选择器#container .list li，它的意思是先选取id为container的节点，然后再选取其内部的class为list的节点内部的所有li节点。然后，打印输出。可以看到，我们成功获取到了符合条件的节点。

最后，将它的类型打印输出。可以看到，它的类型依然是PyQuery类型。

4. 查找节点

下面我们介绍一些常用的查询函数，这些函数和jQuery中函数的用法完全相同。

子节点

查找子节点时，需要用到find()方法，此时传入的参数是CSS选择器。这里还是以前面的HTML为例：

from pyquery import PyQuery as pq
doc = pq(html)
items = doc('.list')
print(type(items))
print(items)
lis = items.find('li')
print(type(lis))
print(lis)

运行结果如下：

<class 'pyquery.pyquery.PyQuery'>
<ul class="list">
    <li class="item-0">first item</li>
    <li class="item-1"><a href="link2.html">second item</a></li>
    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    <li class="item-1 active"><a href="link4.html">fourth item</a></li>
    <li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
<class 'pyquery.pyquery.PyQuery'>
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>

首先，我们选取class为list的节点，然后调用了find()方法，传入CSS选择器，选取其内部的li节点，最后打印输出。可以发现，find()方法会将符合条件的所有节点选择出来，结果的类型是PyQuery类型。

其实find()的查找范围是节点的所有子孙节点，而如果我们只想查找子节点，那么可以用children()方法：

1
2
3

lis = items.children()
print(type(lis))
print(lis)

运行结果如下：

<class 'pyquery.pyquery.PyQuery'>
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>

如果要筛选所有子节点中符合条件的节点，比如想筛选出子节点中class为active的节点，可以向children()方法传入CSS选择器.active：

1 2	lis = items.children('.active') print(lis)

运行结果如下：

1 2	<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li> <li class="item-1 active"><a href="link4.html">fourth item</a></li>

可以看到，输出结果已经做了筛选，留下了class为active的节点。

父节点

我们可以用parent()方法来获取某个节点的父节点，示例如下：

html = '''
<div class="wrap">
    <div id="container">
        <ul class="list">
             <li class="item-0">first item</li>
             <li class="item-1"><a href="link2.html">second item</a></li>
             <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
             <li class="item-1 active"><a href="link4.html">fourth item</a></li>
             <li class="item-0"><a href="link5.html">fifth item</a></li>
         </ul>
     </div>
 </div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
items = doc('.list')
container = items.parent()
print(type(container))
print(container)

运行结果如下：

<class 'pyquery.pyquery.PyQuery'>
<div id="container">
    <ul class="list">
         <li class="item-0">first item</li>
         <li class="item-1"><a href="link2.html">second item</a></li>
         <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
         <li class="item-1 active"><a href="link4.html">fourth item</a></li>
         <li class="item-0"><a href="link5.html">fifth item</a></li>
     </ul>
 </div>

这里我们首先用.list选取class为list的节点，然后调用parent()方法得到其父节点，其类型依然是PyQuery类型。

这里的父节点是该节点的直接父节点，也就是说，它不会再去查找父节点的父节点，即祖先节点。

但是如果想获取某个祖先节点，该怎么办呢？这时可以用parents()方法：

from pyquery import PyQuery as pq
doc = pq(html)
items = doc('.list')
parents = items.parents()
print(type(parents))
print(parents)

运行结果如下：

<class 'pyquery.pyquery.PyQuery'>
<div class="wrap">
    <div id="container">
        <ul class="list">
             <li class="item-0">first item</li>
             <li class="item-1"><a href="link2.html">second item</a></li>
             <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
             <li class="item-1 active"><a href="link4.html">fourth item</a></li>
             <li class="item-0"><a href="link5.html">fifth item</a></li>
         </ul>
     </div>
 </div>
 <div id="container">
        <ul class="list">
             <li class="item-0">first item</li>
             <li class="item-1"><a href="link2.html">second item</a></li>
             <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
             <li class="item-1 active"><a href="link4.html">fourth item</a></li>
             <li class="item-0"><a href="link5.html">fifth item</a></li>
         </ul>
     </div>

可以看到，输出结果有两个：一个是class为wrap的节点，一个是id为container的节点。也就是说，parents()方法会返回所有的祖先节点。

如果想要筛选某个祖先节点的话，可以向parents()方法传入CSS选择器，这样就会返回祖先节点中符合CSS选择器的节点：

1 2	parent = items.parents('.wrap') print(parent)

运行结果如下：

<div class="wrap">
    <div id="container">
        <ul class="list">
             <li class="item-0">first item</li>
             <li class="item-1"><a href="link2.html">second item</a></li>
             <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
             <li class="item-1 active"><a href="link4.html">fourth item</a></li>
             <li class="item-0"><a href="link5.html">fifth item</a></li>
         </ul>
     </div>
 </div>

可以看到，输出结果少了一个节点，只保留了class为wrap的节点。

兄弟节点

前面我们说明了子节点和父节点的用法，还有一种节点，那就是兄弟节点。如果要获取兄弟节点，可以使用siblings()方法。这里还是以上面的HTML代码为例：

from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.list .item-0.active')
print(li.siblings())

这里首先选择class为list的节点内部class为item-0和active的节点，也就是第三个li节点。那么，很明显，它的兄弟节点有4个，那就是第一、二、四、五个li节点。

运行结果如下：

<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0">first item</li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>

可以看到，这正是我们刚才所说的4个兄弟节点。

如果要筛选某个兄弟节点，我们依然可以向siblings方法传入CSS选择器，这样就会从所有兄弟节点中挑选出符合条件的节点了：

from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.list .item-0.active')
print(li.siblings('.active'))

这里我们筛选了class为active的节点，通过刚才的结果可以观察到，class为active的兄弟节点只有第四个li节点，所以结果应该是一个。

我们再看一下运行结果：

1	<li class="item-1 active"><a href="link4.html">fourth item</a></li>

5. 遍历

刚才可以观察到，pyquery的选择结果可能是多个节点，也可能是单个节点，类型都是PyQuery类型，并没有返回像Beautiful Soup那样的列表。

对于单个节点来说，可以直接打印输出，也可以直接转成字符串：

from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.item-0.active')
print(li)
print(str(li))

运行结果如下：

1 2	<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li> <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>

对于多个节点的结果，我们就需要遍历来获取了。例如，这里把每一个li节点进行遍历，需要调用items()方法：

from pyquery import PyQuery as pq
doc = pq(html)
lis = doc('li').items()
print(type(lis))
for li in lis:
    print(li, type(li))

运行结果如下：

<class 'generator'>
<li class="item-0">first item</li>
<class 'pyquery.pyquery.PyQuery'>
<li class="item-1"><a href="link2.html">second item</a></li>
<class 'pyquery.pyquery.PyQuery'>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<class 'pyquery.pyquery.PyQuery'>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<class 'pyquery.pyquery.PyQuery'>
<li class="item-0"><a href="link5.html">fifth item</a></li>
<class 'pyquery.pyquery.PyQuery'>

可以发现，调用items()方法后，会得到一个生成器，遍历一下，就可以逐个得到li节点对象了，它的类型也是PyQuery类型。每个li节点还可以调用前面所说的方法进行选择，比如继续查询子节点，寻找某个祖先节点等，非常灵活。

6. 获取信息

提取到节点之后，我们的最终目的当然是提取节点所包含的信息了。比较重要的信息有两类，一是获取属性，二是获取文本，下面分别进行说明。

获取属性

提取到某个PyQuery类型的节点后，就可以调用attr()方法来获取属性：

html = '''
<div class="wrap">
    <div id="container">
        <ul class="list">
             <li class="item-0">first item</li>
             <li class="item-1"><a href="link2.html">second item</a></li>
             <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
             <li class="item-1 active"><a href="link4.html">fourth item</a></li>
             <li class="item-0"><a href="link5.html">fifth item</a></li>
         </ul>
     </div>
 </div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
a = doc('.item-0.active a')
print(a, type(a))
print(a.attr('href'))

运行结果如下：

1 2	<a href="link3.html"><span class="bold">third item</span></a> <class 'pyquery.pyquery.PyQuery'> link3.html

这里首先选中class为item-0和active的li节点内的a节点，它的类型是PyQuery类型。

然后调用attr()方法。在这个方法中传入属性的名称，就可以得到这个属性值了。

此外，也可以通过调用attr属性来获取属性，用法如下：

1	print(a.attr.href)

结果如下：

1	link3.html

这两种方法的结果完全一样。

如果选中的是多个元素，然后调用attr()方法，会出现怎样的结果呢？我们用实例来测试一下：

a = doc('a')
print(a, type(a))
print(a.attr('href'))
print(a.attr.href)

运行结果如下：

1
2
3

<a href="link2.html">second item</a><a href="link3.html"><span class="bold">third item</span></a><a href="link4.html">fourth item</a><a href="link5.html">fifth item</a> <class 'pyquery.pyquery.PyQuery'>
link2.html
link2.html

照理来说，我们选中的a节点应该有4个，而且打印结果也应该是4个，但是当我们调用attr()方法时，返回结果却只是第一个。这是因为，当返回结果包含多个节点时，调用attr()方法，只会得到第一个节点的属性。

那么，遇到这种情况时，如果想获取所有的a节点的属性，就要用到前面所说的遍历了：

from pyquery import PyQuery as pq
doc = pq(html)
a = doc('a')
for item in a.items():
    print(item.attr('href'))

此时的运行结果如下：

link2.html
link3.html
link4.html
link5.html

因此，在进行属性获取时，可以观察返回节点是一个还是多个，如果是多个，则需要遍历才能依次获取每个节点的属性。

获取文本

获取节点之后的另一个主要操作就是获取其内部的文本了，此时可以调用text()方法来实现：

html = '''
<div class="wrap">
    <div id="container">
        <ul class="list">
             <li class="item-0">first item</li>
             <li class="item-1"><a href="link2.html">second item</a></li>
             <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
             <li class="item-1 active"><a href="link4.html">fourth item</a></li>
             <li class="item-0"><a href="link5.html">fifth item</a></li>
         </ul>
     </div>
 </div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
a = doc('.item-0.active a')
print(a)
print(a.text())

运行结果如下：

1 2	<a href="link3.html"><span class="bold">third item</span></a> third item

这里首先选中一个a节点，然后调用text()方法，就可以获取其内部的文本信息。此时它会忽略掉节点内部包含的所有HTML，只返回纯文字内容。

但如果想要获取这个节点内部的HTML文本，就要用html()方法了：

from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.item-0.active')
print(li)
print(li.html())

这里我们选中了第三个li节点，然后调用了html()方法，它返回的结果应该是li节点内的所有HTML文本。

运行结果如下：

1	<a href="link3.html"><span class="bold">third item</span></a>

这里同样有一个问题，如果我们选中的结果是多个节点，text()或html()会返回什么内容？我们用实例来看一下：

html = '''
<div class="wrap">
    <div id="container">
        <ul class="list">
             <li class="item-1"><a href="link2.html">second item</a></li>
             <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
             <li class="item-1 active"><a href="link4.html">fourth item</a></li>
             <li class="item-0"><a href="link5.html">fifth item</a></li>
         </ul>
     </div>
 </div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('li')
print(li.html())
print(li.text())
print(type(li.text())

运行结果如下：

1
2
3

<a href="link2.html">second item</a>
second item third item fourth item fifth item
<class 'str'>

结果可能比较出乎意料，html()方法返回的是第一个li节点的内部HTML文本，而text()则返回了所有的li节点内部的纯文本，中间用一个空格分割开，即返回结果是一个字符串。

所以这个地方值得注意，如果得到的结果是多个节点，并且想要获取每个节点的内部HTML文本，则需要遍历每个节点。而text()方法不需要遍历就可以获取，它将所有节点取文本之后合并成一个字符串。

7. 节点操作

pyquery提供了一系列方法来对节点进行动态修改，比如为某个节点添加一个class，移除某个节点等，这些操作有时候会为提取信息带来极大的便利。

由于节点操作的方法太多，下面举几个典型的例子来说明它的用法。

`addClass`和`removeClass`

我们先用实例来感受一下：

html = '''
<div class="wrap">
    <div id="container">
        <ul class="list">
             <li class="item-0">first item</li>
             <li class="item-1"><a href="link2.html">second item</a></li>
             <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
             <li class="item-1 active"><a href="link4.html">fourth item</a></li>
             <li class="item-0"><a href="link5.html">fifth item</a></li>
         </ul>
     </div>
 </div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.item-0.active')
print(li)
li.removeClass('active')
print(li)
li.addClass('active')
print(li)

首先选中了第三个li节点，然后调用removeClass()方法，将li节点的active这个class移除，后来又调用addClass()方法，将class添加回来。每执行一次操作，就打印输出当前li节点的内容。

运行结果如下：

1
2
3

<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-0"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>

可以看到，一共输出了3次。第二次输出时，li节点的active这个class被移除了，第三次class又添加回来了。

所以说，addClass()和removeClass()这些方法可以动态改变节点的class属性。

`attr`、`text`和`html`

当然，除了操作class这个属性外，也可以用attr()方法对属性进行操作。此外，还可以用text()和html()方法来改变节点内部的内容。示例如下：

html = '''
<ul class="list">
     <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
</ul>
'''
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.item-0.active')
print(li)
li.attr('name', 'link')
print(li)
li.text('changed item')
print(li)
li.html('<span>changed item</span>')
print(li)

这里我们首先选中li节点，然后调用attr()方法来修改属性，其中该方法的第一个参数为属性名，第二个参数为属性值。接着，调用text()和html()方法来改变节点内部的内容。三次操作后，分别打印输出当前的li节点。

运行结果如下：

<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-0 active" name="link"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-0 active" name="link">changed item</li>
<li class="item-0 active" name="link"><span>changed item</span></li>

可以发现，调用attr()方法后，li节点多了一个原本不存在的属性name，其值为link。接着调用text()方法，传入文本之后，li节点内部的文本全被改为传入的字符串文本了。最后，调用html()方法传入HTML文本后，li节点内部又变为传入的HTML文本了。

所以说，如果attr()方法只传入第一个参数的属性名，则是获取这个属性值；如果传入第二个参数，可以用来修改属性值。text()和html()方法如果不传参数，则是获取节点内纯文本和HTML文本；如果传入参数，则进行赋值。

`remove()`

顾名思义，remove()方法就是移除，它有时会为信息的提取带来非常大的便利。下面有一段HTML文本：

html = '''
<div class="wrap">
    Hello, World
    <p>This is a paragraph.</p>
 </div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
wrap = doc('.wrap')
print(wrap.text())

现在想提取Hello, World这个字符串，而不要p节点内部的字符串，需要怎样操作呢？

这里直接先尝试提取class为wrap的节点的内容，看看是不是我们想要的。运行结果如下：

1	Hello, World This is a paragraph.

这个结果还包含了内部的p节点的内容，也就是说text()把所有的纯文本全提取出来了。如果我们想去掉p节点内部的文本，可以选择再把p节点内的文本提取一遍，然后从整个结果中移除这个子串，但这个做法明显比较烦琐。

这时remove()方法就可以派上用场了，我们可以接着这么做:

1 2	wrap.find('p').remove() print(wrap.text())

首先选中p节点，然后调用了remove()方法将其移除，然后这时wrap内部就只剩下Hello, World这句话了，然后再利用text()方法提取即可。

另外，其实还有很多节点操作的方法，比如append()、empty()和prepend()等方法，它们和jQuery的用法完全一致，详细的用法可以参考官方文档：http://pyquery.readthedocs.io/en/latest/api.html。

8. 伪类选择器

CSS选择器之所以强大，还有一个很重要的原因，那就是它支持多种多样的伪类选择器，例如选择第一个节点、最后一个节点、奇偶数节点、包含某一文本的节点等。示例如下：

html = '''
<div class="wrap">
    <div id="container">
        <ul class="list">
             <li class="item-0">first item</li>
             <li class="item-1"><a href="link2.html">second item</a></li>
             <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
             <li class="item-1 active"><a href="link4.html">fourth item</a></li>
             <li class="item-0"><a href="link5.html">fifth item</a></li>
         </ul>
     </div>
 </div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('li:first-child')
print(li)
li = doc('li:last-child')
print(li)
li = doc('li:nth-child(2)')
print(li)
li = doc('li:gt(2)')
print(li)
li = doc('li:nth-child(2n)')
print(li) `li \= doc('li:contains(second)')
print(li)`

这里我们使用了CSS3的伪类选择器，依次选择了第一个li节点、最后一个li节点、第二个li节点、第三个li之后的li节点、偶数位置的li节点、包含second文本的li节点。

关于CSS选择器的更多用法，可以参考http://www.w3school.com.cn/css/index.asp。

到此为止，pyquery的常用用法就介绍完了。如果想查看更多的内容，可以参考pyquery的官方文档：http://pyquery.readthedocs.io。我们相信有了它，解析网页不再是难事。

作者崔庆才发表于 2018-01-28 阅读次数：本文字数： 20k 阅读时长 ≈ 18 分钟

Python [Python3网络爬虫开发实战] 4.2-使用Beautiful Soup

前面介绍了正则表达式的相关用法，但是一旦正则表达式写的有问题，得到的可能就不是我们想要的结果了。而且对于一个网页来说，都有一定的特殊结构和层级关系，而且很多节点都有id或class来作区分，所以借助它们的结构和属性来提取不也可以吗？

这一节中，我们就来介绍一个强大的解析工具Beautiful Soup，它借助网页的结构和属性等特性来解析网页。有了它，我们不用再去写一些复杂的正则表达式，只需要简单的几条语句，就可以完成网页中某个元素的提取。

废话不多说，接下来就来感受一下Beautiful Soup的强大之处吧。

1. 简介

简单来说，Beautiful Soup就是Python的一个HTML或XML的解析库，可以用它来方便地从网页中提取数据。官方解释如下：

Beautiful Soup提供一些简单的、Python式的函数来处理导航、搜索、修改分析树等功能。它是一个工具箱，通过解析文档为用户提供需要抓取的数据，因为简单，所以不需要多少代码就可以写出一个完整的应用程序。

Beautiful Soup自动将输入文档转换为Unicode编码，输出文档转换为UTF-8编码。你不需要考虑编码方式，除非文档没有指定一个编码方式，这时你仅仅需要说明一下原始编码方式就可以了。

Beautiful Soup已成为和lxml、html6lib一样出色的Python解释器，为用户灵活地提供不同的解析策略或强劲的速度。

所以说，利用它可以省去很多烦琐的提取工作，提高了解析效率。

2. 准备工作

在开始之前，请确保已经正确安装好了Beautiful Soup和lxml，如果没有安装，可以参考第1章的内容。

3. 解析器

Beautiful Soup在解析时实际上依赖解析器，它除了支持Python标准库中的HTML解析器外，还支持一些第三方解析器（比如lxml）。表4-3列出了Beautiful Soup支持的解析器。

表4-3 Beautiful Soup支持的解析器

解析器

使用方法

优势

劣势

Python标准库

BeautifulSoup(markup, "html.parser")

Python的内置标准库、执行速度适中、文档容错能力强

Python 2.7.3及Python 3.2.2之前的版本文档容错能力差

lxml HTML解析器

BeautifulSoup(markup, "lxml")

速度快、文档容错能力强

需要安装C语言库

lxml XML解析器

BeautifulSoup(markup, "xml")

速度快、唯一支持XML的解析器

需要安装C语言库

html5lib

BeautifulSoup(markup, "html5lib")

最好的容错性、以浏览器的方式解析文档、生成HTML5格式的文档

速度慢、不依赖外部扩展

通过以上对比可以看出，lxml解析器有解析HTML和XML的功能，而且速度快，容错能力强，所以推荐使用它。

如果使用lxml，那么在初始化Beautiful Soup时，可以把第二个参数改为lxml即可：

1
2
3

from bs4 import BeautifulSoup
soup = BeautifulSoup('<p>Hello</p>', 'lxml')
print(soup.p.string)

在后面，Beautiful Soup的用法实例也统一用这个解析器来演示。

4. 基本用法

下面首先用实例来看看Beautiful Soup的基本用法：

html = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="dromouse"><b>The Dormouse's story</b></p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.prettify())
print(soup.title.string)

运行结果如下：

<html>
 <head>
  <title>
   The Dormouse's story
  </title>
 </head>
 <body>
  <p class="title" name="dromouse">
   <b>
    The Dormouse's story
   </b>
  </p>
  <p class="story">
   Once upon a time there were three little sisters; and their names were
   <a class="sister" href="http://example.com/elsie" id="link1">
    <!-- Elsie -->
   </a>
   ,
   <a class="sister" href="http://example.com/lacie" id="link2">
    Lacie
   </a>
   and
   <a class="sister" href="http://example.com/tillie" id="link3">
    Tillie
   </a>
   ;
and they lived at the bottom of a well.
  </p>
  <p class="story">
   ...
  </p>
 </body>
</html>
The Dormouse's story

这里首先声明变量html，它是一个HTML字符串。但是需要注意的是，它并不是一个完整的HTML字符串，因为body和html节点都没有闭合。接着，我们将它当作第一个参数传给BeautifulSoup对象，该对象的第二个参数为解析器的类型（这里使用lxml），此时就完成了BeaufulSoup对象的初始化。然后，将这个对象赋值给soup变量。

接下来，就可以调用soup的各个方法和属性解析这串HTML代码了。

首先，调用prettify()方法。这个方法可以把要解析的字符串以标准的缩进格式输出。这里需要注意的是，输出结果里面包含body和html节点，也就是说对于不标准的HTML字符串BeautifulSoup，可以自动更正格式。这一步不是由prettify()方法做的，而是在初始化BeautifulSoup时就完成了。

然后调用soup.title.string，这实际上是输出HTML中title节点的文本内容。所以，soup.title可以选出HTML中的title节点，再调用string属性就可以得到里面的文本了，所以我们可以通过简单调用几个属性完成文本提取，这是不是非常方便？

5. 节点选择器

直接调用节点的名称就可以选择节点元素，再调用string属性就可以得到节点内的文本了，这种选择方式速度非常快。如果单个节点结构层次非常清晰，可以选用这种方式来解析。

选择元素

下面再用一个例子详细说明选择元素的方法：

html = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="dromouse"><b>The Dormouse's story</b></p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.title)
print(type(soup.title))
print(soup.title.string)
print(soup.head)
print(soup.p)

运行结果如下：

<title>The Dormouse's story</title>
<class 'bs4.element.Tag'>
The Dormouse's story
<head><title>The Dormouse's story</title></head>
<p class="title" name="dromouse"><b>The Dormouse's story</b></p>

这里依然选用刚才的HTML代码，首先打印输出title节点的选择结果，输出结果正是title节点加里面的文字内容。接下来，输出它的类型，是bs4.element.Tag类型，这是Beautiful Soup中一个重要的数据结构。经过选择器选择后，选择结果都是这种Tag类型。Tag具有一些属性，比如string属性，调用该属性，可以得到节点的文本内容，所以接下来的输出结果正是节点的文本内容。

接下来，我们又尝试选择了head节点，结果也是节点加其内部的所有内容。最后，选择了p节点。不过这次情况比较特殊，我们发现结果是第一个p节点的内容，后面的几个p节点并没有选到。也就是说，当有多个节点时，这种选择方式只会选择到第一个匹配的节点，其他的后面节点都会忽略。

提取信息

上面演示了调用string属性来获取文本的值，那么如何获取节点属性的值呢？如何获取节点名呢？下面我们来统一梳理一下信息的提取方式。

(1)获取名称

可以利用name属性获取节点的名称。这里还是以上面的文本为例，选取title节点，然后调用name属性就可以得到节点名称：

1	print(soup.title.name)

运行结果如下：

title

(2)获取属性

每个节点可能有多个属性，比如id和class等，选择这个节点元素后，可以调用attrs获取所有属性：

1 2	print(soup.p.attrs) print(soup.p.attrs['name'])

运行结果如下：

1 2	{'class': ['title'], 'name': 'dromouse'} dromouse

可以看到，attrs的返回结果是字典形式，它把选择的节点的所有属性和属性值组合成一个字典。接下来，如果要获取name属性，就相当于从字典中获取某个键值，只需要用中括号加属性名就可以了。比如，要获取name属性，就可以通过attrs['name']来得到。

其实这样有点烦琐，还有一种更简单的获取方式：可以不用写attrs，直接在节点元素后面加中括号，传入属性名就可以获取属性值了。样例如下：

1 2	print(soup.p['name']) print(soup.p['class'])

运行结果如下：

1 2	dromouse ['title']

这里需要注意的是，有的返回结果是字符串，有的返回结果是字符串组成的列表。比如，name属性的值是唯一的，返回的结果就是单个字符串。而对于class，一个节点元素可能有多个class，所以返回的是列表。在实际处理过程中，我们要注意判断类型。

(3)获取内容

可以利用string属性获取节点元素包含的文本内容，比如要获取第一个p节点的文本：

1	print(soup.p.string)

运行结果如下：

1	The Dormouse's story

再次注意一下，这里选择到的p节点是第一个p节点，获取的文本也是第一个p节点里面的文本。

嵌套选择

在上面的例子中，我们知道每一个返回结果都是bs4.element.Tag类型，它同样可以继续调用节点进行下一步的选择。比如，我们获取了head节点元素，我们可以继续调用head来选取其内部的head节点元素：

html = """
<html><head><title>The Dormouse's story</title></head>
<body>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.head.title)
print(type(soup.head.title))
print(soup.head.title.string)

运行结果如下：

1
2
3

<title>The Dormouse's story</title>
<class 'bs4.element.Tag'>
The Dormouse's story

第一行结果是调用head之后再次调用title而选择的title节点元素。然后打印输出了它的类型，可以看到，它仍然是bs4.element.Tag类型。也就是说，我们在Tag类型的基础上再次选择得到的依然还是Tag类型，每次返回的结果都相同，所以这样就可以做嵌套选择了。

最后，输出它的string属性，也就是节点里的文本内容。

关联选择

在做选择的时候，有时候不能做到一步就选到想要的节点元素，需要先选中某一个节点元素，然后以它为基准再选择它的子节点、父节点、兄弟节点等，这里就来介绍如何选择这些节点元素。

(1)子节点和子孙节点

选取节点元素之后，如果想要获取它的直接子节点，可以调用contents属性，示例如下：

html = """
<html>
    <head>
        <title>The Dormouse's story</title>
    </head>
    <body>
        <p class="story">
            Once upon a time there were three little sisters; and their names were
            <a href="http://example.com/elsie" class="sister" id="link1">
                <span>Elsie</span>
            </a>
            <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> 
            and
            <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
            and they lived at the bottom of a well.
        </p>
        <p class="story">...</p>
"""

运行结果如下：

1
2
3

['\n            Once upon a time there were three little sisters; and their names were\n            ', <a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>, '\n', <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, ' \n            and\n            ', <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>, '\n            and they lived at the bottom of a well.\n        ']

可以看到，返回结果是列表形式。p节点里既包含文本，又包含节点，最后会将它们以列表形式统一返回。

需要注意的是，列表中的每个元素都是p节点的直接子节点。比如第一个a节点里面包含一层span节点，这相当于孙子节点了，但是返回结果并没有单独把span节点选出来。所以说，contents属性得到的结果是直接子节点的列表。

同样，我们可以调用children属性得到相应的结果：

from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.p.children)
for i, child in enumerate(soup.p.children):
    print(i, child)

运行结果如下：

<list_iterator object at 0x1064f7dd8>
0 
            Once upon a time there were three little sisters; and their names were

1 <a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
2 

3 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
4  
            and

5 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
6 
            and they lived at the bottom of a well.

还是同样的HTML文本，这里调用了children属性来选择，返回结果是生成器类型。接下来，我们用for循环输出相应的内容。

如果要得到所有的子孙节点的话，可以调用descendants属性：

from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.p.descendants)
for i, child in enumerate(soup.p.descendants):
    print(i, child)

运行结果如下：

<generator object descendants at 0x10650e678>
0 
            Once upon a time there were three little sisters; and their names were

1 <a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
2 

3 <span>Elsie</span>
4 Elsie
5 

6 

7 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
8 Lacie
9  
            and

10 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
11 Tillie
12 
            and they lived at the bottom of a well.

此时返回结果还是生成器。遍历输出一下可以看到，这次的输出结果就包含了span节点。descendants会递归查询所有子节点，得到所有的子孙节点。

(2)父节点和祖先节点

如果要获取某个节点元素的父节点，可以调用parent属性：

html = """
<html>
    <head>
        <title>The Dormouse's story</title>
    </head>
    <body>
        <p class="story">
            Once upon a time there were three little sisters; and their names were
            <a href="http://example.com/elsie" class="sister" id="link1">
                <span>Elsie</span>
            </a>
        </p>
        <p class="story">...</p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.a.parent)

运行结果如下：

<p class="story">
            Once upon a time there were three little sisters; and their names were
            <a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>

这里我们选择的是第一个a节点的父节点元素。很明显，它的父节点是p节点，输出结果便是p节点及其内部的内容。

需要注意的是，这里输出的仅仅是a节点的直接父节点，而没有再向外寻找父节点的祖先节点。如果想获取所有的祖先节点，可以调用parents属性：

html = """
<html>
    <body>
        <p class="story">
            <a href="http://example.com/elsie" class="sister" id="link1">
                <span>Elsie</span>
            </a>
        </p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(type(soup.a.parents))
print(list(enumerate(soup.a.parents)))

运行结果如下：

<class 'generator'>
[(0, <p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>), (1, <body>
<p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>
</body>), (2, <html>
<body>
<p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>
</body></html>), (3, <html>
<body>
<p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>
</body></html>)]

可以发现，返回结果是生成器类型。这里用列表输出了它的索引和内容，而列表中的元素就是a节点的祖先节点。

(3)兄弟节点

上面说明了子节点和父节点的获取方式，如果要获取同级的节点（也就是兄弟节点），应该怎么办呢？示例如下：

html = """
<html>
    <body>
        <p class="story">
            Once upon a time there were three little sisters; and their names were
            <a href="http://example.com/elsie" class="sister" id="link1">
                <span>Elsie</span>
            </a>
            Hello
            <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> 
            and
            <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
            and they lived at the bottom of a well.
        </p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print('Next Sibling', soup.a.next_sibling)
print('Prev Sibling', soup.a.previous_sibling)
print('Next Siblings', list(enumerate(soup.a.next_siblings)))
print('Prev Siblings', list(enumerate(soup.a.previous_siblings)))

运行结果如下：

Next Sibling 
            Hello

Prev Sibling 
            Once upon a time there were three little sisters; and their names were

Next Siblings [(0, '\n            Hello\n            '), (1, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>), (2, ' \n            and\n            '), (3, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>), (4, '\n            and they lived at the bottom of a well.\n        ')]
Prev Siblings [(0, '\n            Once upon a time there were three little sisters; and their names were\n            ')]

可以看到，这里调用了4个属性，其中next_sibling和previous_sibling分别获取节点的下一个和上一个兄弟元素，next_siblings和previous_siblings则分别返回所有前面和后面的兄弟节点的生成器。

(4)提取信息

前面讲解了关联元素节点的选择方法，如果想要获取它们的一些信息，比如文本、属性等，也用同样的方法，示例如下：

html = """
<html>
    <body>
        <p class="story">
            Once upon a time there were three little sisters; and their names were
            <a href="http://example.com/elsie" class="sister" id="link1">Bob</a><a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> 
        </p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print('Next Sibling:')
print(type(soup.a.next_sibling))
print(soup.a.next_sibling)
print(soup.a.next_sibling.string)
print('Parent:')
print(type(soup.a.parents))
print(list(soup.a.parents)[0])
print(list(soup.a.parents)[0].attrs['class'])

运行结果如下：

Next Sibling:
<class 'bs4.element.Tag'>
<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
Lacie
Parent:
<class 'generator'>
<p class="story">
            Once upon a time there were three little sisters; and their names were
            <a class="sister" href="http://example.com/elsie" id="link1">Bob</a><a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
</p>
['story']

如果返回结果是单个节点，那么可以直接调用string、attrs等属性获得其文本和属性；如果返回结果是多个节点的生成器，则可以转为列表后取出某个元素，然后再调用string、attrs等属性获取其对应节点的文本和属性。

6. 方法选择器

前面所讲的选择方法都是通过属性来选择的，这种方法非常快，但是如果进行比较复杂的选择的话，它就比较烦琐，不够灵活了。幸好，Beautiful Soup还为我们提供了一些查询方法，比如find_all()和find()等，调用它们，然后传入相应的参数，就可以灵活查询了。

`find_all()`

find_all，顾名思义，就是查询所有符合条件的元素。给它传入一些属性或文本，就可以得到符合条件的元素，它的功能十分强大。

它的API如下：

1	find_all(name , attrs , recursive , text , **kwargs)

(1)`name`

我们可以根据节点名来查询元素，示例如下：

html='''
<div class="panel">
    <div class="panel-heading">
        <h4>Hello</h4>
    </div>
    <div class="panel-body">
        <ul class="list" id="list-1">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
            <li class="element">Jay</li>
        </ul>
        <ul class="list list-small" id="list-2">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
        </ul>
    </div>
</div>
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.find_all(name='ul'))
print(type(soup.find_all(name='ul')[0]))

运行结果如下：

[<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>, <ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>]
<class 'bs4.element.Tag'>

这里我们调用了find_all()方法，传入name参数，其参数值为ul。也就是说，我们想要查询所有ul节点，返回结果是列表类型，长度为2，每个元素依然都是bs4.element.Tag类型。

因为都是Tag类型，所以依然可以进行嵌套查询。还是同样的文本，这里查询出所有ul节点后，再继续查询其内部的li节点：

1 2	for ul in soup.find_all(name='ul'): print(ul.find_all(name='li'))

运行结果如下：

1 2	[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>] [<li class="element">Foo</li>, <li class="element">Bar</li>]

返回结果是列表类型，列表中的每个元素依然还是Tag类型。

接下来，就可以遍历每个li，获取它的文本了：

for ul in soup.find_all(name='ul'):
    print(ul.find_all(name='li'))
    for li in ul.find_all(name='li'):
        print(li.string)

运行结果如下：

[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>]
Foo
Bar
Jay
[<li class="element">Foo</li>, <li class="element">Bar</li>]
Foo
Bar

(2)`attrs`

除了根据节点名查询，我们也可以传入一些属性来查询，示例如下：

html='''
<div class="panel">
    <div class="panel-heading">
        <h4>Hello</h4>
    </div>
    <div class="panel-body">
        <ul class="list" id="list-1" name="elements">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
            <li class="element">Jay</li>
        </ul>
        <ul class="list list-small" id="list-2">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
        </ul>
    </div>
</div>
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.find_all(attrs={'id': 'list-1'}))
print(soup.find_all(attrs={'name': 'elements'}))

运行结果如下：

[<ul class="list" id="list-1" name="elements">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>]
[<ul class="list" id="list-1" name="elements">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>]

这里查询的时候传入的是attrs参数，参数的类型是字典类型。比如，要查询id为list-1的节点，可以传入attrs={'id': 'list-1'}的查询条件，得到的结果是列表形式，包含的内容就是符合id为list-1的所有节点。在上面的例子中，符合条件的元素个数是1，所以结果是长度为1的列表。

对于一些常用的属性，比如id和class等，我们可以不用attrs来传递。比如，要查询id为list-1的节点，可以直接传入id这个参数。还是上面的文本，我们换一种方式来查询：

from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.find_all(id='list-1'))
print(soup.find_all(class_='element'))

运行结果如下：

[<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>]
[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>, <li class="element">Foo</li>, <li class="element">Bar</li>]

这里直接传入id='list-1'，就可以查询id为list-1的节点元素了。而对于class来说，由于class在Python里是一个关键字，所以后面需要加一个下划线，即class_='element'，返回的结果依然还是Tag组成的列表。

(3)`text`

text参数可用来匹配节点的文本，传入的形式可以是字符串，可以是正则表达式对象，示例如下：

import re
html='''
<div class="panel">
    <div class="panel-body">
        <a>Hello, this is a link</a>
        <a>Hello, this is a link, too</a>
    </div>
</div>
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.find_all(text=re.compile('link')))

运行结果如下：

1	['Hello, this is a link', 'Hello, this is a link, too']

这里有两个a节点，其内部包含文本信息。这里在find_all()方法中传入text参数，该参数为正则表达式对象，结果返回所有匹配正则表达式的节点文本组成的列表。

`find()`

除了find_all()方法，还有find()方法，只不过后者返回的是单个元素，也就是第一个匹配的元素，而前者返回的是所有匹配的元素组成的列表。示例如下：

html='''
<div class="panel">
    <div class="panel-heading">
        <h4>Hello</h4>
    </div>
    <div class="panel-body">
        <ul class="list" id="list-1">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
            <li class="element">Jay</li>
        </ul>
        <ul class="list list-small" id="list-2">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
        </ul>
    </div>
</div>
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.find(name='ul'))
print(type(soup.find(name='ul')))
print(soup.find(class_='list'))

运行结果如下：

<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<class 'bs4.element.Tag'>
<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>

这里的返回结果不再是列表形式，而是第一个匹配的节点元素，类型依然是Tag类型。

另外，还有许多查询方法，其用法与前面介绍的find_all()、find()方法完全相同，只不过查询范围不同，这里简单说明一下。

find_parents()和find_parent()：前者返回所有祖先节点，后者返回直接父节点。
find_next_siblings()和find_next_sibling()：前者返回后面所有的兄弟节点，后者返回后面第一个兄弟节点。
find_previous_siblings()和find_previous_sibling()：前者返回前面所有的兄弟节点，后者返回前面第一个兄弟节点。
find_all_next()和find_next()：前者返回节点后所有符合条件的节点，后者返回第一个符合条件的节点。
find_all_previous()和find_previous()：前者返回节点后所有符合条件的节点，后者返回第一个符合条件的节点。

7. CSS选择器

Beautiful Soup还提供了另外一种选择器，那就是CSS选择器。如果对Web开发熟悉的话，那么对CSS选择器肯定也不陌生。如果不熟悉的话，可以参考http://www.w3school.com.cn/cssref/css_selectors.asp了解。

使用CSS选择器时，只需要调用select()方法，传入相应的CSS选择器即可，示例如下：

html='''
<div class="panel">
    <div class="panel-heading">
        <h4>Hello</h4>
    </div>
    <div class="panel-body">
        <ul class="list" id="list-1">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
            <li class="element">Jay</li>
        </ul>
        <ul class="list list-small" id="list-2">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
        </ul>
    </div>
</div>
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.select('.panel .panel-heading'))
print(soup.select('ul li'))
print(soup.select('#list-2 .element'))
print(type(soup.select('ul')[0]))

运行结果如下：

[<div class="panel-heading">
<h4>Hello</h4>
</div>]
[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>, <li class="element">Foo</li>, <li class="element">Bar</li>]
[<li class="element">Foo</li>, <li class="element">Bar</li>]
<class 'bs4.element.Tag'>

这里我们用了3次CSS选择器，返回的结果均是符合CSS选择器的节点组成的列表。例如，select('ul li')则是选择所有ul节点下面的所有li节点，结果便是所有的li节点组成的列表。

最后一句打印输出了列表中元素的类型。可以看到，类型依然是Tag类型。

嵌套选择

select()方法同样支持嵌套选择。例如，先选择所有ul节点，再遍历每个ul节点，选择其li节点，样例如下：

from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
for ul in soup.select('ul'):
    print(ul.select('li'))

运行结果如下：

1 2	[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>] [<li class="element">Foo</li>, <li class="element">Bar</li>]

可以看到，这里正常输出了所有ul节点下所有li节点组成的列表。

获取属性

我们知道节点类型是Tag类型，所以获取属性还可以用原来的方法。仍然是上面的HTML文本，这里尝试获取每个ul节点的id属性：

from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
for ul in soup.select('ul'):
    print(ul['id'])
    print(ul.attrs['id'])

运行结果如下：

list-1
list-1
list-2
list-2

可以看到，直接传入中括号和属性名，以及通过attrs属性获取属性值，都可以成功。

获取文本

要获取文本，当然也可以用前面所讲的string属性。此外，还有一个方法，那就是get_text()，示例如下：

from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
for li in soup.select('li'):
    print('Get Text:', li.get_text())
    print('String:', li.string)

运行结果如下：

Get Text: Foo
String: Foo
Get Text: Bar
String: Bar
Get Text: Jay
String: Jay
Get Text: Foo
String: Foo
Get Text: Bar
String: Bar

可以看到，二者的效果完全一致。

到此，Beautiful Soup的用法基本就介绍完了，最后做一下简单的总结。

推荐使用lxml解析库，必要时使用html.parser。
节点选择筛选功能弱但是速度快。
建议使用find()或者find_all()查询匹配单个结果或者多个结果。
如果对CSS选择器熟悉的话，可以使用select()方法选择。

作者崔庆才发表于 2018-01-28 阅读次数：本文字数： 22k 阅读时长 ≈ 20 分钟