为了解决这个问题，我们查看了许多其他Python运行时。每个都有权衡，没有解决并发问题，也没有引入其他问题。

于是我们有了一个疯狂的想法：如果我们实现一个替代运行时优化的实时服务呢？Go似乎是一个明智的平台选择，因为它的操作特性与我们的用例（例如轻量级线程）能很好地匹配。我们想要一流的语言互操作性，Go的强大的运行时类型反射系统能让这一点变得十分简单，Python在Go上会很自然，所以Grumpy诞生了。

Grumpy 是一个 Python to Go 源代码编译器和运行时，旨在替代 CPython 2.7。

关键的区别是它将 Python 源代码编译为 Go 源代码，然后将其编译为本机代码，而不是字节码。这意味着 Grumpy没有 VM。编译的 Go 源代码是对 Grumpy 运行时的一系列调用，Go 库服务与 Python C API 类似的目的（尽管不直接支持 C API）。

部分内容编译自：opensource.googleblog.com

https://github.com/google/grumpy

Gevent
当前协程繁忙时，主动的放弃CPU资源，等到以后再运行。

协程和事件驱动：
最近在研究网络服务框架方面的东西，发现了一个神奇的东西-协程。
一句话说明什么是线程：协程是一种用户态的轻量级线程。
从硬件发展来看，从最初的单核单CPU，到单核多CPU，多核多CPU，似乎已经到了极限了，但是单核CPU性能却还在不断提升。server端也在不断的发展变化。如果将程序分为IO密集型应用和CPU密集型应用，二者的server的发展如下：
IO密集型应用: 多进程->多线程->事件驱动->协程
CPU密集型应用:多进程–>多线程
如果说多进程对于多CPU，多线程对应多核CPU，那么事件驱动和协程则是在充分挖掘不断提高性能的单核CPU的潜力。

同步和异步的比较
无论是线程还是进程，使用的都是同步进制，当发生阻塞时，性能会大幅度降低，无法充分利用CPU潜力，浪费硬件投资，更重要造成软件模块的铁板化，紧耦合，无法切割，不利于日后扩展和变化。不管是进程还是线程，每次阻塞、切换都需要陷入系统调用(system call)，先让CPU跑操作系统的调度程序，然后再由调度程序决定该跑哪一个进程(线程)。多个线程之间在一些访问互斥的代码时还需要加上锁，这也是导致多线程编程难的原因之一。
现下流行的异步server都是基于事件驱动的（如nginx）。事件驱动简化了编程模型，很好地解决了多线程难于编程，难于调试的问题。异步事件驱动模型中，把会导致阻塞的操作转化为一个异步操作，主线程负责发起这个异步操作，并处理这个异步操作的结果。由于所有阻塞的操作都转化为异步操作，理论上主线程的大部分时间都是在处理实际的计算任务，少了多线程的调度时间，所以这种模型的性能通常会比较好。
总的说来，当单核cpu性能提升，cpu不在成为性能瓶颈时，采用异步server能够简化编程模型，也能提高IO密集型应用的性能。

协程和线程
之前说道，协程是一种用户级的轻量级线程。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：
协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。
在并发编程中，协程与线程类似，每个协程表示一个执行单元，有自己的本地数据，与其它协程共享全局数据和其它资源。等待线程会抢占cpu，而协程会主动放弃cpu。不管是进程还是线程，每次阻塞、切换都需要陷入系统调用(system call)，先让CPU跑操作系统的调度程序，然后再由调度程序决定该跑哪一个进程(线程)。
而且由于抢占式调度执行顺序无法确定的特点，使用线程时需要非常小心地处理同步问题，而协程完全不存在这个问题（事件驱动和异步程序也有同样的优点）。

协程和事件驱动
以nginx为代表的事件驱动的异步server正在横扫天下，那么事件驱动模型会是server端模型的终点吗？
事件驱动编程的架构是预先设计一个事件循环，这个事件循环程序不断地检查目前要处理的信息，根据要处理的信息运行一个触发函数。其中这个外部信息可能来自一个目录夹中的文件，可能来自键盘或鼠标的动作，或者是一个时间事件。这个触发函数，可以是系统默认的也可以是用户注册的回调函数。
事件驱动程序设计着重于弹性以及异步化上面。许多GUI框架（如windows的MFC，Android的GUI框架），Zookeeper的Watcher等都使用了事件驱动机制。未来还会有其他的基于事件驱动的作品出现。
基于事件驱动的编程是单线程思维，其特点是异步+回调。
协程也是单线程，但是它能让原来要使用异步+回调方式写的非人类代码,可以用看似同步的方式写出来。它是实现推拉互动的所谓非抢占式协作的关键。

总结：
协程的好处：

跨平台
跨体系架构
无需线程上下文切换的开销
无需原子操作锁定及同步的开销
方便切换控制流，简化编程模型
高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。

缺点:

无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序：这一点和事件驱动一样，可以使用异步IO操作来解决

1. Scrapy

· 实现语言：Python

· GitHub Star 数：28660

· 官方支持链接

简介：

· Scrapy 是一种高速的高层 Web 爬取和 Web 采集框架，可用于爬取网站页面，并从页面中抽取结构化数据。

· Scrapy 的用途广泛，适用于从数据挖掘、监控到自动化测试。

· Scrapy 设计上考虑了从网站抽取特定的信息，它支持使用 CSS 选择器和 XPath 表达式，使开发人员可以聚焦于实现数据抽取。

· 对于熟悉 Python 的开发人员，只需几分钟就能建立并运行 Scrapy。

· 支持运行在 Linux、Mac OS 和 Windows 系统上。

特性：

· 内置支持从 HTML 和 XML 抽取数据、使用扩展的 CSS 选择器（Selector）和 XPath 表达式等特性。

· 支持以多种格式（JSON、CSV、XML）生成输出。

· 基于 Twisted 构建。

· 稳健的支持，自动检测编码方式。

· 快速，功能强大。

– 官方文档：https://docs.scrapy.org/en/latest/

– 官方网站：https://scrapy.org/

2. Cola

· 实现语言：Python

· GitHub Star 数：1274

· 官方支持链接

简介：

· Cola 是一种高层分布式爬取框架，实现从网站爬取网页，并从中抽取结构化数据。

· 它提供了一种实现目标数据获取的简单且灵活的方式。

· 用户只需要编写其中一部分代码，就可在本地和分布式环境下运行。

特性：

· 高层分布式爬取框架。

· 简单且高速。

· 灵活。

– 官方文档：https://github.com/chineking/cola

– 官方网站：https://pypi.org/project/Cola/

3. Crawley

· 实现语言 Python

· GitHub Star 数： 144

· 官方支持链接

简介：

· Crawley 是一种 Python 爬取和采集框架，意在简化开发人员从 Web 网页抽取数据到数据库等结构化存储中。

特性：

· 基于 Eventlet 构建的高速 Web 爬虫。

· 支持 MySQL、PostgreSQL、Oracle、Sqlite 等关系数据库引擎。

· 支持 MongoDB、CouchDB 等 NoSQL 数据库（最新特性！）。

· 支持导出数据为 JSON、XML 和 CSV 格式（最新特性！）。

· 命令行工具。

· 支持开发人员使用自己喜好的工具，例如 XPath 或 Pyquery（一种类似于 JQuery 的 Python 软件库）等。

· 支持 Cookie 处理器（Handler）。

– 官方文档：https://pythonhosted.org/crawley/

– 官方网站：http://project.crawley-cloud.com/

4. MechanicalSoup

· 实现语言： Python

· GitHub Star 数： 2803

· 官方支持链接

简介：

· MechanicalSoup 是一种设计模拟人类使用 Web 浏览器行为的 Python 软件库，它基于解析软件库 BeautifulSoup 构建。

· 如果开发人员需要从单个站点采集数据，或是不需要大量数据采集，那么使用 MechanicalSoup 是一种简单高效的方法。

· MechanicalSoup 自动存储和发送 Cookie、跟踪重定向、支持链接跟随和提交表单。

特性：

· 轻量级。

· 支持 Cookie 处理器。

– 官方文档： https://mechanicalsoup.readthedocs.io/en/stable/

– 官方网站：https://mechanicalsoup.readthedocs.io/

5. PySpider

· 实现语言： Python

· GitHub Star 数： 11803

· 官方支持链接

简介：

· PySpider 是一种 Python 编写的强大 Web 爬虫。

· 它支持 JavaScript 网页，并具有分布式架构。

· PySpider 支持将爬取数据存储在用户选定的后台数据库，包括MySQL, MongoDB, Redis, SQLite, Elasticsearch等。

· 支持开发人员使用 RabbitMQ、Beanstalk 和 Redis 等作为消息队列。

特性：

· 提供强大 Web 界面，具有脚本编辑器、任务监控、项目管理器和结果查看器。

· 支持对重度 Ajax 网站的爬取。

· 易于实现适用、快速的爬取。

– 官方文档： http://docs.pyspider.org/

– 官方网站：https://github.com/binux/pyspider

6. Portia

· 实现语言： Python

· GitHub Star 数： 6250

· 官方支持链接

简介：

· Portia 是由 Scrapinghub 创建的一种可视化爬取工具，它不需要用户具有任何程序开发知识。

· 如果用户并非开发人员，最好直接使用 Portia 实现 Web 爬取需求。

· 用户无需任何安装就可免费试用 Portia，只需要在 Scrapinghub 注册一个账户，就可使用托管版本。

· 即便用户没有编程技能，在 Portia 中创建爬虫并抽取 Web 内容也是非常易于实现的。

· 用户无需安装任何程序，因为 Portia 是运行在 Web 页面上的。

· 用户可以使用 Portia 的基本点击工具标注需要爬取的数据，然后 Portia 就会根据这些标注理解如何爬取类似页面中的数据。

· 一旦检测到需要爬取的页面，Portia 会形成一个用户已创建结构的实例。

特性：

· 通过记录并回放用户在页面上的操作，实现点击、拖动和等待等动作。

· Portia 可以很好地爬取基于 Ajax 构建的网站（基于 Splash），也适用于爬取 Backbone、Angular 和 Ember 等重度 JavsScript 框架。

– 官方文档：https://portia.readthedocs.io/en/latest/index.html

– 官方网站： https://github.com/scrapinghub/portia

7. Beautifulsoup

· 实现语言： Python

· 官方支持链接

简介：

· Beautiful Soup 一种设计用于实现 Web 爬取等快速数据获取项目的 Python 软件库。

· 它在设计上处于 HTML 或 XML 解析器之上，提供用于迭代、搜索和修改解析树等功能的 Python 操作原语。往往能为开发人员节省数小时乃至数天的工作。

特性：

· Beautiful Soup 自动将输入文档转换为 Unicode 编码，并将输出文档转换为 UTF-8 编码。

· Beautiful Soup 处于一些广为采用的 Python 解析器（例如，lxml和html5lib）之上，支持用户尝试使用多种不同的解析策略，并在速度和灵活性上做出权衡。

– 官方文档：https://www.crummy.com/software/BeautifulSoup/bs4/doc/

– 官方网站： https://www.crummy.com/software/BeautifulSoup/

8. Spidy 爬虫

· 实现语言： Python

· GitHub Star 数： 152

· 官方支持链接

简介：

· Spidy 是一种从命令行运行的 Web 爬虫。易于使用。用户只需提供 Web 网页的 URL 链接，Spidy 就可以开始爬取！Spidy 无疑是一种整体爬取 Web 的简单有效的方式。

· Spidy 使用 Python 请求查询 Web 页面，并使用 lxml 抽取页面中的所有链接。非常简单！

特性：

· 错误处理。

· 跨平台兼容性。

· 频繁时间戳日志。

· 可移植性。

· 用户友好的日志。

· 保存 Web 页面。

· 支持文件压缩。

– 官方文档：https://github.com/rivermont/spidy

– 官方网站： http://project.crawley-cloud.com/

9. Garb

· 实现语言： Python

· GitHub Star 数： 1627

· 官方支持链接

简介：

· Grab 是一种用于构建爬虫的 Python 框架。

· 使用 Grab 可构建出各种复杂度的 Web 爬虫，从只有五行代码的脚本，到可处理百万量级 Web 页面的复杂异步爬虫。

· Grab 提供了执行网络请求、处理接收内容的 API。例如，实现与 HTML 文档的 DOM 树进行交互。

特性：

· 支持 HTTP 和 SOCKS 代理，可使用也可不使用认证。

· 自动字符集检测。

· 强大的 API，支持使用 XPath 查询从 HTML 文档的 DOM 树中抽取数据。

· 自动 Cookie（或会话）支持。

– 官方文档：https://grablib.org/en/latest/

– 官方网站： https://github.com/lorien/grab

Java 编写的开源 Web 爬虫

10. Apache Nutch

· 实现语言： Java

· GitHub Star 数： 1743

· 官方支持链接

简介：

· Apache Nutch 是一种高度可扩展、可伸缩的开源 Web 爬虫软件项目。

· 如果要列出最好的开源 Web 爬虫列表，Apache Nutch 无疑金榜题名。

· 作为一种用于数据挖掘的高度可扩展、可伸缩的开源代码 Web 数据抽取软件项目，Apache Nutch 得到了广泛的使用。

· Nutch 支持单机运行，但是在 Hadoop 集群上运行可最大化地发挥其强大能力。

· 全球范围内很多数据分析人员和科研人员、应用开发人员和 Web 文本挖掘工程师都在使用 Apache Nutch。

· Apache Nutch 是一种 Java 编写的跨平台解决方案。

特性：

· 默认情况下，爬取数据和分析数据是独立的过程。

· 广泛支持多种文档格式，包括纯文本、HTML/XHTML+XML、XML、PDF、ZIP 等。

· 使用 XPath 和命名空间实现映射。

· 通过 Hadoop 支持分布式文件系统。

· 链接图形式的数据库。

· 支持 NTLM 认证。

– 官方文档： https://wiki.apache.org/nutch/

– 官方网站： http://nutch.apache.org/

11. Heritrix

· 实现语言： Java

· GitHub Star 数： 1236

· 官方支持链接

简介：

· 在使用 Java 编写的免费开源 Web 爬虫中，Heritrix 是其中一种得到广泛使用的工具。事实上，它是一种可扩展、Web 规模、存档质量（archival-quality）的 Web 爬取项目。

· Heritrix 是一种扩展能力和性能很好的解决方案，支持用户即刻爬取并归档一组网站。此外，它在设计上考虑了 robots.txt 禁止规则和 META 机器人标签。

· Heritrix 可运行在 Linux/Unix 和 Windows 系统上。

特性：

· HTTP 认证。

· NTLM 认证。

· 链接抽取中的 XSL 转换。

· 独立于搜索引擎。

· 是一种成熟并稳定的平台。

· 高度可配置。

· 支持在任一机器上运行。

– 官方文档： https://github.com/internetarchive/heritrix3/wiki/Heritrix%203.0%20and%203.1%20User%20Guide

– 官方站： https://github.com/internetarchive/heritrix3b

12. ACHE 爬虫

· 实现语言： Java

· GitHub Star 数： 154

· 官方支持链接

简介：

· ACHE 是一种专用于特定用途的 Web 爬虫。

· ACHE 爬取满足特定标准的 Web 页面。例如，属于特定领域并包含用户指定模式的页面。

· 不同于通用爬虫，ACHE 使用页面分类器遴选特定领域中的相关和无关页面。

· 页面分类器可以是基本的正则表达式（例如，匹配所有包含给定单词的页面），也可以基于机器学习的分类模型。ACHE 也可以自动学习如何对链接做优先处理，实现高效地定位相关内容，避免检索无关的页面内容。

特性：

· 对固定网站列表的正常爬取。

· 通过自动链接优先处理，发现并爬取新的相关网站。

· 可配置不同类型的页面分类器（例如，机器学习、正则表达式等）。

· 持续重新爬取站点，实现页面更新的发现。

· 使用 ElasticSearch 对爬取页面做索引。

· 实时搜索爬取页面的 Web 接口。

· 用于监控爬虫的 REST API 和基于 Web 的用户接口。

· 使用 TOR 代理爬取隐含服务。

– 官方文档： http://ache.readthedocs.io/en/latest/

– 官方网站： https://github.com/ViDA-NYU/ache

13. Crawler4j

· 实现语言： Java

· GitHub Star 数： 3039

· 官方支持链接

简介：

· crawler4j 是一种 Java 编写的开源 Web 爬虫，提供了爬取 Web 网站的基本接口。

· 开发人员可以使用 crawler4j 在数分钟内建立一个多线程 Web 爬虫。

– 官方文档： https://github.com/yasserg/crawler4j

– 官方网站： https://github.com/yasserg/crawler4j

14. Gecco

· 实现语言： Java

· GitHub Star 数： 1245

· 官方支持链接

简介：

· Gecco 是一种使用 Java 开发的轻量级 Web 爬虫，易于使用。

· Gecco 集成了 jsoup、httpclient、fastjson、spring、htmlunit、redission 等优秀框架。用户只需要配置一系列 jQuery 风格选择器，就能很快地建立一个爬虫。

· Gecco 框架具有优秀的扩展能力。框架基于一些开放式和封闭式设计原则，对改进封闭，对扩展开放。

特性：

· 易于使用，使用 jQuery 风格选择器抽取元素。

· 支持页面中的异步 Ajax 请求。

· 支持页面 JavaScript 变量抽取。

· 使用 Redis 实现分布式爬取（参见 gecco-redis 文档）。

· 支持使用 Spring 开发业务逻辑（参见 gecco-spring 文档）。

· 支持 htmlunit 扩展（参见 gecco-htmlunit 文档）。

· 支持多种扩展机制。

· 支持下载 UserAgent 的随机选择。

· 支持下载代理服务器的随机选取。

– 官方文档： https://github.com/xtuhcy/gecco

– 官方网站： https://github.com/xtuhcy/gecco

15. BUbiNG

· 实现语言： Java

· GitHub Star 数：24

· 官方支持链接

简介：

· BUbiNG 令人惊喜，它可称为下一代的开源 Web 爬虫。BUbiNG 是一种 Java 开发的完全分布式爬虫（无需中央协调），每秒可爬取数千个网页，并支持采集大规模数据集。

· BUbiNG 的分布式是基于高速协议实现的，因此可以获得非常高的通量。

· BUbiNG 提供对海量数据的大规模爬取。它完全可配置、易于扩展，并可集成垃圾信息检测。

特性：

· 高度并行。

· 完全分布式。

· 使用 JAI4J。JAI4J 是一种基于 JGroups 实现的瘦功能层，实现任务指派。

· （当前）使用剥离网页的指纹，检测近似的重复内容。

· 快速。

· 大规模爬取。

– 官方文档： http://law.di.unimi.it/software/bubing-docs/index.html

– 官方网站： http://law.di.unimi.it/software.php#bubing

16. Narconex

· 实现语言：Java

· 官方支持链接

简介：

· 对于寻求可满足企业级需求的开源 Web 爬虫的用户而言，Narconex 是一种很好的工具。

· Norconex 支持用户爬取任何 Web 内容。用户可以独立运行这种全功能数据采集器，或是将其集成在自己的应用中。

· 支持所有操作系统。可在具有一般容量的单体服务器上爬取数百万信息。此外，Narconex 提供多种内容和元数据操作特性，还可以抽取页面中特定的图像。

特性：

· 多线程。

· 支持按各种计划任务，抽取不同时间段的数据。

· 从 HTML、Word、PDF 等多种文件格式中抽取文本内容。

· 抽取文档相关的元数据。

· 支持抽取使用用 JavaScript 渲染的页面。

· 检测语言。

· 支持翻译。

· 可配置爬取速度。

· 可检测发生修改或已被删除的文档。

· 支持使用外部命令分析或操作文档。

– 官方文档： http://www.norconex.com/collectors/collector-http/getting-started

– 官方网站： http://www.norconex.com/collectors/collector-http/

17. WebSPHINX

· 实现语言： Java

· 当前尚不提供官方支持。

简介：

· WebSphinix 是一种非常易于使用的可定制 Web 爬虫。它设计用于高级 Web 用户和 Java 编程人员，支持他们自动爬取小部分 Web。

· WebSphinix 数据抽取解决方案也提供了一种全面的 Java 类库和交互式软件开发环境。WebSphinix 包括两部分：爬虫基准测试（Crawler Workbench），WebSPHINX 类库。

· 爬虫基准测试提供了很好的用户图形接口，支持用户配置并控制定制的 Web 爬虫。

· WebSPHINX 类库为使用 Java 编写 Web 爬虫提供支持。

· WebSphinix 支持运行在 Windows、Linux、Mac 和 Android IOS 上。

特性：

· 以图的方式可视化 Web 页面采集。

· 将多个页面组合为单个文档，以供查看和打印。

· 支持抽取所有满足设定模式的文本。

· 支持 HTML 解析。

· 支持 robot.txt 禁止标准。

· 通用 HTML 转换。

· 多线程 Web 页面检索。

– 官方文档： https://www.cs.cmu.edu/~rcm/websphinx/doc/index.html

– 官方网站： https://www.cs.cmu.edu/~rcm/websphinx/#about

18. Spiderman

· 实现语言： Java

· GitHub Star 数： 2400

· 官方支持链接

简介：

· Spiderman 是一种 Java 开源 Web 数据抽取工具。它采集特定的 Web 页面，并从中抽取有用数据。

· Spiderman 主要使用 XPath 和正则表达式等技术抽取实际数据。

特性：

· 更高的性能。

· 持久化集合状态。

· 分布式。

· 支持 JavaScript。

· – 官方文档： https://gitee.com/l-weiwei/spiderman

– 官方网站： https://gitee.com/l-weiwei/spiderman

19. WebCollector :

· 实现语言： Java

· GitHub Star 数： 1986

· 官方支持链接

简介：

· WebCollector 是一种基于 Java 的开源 Web 爬虫框架。

· 它为实现 Web 爬取功能提供了一下基本的接口。用户可以使用它在五分钟内建立起一个多线程爬虫。

特性：

· 快速。

– 官方文档： https://github.com/CrawlScript/WebCollector

– 官方网站： https://github.com/CrawlScript/WebCollector

20. Webmagic

· 实现语言： Java

· GitHub Star 数： 6891

· 官方支持链接

简介：

· WebMagic 是一种可扩展的爬虫框架。

· WebMagic 涵盖了爬虫的整个生命周期，包括下载、URL 管理、内容抽取和持久化。

· 可用于简化一些特定爬虫的开发。

特性：

· 高度灵活的简单内核。

· 提供实现 HTML 抽取的简单 API。

· 使用 POJO 标注定制爬虫，无需配置。

· 支持多线程和分布式。

· 易于集成。

– 官方文档： http://webmagic.io/docs/en/

– 官方网站： https://github.com/code4craft/webmagic

21. StormCrawler

· 实现语言： Java

· GitHub Star 数：437

· 官方支持链接

简介：

· StormCrawler 是一种基于 Apache Storm 构架分布式 Web 爬虫的开源 SDK。

· StormCrawler 为开发人员构建爬虫提供了软件库和一系列资源。

· StormCrawler 完全适用于以数据流提供需获取和解析的 URL 的情况，也非常适用于大规模递归性爬取，尤其是需要低延迟的情况。

特性：

· 可扩展。

· 有弹性。

· 低延迟。

· 易于扩展。

· 运行良好且高效。

– 官方文档： http://stormcrawler.net/docs/api/

– 官方网站： http://stormcrawler.net/

JavaScript 编写的开源 Web 爬虫

22. NodeCrawler

· 实现语言： JavaScript

· GitHub Star 数： 3999

· 官方支持链接

简介：

· NodeCrawler 是一种广为使用的 Web 爬虫，它基于 NodeJS 实现，具有非常快的爬取速度。

· Nodecrawler 非常适用于偏爱使用 JavaScript 编程或者致力于 JavaScript 项目的开发人员。其安装也非常简单。

· JSDOM 和 Cheerio（用于 HTML 解析）实现服务器端渲染。其中，JSDOM 更为稳定。

特性：

· 使用 Cheerio（默认）或 JSDOM 实现服务端 DOM 和自动 jQuery 插入。

· 可配置池子规模和重试次数。

· 控制爬取率限制。

· 请求的优先队列。

· 支持 forceUTF8 模式，使得爬虫可以检测并转换字符集。

· 与 4.x 乃至更新版本兼容。

– 官方文档：https://github.com/bda-research/node-crawler

– 官方网站：http://nodecrawler.org/

23. Simplecrawler

· 实现语言： JavaScript

· GitHub Star 数：1764

· 官方支持链接

简介：

· Simplecrawler 设计提供基本的、灵活且稳定的网站爬取 API。

· Simplecrawler 在实现上考虑了针对特大型 Web 站点的归档、分析和搜索。它可爬取上百万页面，并毫无问题地向磁盘写入数十 GB 数据。

特性：

· 提供了用于自动检测链接资源的一些简单逻辑，用户可自行替换和添加。

· 自动请求任何 robots.txt 禁止规则。

· 具有灵活的队列系统，可在磁盘上冻结和解冻。

– 官方文档： https://github.com/simplecrawler/simplecrawler

– 官方网站： https://www.npmjs.com/package/simplecrawler

24. Js-crawler :

· 实现语言： JavaScript

· GitHub Star 数： 167

· 官方支持链接)

简介：

· 使用 NodeJS 实现的 Web 爬虫，支持 HTTP 和 HTTPS

– 官方文档： https://github.com/antivanov/js-crawler

– 官方网站： https://github.com/antivanov/js-crawler

25. Webster

· 实现语言： JavaScript

· GitHub Star 数： 201

· 官方支持链接

简介：

· Webster 是一种使用 NodeJS 编写的可靠 Web 爬取和采集框架，用于爬取 Web 站点并从页面中抽取结构化数据。

· 与其他爬取框架的不同之处在于，Webster 可以抓取浏览器客户端的 JavaScript 和 Ajax 请求呈现的内容。

– 官方文档： http://webster.zhuyingda.com/

– 官方网站： https://github.com/zhuyingda/webster

26. Node-osmosis

· 实现语言：JavaScript

· GitHub Star 数： 3630

· **官方支持链接

简介：

* 一种使用 NodeJS 实现的 HTML/XML 解析器和 Web 爬虫。

特性：

· 使用原生 libxml 的 C 绑定。

· 干净的 Promise 类接口。

· 支持 CSS 3.0 和 XPath 1.0 选择器的混合。

· Sizzle 选择器、Slick 选择器以及更多。

· 不具有像 jQuery、cheerio 或 jsdom 那样的大型依赖。

· 构成深度和复杂的数据结构。

· HTML 解析器特性：

· 快速解析；

· 高速搜索；

· 内存占用小。

· HTML DOM 特性：

· 加载和搜索 ajax 内容；

· DOM 交互和事件；

· 执行嵌入和远程脚本；

· 在 DOM 中执行代码。

· HTTP 请求特性：

· 日志记录 URL，重定向和错误；

· Cookie 的 jar 包，以及自定义 Cookie/头部/用户代理；

· 登录/表单提交、会话 Cookie，基本的认证；

· 单代理、多代理，处理代理失败情况；

· 限制重试和重定向。

– 官方文档： https://rchipka.github.io/node-osmosis/global.html

– 官方网站： https://www.npmjs.com/package/osmosis

27. Supercrawler

· 实现语言：JavaScript

· GitHub Star 数： 4341

· 官方支持链接

简介：

· Supercrawler 是一种使用 NodeJS 实现的 Web 爬虫，在设计上支持高度可配置和易用性。

· 一旦成功爬取一个网页（可以是图像、文本文档或其他任何文件），Supercrawler 将会触发用户自定义的内容类型（content-type）处理器，处理页面解析、保存数据以及其它一些用户定义的功能。

特性：

· 链接检测：Supercrawler 会解析所爬取的 HTML 文档，识别其中链接并添加到队列中。

· 机器人解析：在爬取前 Supercrawler 会请求 robots.txt 并检查其中的禁止规则。它也可识别站点地图。

· 站点地图解析：Supercrawler 可以从 XML 站点地图文件中读取链接，并将链接添加到队列中。

· 并发限制：Supercrawler 可限制在任一时间发出的请求数。

· 速率限制：Supercrawler 可添加请求的时延，以免对服务器产生轰炸。

· 指数补偿（Exponential backoff）重试：Supercrawler 将依此在一小时、两小时、四小时乃至更多时间后重试请求。要使用该特性，爬取队列必须使用数据库或 Redis 作为后端。

· 主机名均衡：Supercrawler 可在不同主机名间平均分割请求量。要使用该特性，爬取队列必须以 Redis 为后端。

– 官方文档： https://github.com/brendonboshell/supercrawler

– 官方网站： https://github.com/brendonboshell/supercrawler

28. Web scraper 的 Chrome 扩展

· 实现语言：JavaScript

· GitHub Star 数： 775

· 官方支持链接

简介：

· Web Scraper 是一种 Chrome 浏览器扩展，构建用于从 Web 页面抽取数据。

· 用户可以使用该扩展创建计划（站点地图），定义如何遍历一个 Web 网站，以及如何从中抽取数据。

· Web Scraper 使用站点地图相应地遍历网站，并从中抽取数据。

· 支持以 CSV 格式导出所抽取的数据。

特性：

· 抽取多个页面。

· 站点地图和抽取的数据存储在浏览器的本地存储，也可存储在 CouchDB 中。

· 多种数据类型选取。

· 支持从动态网页（JavaScript+AJAX）抽取数据。

· 浏览抽取的数据。

· 以 CSV 格式导出抽取的数据。

· 导入、导出站点地图。

· 只依赖于 Chrome 浏览器。

– 官方文档： https://www.webscraper.io/documentation

– 官方网站： https://www.webscraper.io

29. Headless Chrome 爬虫

· 实现语言：JavaScript

· GitHub Star 数： 3256

· 官方支持链接

简介：

· 使用基本 HTML 文件请求的爬虫，通常速度很快。但这样的爬虫往往会抽取到空白内容，尤其是在爬取使用 AngularJS、React 和 Vue.js 等现代前端框架构建的网站时。

特性：

· 分布式爬取。

· 可配置并发、延迟和重试。

· 支持深度优先搜索和广度优先搜索算法。

· 支持插拔缓存存储，例如 Redis。

· 支持导出 CSV 和 JSON。

· 在达到最大请求时暂停爬取，并可在任一时刻恢复。

· 自动插入用于抽取的 jQuery。

· 保存屏幕截图，用于证实爬取过程。

· 模拟设备和用户代理。

· 具有优先队列，可提高爬取效率。

– 官方文档： https://github.com/yujiosaka/headless-chrome-crawler/blob/master/docs/API.md

– 官方网站： https://github.com/yujiosaka/headless-chrome-crawler

30. X-ray

· 实现语言：JavaScript

· GitHub Star 数： 4464

· 官方支持链接

特性：

· 模式灵活：支持字符串、数组、对象以及嵌套对象结构。模式并非绑定于所抽取的页面结构，支持用户获取选定结构中的数据。

· 可组合（Composable）：API 是完全可组合的，赋予用户抽取每个页面的极大灵活性。

· 分页支持：爬取页面在 Web 站点上的所有分页。X-ray 还支持请求延迟和分页限制，并支持将爬取页面导入到单个文件中。这样一旦单个页面产生错误，用户不会失去所有已爬取的数据。

· 爬虫支持：从一个页面开始，轻易跳转另一个页面。页面跳转是可预测的，按深度优先爬取所有页面。

· 负责任的爬取：X-ray 支持并发、限制、延迟、超时和限制，实现负责任地爬取任何页面。

· 可插拔驱动：可按用户需求置换不同的爬虫。

– 官方文档： https://github.com/matthewmueller/x-ray

– 官方网站： https://www.npmjs.com/package/x-ray-scraper

C 编写的开源 Web 爬虫

31. Httrack

· 实现语言：C

· GitHub Star 数： 747

· 官方支持链接

简介：

· HTTracks 是一项免费（GPL、Libre/自由软件）且易于使用的离线浏览器功能。

· 支持用户将 Web 站点下载到本地目录，递归构建全部目录，以及获取 HTML、图像和其它文件到本地计算机。

· HTTrack 会维持原站点的相对链接结构。用户可以用浏览器打开本地的“镜像”页面，并逐个链接浏览，与在线浏览无异。

· HTTrack 也支持对已有镜像站点的更新，以及从中断点恢复下载。

· HTTrack 高度可配置，并提供帮助文档。

特性：

· 多语言窗口，提供对 Linux/UNIX 的接口。

· 镜像单个站点，或是一并镜像多个站点。

· 支持按文件类型、链接位置、结构深度、文件大小过滤，接受或拒绝站点或文件名。

· 支持代理，可最大化速度，并可选认证。

– 官方文档： http://www.httrack.com/html/index.html

– 官方网站： http://www.httrack.com/

32. GNU Wget

· 实现语言：C

· GitHub Star 数： 22

· 官方支持链接

简介：

· GNU Wget 是一种免费软件包，它使用 HTTP、HTTPS、FTP、FTPS 等广为使用的互联网协议检索文件。

· Wget 是一种非交互式命令行工具，易于从脚本、Cron 任务、不具有 X 窗口支持的终端等处调用。

特性：

· 使用 REST 和 RANGE 支持从中断处恢复下载。

· 基于 NLS 的消息文件，可使用多种语言。

· 可运行于大多数类 UNIX 操作系统上，也支持 Windows.

· 支持 HTTP 代理。

· 支持 HTTP Cookie。

– 官方文档： https://www.gnu.org/software/wget/manual/

– 官方网站： https://www.gnu.org/software/wget/

C++编写的开源 Web 爬虫

33. gigablast

· 实现语言：C++

· GitHub Star 数： 912

· **官方支持链接

简介：

· Gigablast 是一种开源的 Web 和企业搜索引擎，也是一种爬虫。

· Gigablast 是自身维护数十亿页面检索索引的数家美国搜索引擎之一。

特性：

· 大规模。

· 高性能。

· 实时信息检索技术。

– 官方文档： http://www.gigablast.com/api.html

– 官方网站： http://www.gigablast.com/

C#编写的开源 Web 爬虫

34. http://Arachnode.net

· 实现语言：C#

· GitHub Star 数： 9

· 官方支持链接

简介：

· http://Arachnode.net 适用于寻求开源 Web 爬虫的 C#开发人员。

· http://Arachnode.net 软件类库从因特网下载内容、对内容做索引，并对过程做定制。

· 用户可使用该工具做个人内容聚合，也可用于将下载的内容抽取、采集和解析为多个表单。

· http://Arachnode.net 索引所发现的内容，并存储在 http://Lucene.NET 索引中。

· http://Arachnode.net 非常适用于文本挖掘，也适用于学习高级爬取技术。

特性：

· 可配置规则和行为。

· 集成 http://Lucene.NET。

· 支持 SQL Server 和全文本索引。

· 支持对.DOC/.PDF/.PPT/.XLS 等文件类型的索引。

· 支持将 HTML 转化为 XML 和 XHTML。

· 支持全部 JavaScript/AJAX 功能。

· 支持多线程和节流(Throttling)。

· 行为适当（Respectful）的爬取。

· 分析服务。

– 官方文档： https://documentation.arachnode.net/index.html

– 官方网站： http://arachnode.net/

35. Abot

· 实现语言：C#

· GitHub Star 数： 1392

· 官方支持链接

简介：

· Abot 是一种 C#实现的开源 Web 爬虫，主要侧重于速度和灵活性。

· Abot 在实现中考虑了底层技术细节，包括多线程、HTTP 请求、调度、链接解析等。

· 用户只需注册事件，就可以处理分页数据。

· 支持用户插入自己的核心接口实现，实现对整个爬取过程的完全控制。

特性：

· 高速！

· 易于定制（可插拔架构，支持用户定义爬取内容和方式）。

· 经过大量的单元测试（高代码覆盖率）。

· 非常轻量级（并非过度工程化）。

· 无过程之外的依赖，例如对数据库、所安装服务等的依赖。

– 官方文档： https://github.com/sjdirect/abot

– 官方网站： https://github.com/sjdirect/abot

36. Hawk

· 实现语言：C#

· GitHub Star 数： 1875

· 官方支持链接

简介：

· HAWK 无需用户做任何编程，提供图形可视化数据获取和清理工具，并以 GPL 协议开源。

特性：

· 无需编程，即可实现对 Web 内容的智能分析。

· 所见即所得（WYSIWYG），可视化拉拽，支持对数据转换和过滤等的快速处理。

· 支持从多种数据库和文件中导入和导出。

· 任务可保存并可重用。

· 尤其适用于爬取和数据清理，但其功能并不仅局限于此。

– 官方文档： https://github.com/ferventdesert/Hawk

– 官方网站： https://ferventdesert.github.io/Hawk/

37. SkyScraper

· 实现语言：C#

· GitHub Star 数： 39

· 官方支持链接

简介：

· 一种异步 Web 获取和爬虫，使用了 async/await 和响应式扩展。

– 官方文档： https://github.com/JonCanning/SkyScraper

– 官方网站： https://github.com/JonCanning/SkyScraper

.NET 编写的 Web 爬虫

38. DotnetSpider

· 实现语言：.NET

· GitHub Star 数： 1382

· 官方支持链接

简介：

· DotnetSpider 是一种使用.NET Standard 实现的 Web 爬取软件库，类似于 WebMagic 和 Scrapy。

· 它是一种适用于.NET 的轻量级、高效和高速的高层 Web 爬取和获取框架。

– 官方文档： https://github.com/dotnetcore/DotnetSpider/wiki

– 官方网站： https://github.com/dotnetcore/DotnetSpider

PHP 编写的开源 Web 爬虫

39. Goutte

· 实现语言：PHP

· GitHub Star 数： 6574

· 官方支持链接

简介：

· Goutte 是一种 PHP 实现的屏幕抓取和 Web 爬取软件库。

· Goutte 为爬取 Web 站点和从 HTML/XML 响应中抽取数据提供了很好的 API。

– 官方文档： https://goutte.readthedocs.io/en/latest/

– 官方网站： https://github.com/FriendsOfPHP/Goutte

40. Dom-crawler

· 实现语言：PHP

· GitHub Star 数： 1340

· 官方支持链接

简介：

· DomCrawler 组件简化了对 HTML 和 XML 文档的 DOM 浏览。

– 官方文档： https://symfony.com/doc/current/components/dom_crawler.html

– 官方网站： https://github.com/symfony/dom-crawler

41. Pspider

· 实现语言：PHP

· GitHub Star 数： 249

· 官方支持链接

简介：

· Pspider 是最近完全使用 PHP 实现的一种并行爬取框架，它基于 hightman/httpclient 组件。

– 官方文档： https://github.com/hightman/pspider

– 官方网站： https://github.com/hightman/pspider

42. Php-spider

· 实现语言：PHP

· GitHub Star 数： 1023

· 官方支持链接

简介：

· 一种可配置、可扩展的 Web 爬虫。

特性：

· 可限制爬取深度、队列大小和最大下载数。

· 支持基于 XPath、CSS 选择器或普通（Plain old）PHP 添加自定义的 URI 发现逻辑。

· 提供了一系列有用的 URI 过滤器，例如域限制等。

· 收集爬取统计信息，用于形成报告。

– 官方文档： https://github.com/mvdbos/php-spider

– 官方网站： https://github.com/mvdbos/php-spider

43. Spatie / Crawler

· 实现语言：PHP

· GitHub Star 数： 740

· **官方支持链接

简介：

· 该软件包提供了从 Web 站点爬取链接的类。在实现的底层机制上，使用了 GuzzleHttp/Promise 并发爬取多个 URL。

· 该爬虫支持执行 JavaScript，可以爬取使用 JavaScript 渲染的站点。从实现的底层机制看，该特性使用了 Chrome 和 Puppeteer。

– 官方文档： https://github.com/spatie/crawler

– 官方网站： https://github.com/spatie/crawler

Ruby 实现的开源 Web 爬虫

44. Mechanize

· 实现语言：Ruby

· GitHub Star 数： 3728

· 官方支持链接

简介：

· Mechanize 软件库用于实现于 Web 站点的自动交互。

· Mechanize 自动按重定向存储并发送 Cookie。可以根据链接提交表单，支持填写和提交表单域。

· Mechanize 也可跟踪用户访问过站点的历史记录。

– 官方文档： http://docs.seattlerb.org/mechanize/

– 官方网站： https://github.com/sparklemotion/mechanize

GO 编写的开源 Web 爬虫

45. Colly

· 实现语言：Go

· GitHub Star 数： 5439

· 官方支持链接

简介：

· 为 Go 爱好者提供了一种快速且适用的爬取框架。

· Colly 提供了非常清晰的接口，可用于编写任何类型的爬虫和数据获取工具。

· Colly 使得用户可以轻易地从站点抽取结构化数据。这些数据适用于大范围的应用，例如数据挖掘、数据处理和归档。

特性：

· 清晰的 API。

· 高速（支持单核每秒处理一千次以上的请求）。

· 按域管理请求延迟和最大并发。

· 自动 Cookie 和会话管理。

· 同步/异步/并行爬取。

· 支持缓存。

· 对非 unicode 响应的自动编码。

· 支持 robots.txt 禁止规则。

· 分布式爬取。

· 可通过环境变量配置。

· 支持扩展。

– 官方文档： http://go-colly.org/docs/

– 官方网站： http://go-colly.org/

46. Gopa

· 实现语言：Go

· GitHub Star 数： 169

· 官方支持链接

特性：

· 轻量级，低资源占用，小于 100MB 的内存需求。

· 易于部署，无需任何运行时和依赖关系。

· 易于使用，不需要用户具有任何编程和脚本技能，提供开箱即可用特性。

– 官方文档： https://github.com/infinitbyte/gopa

– 官方网站： https://github.com/infinitbyte/gopa

47. Pholcus

· 实现语言：Go

· GitHub Star 数： 4341

· 官方支持链接

简介：

· Pholcus 是一种完全使用 Go 语言实现的高并发性、重量级爬虫软件。

· 它针对因特网数据采集，为只具有基本 Go 或 JavaScript 编程基础的用户提供了一种只需要关注自定义功能的特性。

· 规则简单灵活，并发批处理任务，提供丰富的输出方式，包括 MySQL、MongoDB、Kafka、CSV、Exvel 等。

· 用户共享了大量的演示。此外，Pholcus 支持两种水平和垂直爬取模式，支持模拟登陆、暂停任务、取消任务等一系列高级特性。

特性：

· 一种强大的爬取工具。

· 支持三种运行模式：单机、服务器和客户。

· 提供三种操作接口：Web、GUI 和命令行。

– 官方文档： https://pholcus.gitbooks.io/docs/

– 官方网站： https://github.com/henrylee2cn/pholcus

R 编写的开源 Web 爬虫

48. Rvest

· 实现语言：R

· GitHub Star 数： 969

· 官方支持链接

简介：

· Rvest 为用户从 Web 页面抽取信息提供帮助。它在设计上使用了 magrittr 软件包，易于表达通用 Web 抽取。

– 官方文档： https://cran.r-project.org/web/packages/rvest/rvest.pdf

– 官方网站： https://github.com/hadley/rvest

Scala 编写的开源 Web 爬虫

49. Sparkler

· 实现语言： Scala

· GitHub Star 数： 198

· 官方支持链接

简介：

· Web 爬虫是一种机器人程序，它从 Web 网站采集资源，用于构建搜索引擎、知识库等应用。

· Sparkler（“Spark-Crawler”的缩写）是一种新型的 Web 爬虫，它通过整合 Spark、Kafka、Lucene/Solr、Tika、pf4j 等多种 Apache 项目，使用了分布式计算和信息检索领域的最新进展。

特性：

· 提供更高的性能，具有更好的容错。

· 支持复杂和近实时分析。

· 实时输出数据流。

· 可扩展的插件框架。

· 通用解析器。

– 官方文档： http://irds.usc.edu/sparkler/dev/development-environment-setup.html#contributing-source

– 官方网站： http://irds.usc.edu/sparkler/

Perl 编写的开源 Web 爬虫

50. Web-scraper

· 实现语言：Perl

· GitHub Star 数： 91

· 官方支持链接

简介：

· Web Scraper 是一种使用 HTML、CSS 选择器或 XPath 表达式的 Web 采集工具集。

– 官方文档： https://github.com/miyagawa/web-scraper

– 官方网站： https://github.com/miyagawa/web-scraper

小结

以上罗列了 50 个不同编程语言下的不错爬虫框架/项目，感兴趣可以用用看。

英文原文： http://www.prowebscraper.com/blog/

Pyston v2 is easy to deploy, so if you’re looking for better Python performance, we encourage you to take five minutes and try Pyston. Doing so is one of the easiest ways to speed up your project.

Performance

Pyston v2 provides a noticeable speedup on many workloads while having few drawbacks. Our focus has been on web serving workloads, but Pyston v2 is also faster on other workloads and popular benchmarks.

Our team put together a new public Python macrobenchmark suite that measures the performance of several commonly-used Python projects. The benchmarks in this suite are larger than those found in other Python suites, making them more likely to be representative of real-world applications. Even though this gives us a lower headline number than other projects, we believe it translates to better speedups for real use cases. Pyston v2 still shows sped-up performance on microbenchmarks, being twice as fast as standard Python on tests like chaos.py and nbody.py.

Results were collected on an m5.large EC2 instance running Ubuntu 20.04

[1] Warmup time is defined as time until the benchmark reached 95% of peak performance; if it was not distinguishable from noise it is marked “n/a”. Only post-warmup behavior is considered for latency measurement.
[2] mypy and PyTorch don’t support automatically building their C extensions from source, so these Pyston numbers use our unsafe compatibility mode
[3] The PyPy benchmark suite was modified to only run the benchmarks that are compatible with Python 3.8

Results analysis

In our targeted benchmarks (djangocms + flaskblogging), Pyston v2 provides an average 1.22x speedup for mean latency and an 1.18x improvement for p99 latency while using a just few more megabytes per process. We have not yet invested time in optimizing the other benchmarks.

“p99 latency” is the upper 99th percentile of the response-time distribution, and is a common metric used in web serving contexts since it can provide insight into user experience that is lost by taking an average. PyPy’s high p99 latency on djangocms comes from periodic latency spikes, presumably from garbage collection pauses. CPython and Pyston both exhibit periodic spikes, presumably from their cycle collectors, but they are both less frequent and much smaller in magnitude.

The mypy and PyTorch benchmarks show a natural boundary of Pyston v2. These benchmarks both do the bulk of their work in C extensions which are unaffected by our Python speedups. We natively support the C API and do not have an emulation layer, so we are still able to provide a small boost to mypy performance and do not degrade pytorch or numpy performance. Your benefit will depend on your mix of Python and C extension work.

Technical approach

We’re planning on going into more detail in future blog posts, but some of the techniques we use in Pyston v2 include:

• A very-low-overhead JIT using DynASM
• Quickening
• General CPython optimizations
• Build process improvements

Compatibility

Since Pyston is a fork of CPython, we believe it is one of the most compatible alternative Python implementations available today. It supports all the same features and C API that CPython does.

While Pyston is identically functional in theory, in practice there are some temporary compatibility hurdles for any new Python implementation. Please see our wiki for details.

Availability

Pyston v2.0 is immediately available as a pre-built package. Currently, we have packages for Ubuntu 18.04 and 20.04 x86_64. If you would like support for a different OS, let us know by filing an issue in our issue tracker.

Trying out Pyston is as simple as installing our package, replacing python3 with pyston3, and reinstalling your dependencies with pip-pyston3 install (though see our wiki for a known issue about setuptools). If you already have an automated build set up, the change should be just a few lines.

Our plan is to open-source the code in the future, but since compiler projects are expensive and we no longer have benevolent corporate sponsorship, it is currently closed-source while we iron out our business model.

Reaching us

We are designing Pyston for developers and love to hear about your needs and experiences. So, we’ve set up a Discord server where you can chat with us. If you’d like a commercially-supported version of Pyston, please send us an email.

We’ve optimized Pyston for several use cases but are eager to hear about new ones so that we can make it even more beneficial. If you run into any problems or instances where Pyston does not help as much as expected, please let us know!

Background

We designed Pyston v1 at Dropbox to speed up Python for its web serving workloads. After the project ended, some of us from the team brainstormed how we would do it differently if we were to do it again. In early 2020, enough pieces were in place for us to start a company and work on Pyston full-time.

Pyston v2 is inspired by but is technically unrelated to the original Pyston v1 effort.

Moving forward

We’re on a mission to make Python faster and have plenty of ideas to do so. That means we’re actively looking for people to join the team. Let us know if you’d like to get involved. Otherwise stay tuned for future releases and reach out if you have any questions!

scrapy中的有很多配置，说一下比较常用的几个：

• CONCURRENT_ITEMS：项目管道最大并发数
• CONCURRENT_REQUESTS： scrapy下载器最大并发数
• DOWNLOAD_DELAY：访问同一个网站的间隔时间，单位秒。一般默认为0.5*DOWNLOAD_DELAY到1.5 *DOWNLOAD_DELAY之间的随机值。也可以设置为固定值，由RANDOMIZE_DOWNLOAD_DELAY指定是否固定，默认True随机。这里的同一个网站可以是域名也可以是IP，由CONCURRENT_REQUESTS_PER_IP的值决定。
• CONCURRENT_REQUESTS_PER_DOMAIN：对单个域名的最大并发
• CONCURRENT_REQUESTS_PER_IP：对单个IP的最大并发，如果值不为0，则CONCURRENT_REQUESTS_PER_DOMAIN参数被忽略，而且DOWNLOAD_DELAY这个参数的同一网站指的是IP
• DEFAULT_ITEM_CLASS：执行scrapy shell 命令的默认item类，默认scrapy.item.Item
• DEPTH_LIMIT：爬取的最大深度
• DEPTH_PRIORITY：正值为广度优先(BFO)，负值为深度优先(DFO)，计算公式：request.priority = request.priority - ( depth * DEPTH_PRIORITY )
• COOKIES_ENABLED： 是否启用cookie中间件，也就是自动cookie管理
• COOKIES_DEBUG：将请求cookie和响应包含Set-Cookie的写入日志
• DOWNLOADER_MIDDLEWARE：下载器中间件和优先级的字典
• DEFAULT_REQUEST_HEADERS：用于Scrapy HTTP请求的默认标头
• DUPEFILTER_CLASS：去重的类，可以改成使用布隆过滤器，而不使用默认的
• LOG_ENABLED：是否启用日志
• LOG_FILE：日志文件路径，默认为None
• LOG_FORMAT：日志格式化表达式
• LOG_DATEFORMAT：LOG_FORMAT中的时间格式化表达式
• LOG_LEVEL：最低日志级别，默认DEBUG，可用：CRITICAL, ERROR, WARNING, INFO, DEBUG
• LOG_STDOUT：是否将所有标准输出（和错误）将被重定向到日志，例如print也会被记录在日志
• LOG_SHORT_NAMES：如果为True，则日志将仅包含根路径;如果设置为False，则显示负责日志输出的组件
• LOGSTATS_INTERVAL：每次统计记录打印输出之间的间隔
• MEMDEBUG_ENABLED：是否启用内存调试
• REDIRECT_MAX_TIMES：定义可以重定向请求的最长时间
• REDIRECT_PRIORITY_ADJUST：调整重定向请求的优先级，为正值时优先级高
• RETRY_PRIORITY_ADJUST：调整重试请求的优先级
• ROBOTSTXT_OBEY：是否遵循robot协议
• SCRAPER_SLOT_MAX_ACTIVE_SIZE：正在处理响应数据的软限制（以字节为单位），如果所有正在处理的响应的大小总和高于此值，Scrapy不会处理新的请求。
• SPIDER_MIDDLEWARES：蜘蛛中间件
• USER_AGENT：默认使用的User-Agent

我也是新手，并没有系统性的使用scrapy，只是用来练习过一些小项目，所以如果有错误还请指出。

面对这么多的设置总不能用一次就查一次吧，所以我们需要修改scrapy startproject命令默认创建的模板文件中的settings.py的内容，将以上的注释和参数都保存在这个文件中，每当我们创建一个新的工程，我们只需要看一下settings.py中哪个参数需要更改就行了。模板文件在Anaconda\Lib\site-packages\scrapy\templates\project\module(如果是anaconda的话)

# 项目名称
BOT_NAME = '$project_name'

SPIDER_MODULES = ['$project_name.spiders']
NEWSPIDER_MODULE = '$project_name.spiders'

# 在项目处理器（也称为“ 项目管道”）中并行处理的最大并发项目数（每个响应），默认100。
#CONCURRENT_ITEMS = 100

# Scrapy下载器将执行的并发（即，并发）请求的最大数量，默认16
CONCURRENT_REQUESTS = 8

# 从同一网站下载连续页面之前，下载程序应等待的时间（以秒为单位）。
# 这可以用来限制爬网速度，以避免对服务器造成太大的冲击。支持小数。
# 默认情况下，Scrapy不会在请求之间等待固定的时间，而是使用0.5 * DOWNLOAD_DELAY和1.5 * DOWNLOAD_DELAY之间的随机间隔。
#DOWNLOAD_DELAY = 0

# 将对任何单个域执行的并发（即，并发）请求的最大数量，默认8
#CONCURRENT_REQUESTS_PER_DOMAIN = 16

# 将对任何单个IP执行的并发（即，并发）请求的最大数量，默认0。
# 如果非0，CONCURRENT_REQUESTS_PER_DOMAIN这个参数会被忽略，即按IP不按域名。DOWNLOAD_DELAY也是按IP
#CONCURRENT_REQUESTS_PER_IP = 16

# 将用于实例化Scrapy shell中的项目的默认类
#DEFAULT_ITEM_CLASS = 'scrapy.item.Item'

# 对于任何站点，将允许爬网的最大深度。如果为零，则不施加限制
#DEPTH_LIMIT = 0

# 根据DEPTH_PRIORITY的值取决于深度优先或广度优先，即正值为广度优先(BFO)，负值为深度优先(DFO)
# 计算公式：request.priority = request.priority - ( depth * DEPTH_PRIORITY )
#DEPTH_PRIORITY = 0

# 是否启用cookie
COOKIES_ENABLED = False

# 如果启用，Scrapy将记录请求中发送的所有cookie（即Cookie 标头）和响应中接收的所有cookie（即Set-Cookie标头）
#COOKIES_DEBUG = False

# 是否收集详细的深度统计信息。如果启用此功能，则在统计信息中收集每个深度的请求数
#DEPTH_STATS_VERBOSE = False

# 是否启用DNS内存缓存
#DNSCACHE_ENABLED = True

# DNS内存缓存大小
#DNSCACHE_SIZE = 10000

# 处理DNS查询的超时时间（以秒为单位）。支持浮动
#DNS_TIMEOUT = 60

# 用于爬网的下载器
#DOWNLOADER = 'scrapy.core.downloader.Downloader'

# Disable Telnet Console (enabled by default)
#TELNETCONSOLE_ENABLED = False

# 包含您的项目中启用的下载器中间件及其命令的字典
#DOWNLOADER_MIDDLEWARE = {}

# 用于Scrapy HTTP请求的默认标头。它们被填充在 DefaultHeadersMiddleware
DEFAULT_REQUEST_HEADERS = {
}

# Scrapy中默认启用的下载程序中间件的字典。低值更接近引擎，高值更接近下载器，
# 不要试图修改此设置，请修改DOWNLOADER_MIDDLEWARE
#DOWNLOADER_MIDDLEWARES_BASE = {
#     'scrapy.downloadermiddlewares.robotstxt.RobotsTxtMiddleware': 100,
#     'scrapy.downloadermiddlewares.httpauth.HttpAuthMiddleware': 300,
#     'scrapy.downloadermiddlewares.downloadtimeout.DownloadTimeoutMiddleware': 350,
#     'scrapy.downloadermiddlewares.defaultheaders.DefaultHeadersMiddleware': 400,
#     'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': 500,
#     'scrapy.downloadermiddlewares.retry.RetryMiddleware': 550,
#     'scrapy.downloadermiddlewares.ajaxcrawl.AjaxCrawlMiddleware': 560,
#     'scrapy.downloadermiddlewares.redirect.MetaRefreshMiddleware': 580,
#     'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 590,
#     'scrapy.downloadermiddlewares.redirect.RedirectMiddleware': 600,
#     'scrapy.downloadermiddlewares.cookies.CookiesMiddleware': 700,
#     'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': 750,
#     'scrapy.downloadermiddlewares.stats.DownloaderStats': 850,
#     'scrapy.downloadermiddlewares.httpcache.HttpCacheMiddleware': 900,
# }

# 是否启用下载器统计信息收集
#DOWNLOADER_STATS = True

# 包含在项目中启用的请求下载处理程序的字典
#DOWNLOAD_HANDLERS = {}

# 包含请求下载处理程序的默认字典
# 如果要禁用FTP处理程序，请设置DOWNLOAD_HANDLERS = {'ftp': None}
#DOWNLOAD_HANDLERS_BASE = {
#     'file': 'scrapy.core.downloader.handlers.file.FileDownloadHandler',
#     'http': 'scrapy.core.downloader.handlers.http.HTTPDownloadHandler',
#     'https': 'scrapy.core.downloader.handlers.http.HTTPDownloadHandler',
#     's3': 'scrapy.core.downloader.handlers.s3.S3DownloadHandler',
#     'ftp': 'scrapy.core.downloader.handlers.ftp.FTPDownloadHandler',
# }

# 下载程序的超时时间（以秒为单位）
#DOWNLOAD_TIMEOUT = 180

# 载程序将下载的最大响应大小（以字节为单位,默认1024MB），为0则不限制
#DOWNLOAD_MAXSIZE = 1073741824

# 下载程序将开始警告的响应大小（以字节为单位，默认32MB）
#DOWNLOAD_WARNSIZE = 33554432

# 声明的Content-Length与服务器发送的内容不匹配，是否触发异常ResponseFailed([_DataLoss]) 
# 如果为False，可以在爬虫文件中判断并处理 if 'dataloss' in response.flags: 
#DOWNLOAD_FAIL_ON_DATALOSS = True

# 用于检测和过滤重复请求的类
#DUPEFILTER_CLASS = 'scrapy.dupefilters.RFPDupeFilter'

# 默认情况下，RFPDupeFilter仅记录第一个重复的请求。设置DUPEFILTER_DEBUG为True它将记录所有重复的请求。
#DUPEFILTER_DEBUG = False

# 包含您的项目中启用的扩展及其顺序的字典
#EXTENSIONS = {}

# 包含默认情况下在Scrapy中可用的扩展程序及其顺序的字典
#EXTENSIONS_BASE = {
#     'scrapy.extensions.corestats.CoreStats': 0,
#     'scrapy.extensions.telnet.TelnetConsole': 0,
#     'scrapy.extensions.memusage.MemoryUsage': 0,
#     'scrapy.extensions.memdebug.MemoryDebugger': 0,
#     'scrapy.extensions.closespider.CloseSpider': 0,
#     'scrapy.extensions.feedexport.FeedExporter': 0,
#     'scrapy.extensions.logstats.LogStats': 0,
#     'scrapy.extensions.spiderstate.SpiderState': 0,
#     'scrapy.extensions.throttle.AutoThrottle': 0,
# }

# 包含要使用的项目管道及其顺序的字典。值是任意的，但是习惯上将它们定义在0-1000范围内。低值优先于高值
#ITEM_PIPELINES = {}

# 是否启用日志记录
#LOG_ENABLED = True

# 用于日志记录的编码
#LOG_ENCODING = 'utf-8'

# 用于记录输出的文件名
#LOG_FILE = None

# 用于格式化日志消息的字符串
#LOG_FORMAT = '%(asctime)s [%(name)s] %(levelname)s: %(message)s'

# 用于格式化日期/时间的字符串，用于改变LOG_FORMAT 中的asctime占位符
#LOG_DATEFORMAT = '%Y-%m-%d %H:%M:%S'

# 用于格式化不同操作的日志消息的类
#LOG_FORMATTER = "scrapy.logformatter.LogFormatter"

# 最低记录级别, 可用：CRITICAL, ERROR, WARNING, INFO, DEBUG
#LOG_LEVEL = 'DEBUG'

# 如果为True，所有标准输出（和错误）将被重定向到日志，例如print也会被记录在日志
#LOG_STDOUT = False

# 如果为True，则日志将仅包含根路径;如果设置为False，则显示负责日志输出的组件
#LOG_SHORT_NAMES = False

# 每次统计记录打印输出之间的间隔（以秒为单位）
#LOGSTATS_INTERVAL = 60.0

# 是否启用内存调试
#MEMDEBUG_ENABLED = False

# 启用内存调试后，如果此设置不为空，则会将内存报告发送到指定的邮箱地址，否则该报告将被写入日志。
# 例如：MEMDEBUG_NOTIFY = ['user@example.com']
#MEMDEBUG_NOTIFY = []

# 是否启用内存使用扩展。此扩展跟踪该进程使用的峰值内存（将其写入统计信息）。
# 当超过内存限制时，它还可以选择关闭Scrapy进程，并在发生这种情况时通过电子邮件通知
#MEMUSAGE_ENABLED = True

# 关闭Scrapy之前允许的最大内存量
#MEMUSAGE_LIMIT_MB = 0

#MEMUSAGE_CHECK_INTERVAL_SECONDS = 60.0

# 电子邮件列表，用于通知是否已达到内存限制
#MEMUSAGE_NOTIFY_MAIL = False

# 发送警告电子邮件通知最大内存之前允许的最大内存量（以兆字节为单位）。如果为零，则不会发出警告
#MEMUSAGE_WARNING_MB = 0

# 使用genspider命令创建爬虫的模板
#NEWSPIDER_MODULE = ""

# 如果启用，Scrapy将在从同一网站获取请求的同时等待随机的时间（介于0.5 * DOWNLOAD_DELAY和1.5 *之间DOWNLOAD_DELAY）
#RANDOMIZE_DOWNLOAD_DELAY = True

# Twisted Reactor线程池大小的最大限制。这是各种Scrapy组件使用的通用多用途线程池。
# 线程DNS解析器，BlockingFeedStorage，S3FilesStore仅举几例。
# 如果遇到阻塞IO不足的问题，请增加此值。
#REACTOR_THREADPOOL_MAXSIZE = 10

# 定义可以重定向请求的最长时间。超过此最大值后，将按原样返回请求的响应
#REDIRECT_MAX_TIMES = 20

# 调整重定向请求的优先级，为正则优先级高
#REDIRECT_PRIORITY_ADJUST = 2

# 调整重试请求的优先级
#RETRY_PRIORITY_ADJUST = -1

# 是否遵循robot协议
ROBOTSTXT_OBEY = False

# 用于解析robots.txt文件的解析器后端
#ROBOTSTXT_PARSER = 'scrapy.robotstxt.ProtegoRobotParser'

#ROBOTSTXT_USER_AGENT = None

# 用于爬网的调度程序
#SCHEDULER = 'scrapy.core.scheduler.Scheduler'

# 设置为True将记录有关请求调度程序的调试信息
#SCHEDULER_DEBUG = False

# 调度程序将使用的磁盘队列的类型。其他可用类型：scrapy.squeues.PickleFifoDiskQueue，
# scrapy.squeues.MarshalFifoDiskQueue， scrapy.squeues.MarshalLifoDiskQueue
#SCHEDULER_DISK_QUEUE = 'scrapy.squeues.PickleLifoDiskQueue'

# 调度程序使用的内存队列的类型。其他可用类型： scrapy.squeues.FifoMemoryQueue
#SCHEDULER_MEMORY_QUEUE = 'scrapy.squeues.LifoMemoryQueue'

# 调度程序使用的优先级队列的类型。另一种可用的类型是 scrapy.pqueues.DownloaderAwarePriorityQueue
#SCHEDULER_PRIORITY_QUEUE = 'scrapy.pqueues.ScrapyPriorityQueue'

# 正在处理响应数据的软限制（以字节为单位）。
# 如果所有正在处理的响应的大小总和高于此值，Scrapy不会处理新的请求
#SCRAPER_SLOT_MAX_ACTIVE_SIZE  = 5_000_000

# 包含您的项目中启用的蜘蛛合约的字典，用于测试蜘蛛
#SPIDER_CONTRACTS = {}

# 包含Scrapy合同中默认启用的Scrapy合同的字典
#SPIDER_CONTRACTS_BASE  = {
#     'scrapy.contracts.default.UrlContract' : 1,
#     'scrapy.contracts.default.ReturnsContract': 2,
#     'scrapy.contracts.default.ScrapesContract': 3,
# }

# 将用于加载蜘蛛的类
#SPIDER_LOADER_CLASS = 'scrapy.spiderloader.SpiderLoader'

# 包含您的项目中启用的蜘蛛中间件及其命令的字典
#SPIDER_MIDDLEWARES = {}

#SPIDER_MIDDLEWARES_BASE = {
#     'scrapy.spidermiddlewares.httperror.HttpErrorMiddleware': 50,
#     'scrapy.spidermiddlewares.offsite.OffsiteMiddleware': 500,
#     'scrapy.spidermiddlewares.referer.RefererMiddleware': 700,
#     'scrapy.spidermiddlewares.urllength.UrlLengthMiddleware': 800,
#     'scrapy.spidermiddlewares.depth.DepthMiddleware': 900,
# }

# Scrapy将在其中寻找蜘蛛的模板列表
#SPIDER_MODULES  = {}

# 用于收集统计信息的类
#STATS_CLASS = 'scrapy.statscollectors.MemoryStatsCollector'

# 蜘蛛完成后，将Scrapy统计信息转储到Scrapy日志中
#STATS_DUMP = True

# 蜘蛛抓取完毕后发送Scrapy统计信息的邮箱列表
#STATSMAILER_RCPTS = []

# 指定是否 将启用telnet控制台
#TELNETCONSOLE_ENABLED = True

# 用于telnet控制台的端口范围。如果设置为None或0，则使用动态分配的端口
#TELNETCONSOLE_PORT = [6023, 6073]

# 使用startproject命令创建新项目和使用 genspider命令创建新的Spider时要在其中查找模板的目录
#TEMPLATES_DIR = "templates"

# 允许抓取的URL的最大URL长度
#URLLENGTH_LIMIT = 2083

# 爬网时使用的默认User-Agent
#USER_AGENT = "Scrapy/VERSION (+https://scrapy.org)"

默认： True

是否启用cookiesmiddleware。如果关闭，cookies将不会发送给web server。

COOKIES_DEBUG

默认： False

如果启用，Scrapy将记录所有在request(cookie 请求头)发送的cookies及response接收到的cookies（set-cookie接收头）

使用Scrapy的时候需要Cookies，就不能把Cookies放在Headers里面。在Scrapy发起请求的时候，有一个单独的参数来设置Cookies：

yield scrapy.Request(url,
                     callback=self.xxx,
                     headers=headers,
                     cookies={'uid': '123456',
                              'sessionId': '2437917172341832984120934'})

并且， cookies参数的值为一个字典，需要把原来Chrome中的字符串Cookies，先按分号分为不同的段，每一段再根据等号拆分为key和value。

pip install  scrapyd  scrapyd-client  scrapydweb

2. 运行scrapyd

#新的cmd中 运行

scrapyd

3. 修改scrapy 项目参数

# Automatically created by: scrapy startproject
#
# For more information about the [deploy] section see:
# https://scrapyd.readthedocs.io/en/latest/deploy.html

[settings]
default = scrapyRabbitmq.settings

[deploy]
url = http://127.0.0.1:6800/   #取消注释
project = scrapyRabbitmq

4. curl 添加项目

# 在项目目录下执行 scrapyd-deploy

scrapyd-deploy

5. 运行spider

curl http://localhost:6800/schedule.json -d project=scrapyRabbitmq -d spider=shopee-sg-comment

6. 取消spider运行

curl http://localhost:6800/cancel.json -d project=scrapyRabbitmq -d job=514e53dcbcd911eaa6c6e0d55eec7705

7.其他操作

删除scrapy项目
curl http://localhost:6800/delproject.json -d project=scrapy项目名称(要先停止)

查看有多少个scrapy项目在api中

curl http://localhost:6800/listprojects.json

1、获取状态
http://127.0.0.1:6800/daemonstatus.json
2、获取项目列表
http://127.0.0.1:6800/listprojects.json
3、获取项目下已发布的爬虫列表
http://127.0.0.1:6800/listspiders.json?project=myproject
4、获取项目下已发布的爬虫版本列表
http://127.0.0.1:6800/listversions.json?project=myproject
5、获取爬虫运行状态
http://127.0.0.1:6800/listjobs.json?project=myproject
6、启动服务器上某一爬虫（必须是已发布到服务器的爬虫）
http://127.0.0.1:6800/schedule.json （post方式，data={"project":myproject,"spider":myspider}）
7、删除某一版本爬虫
http://127.0.0.1:6800/delversion.json
（post方式，data={"project":myproject,"version":myversion}）
8、删除某一工程，包括该工程下的各版本爬虫

http://127.0.0.1:6800/delproject.json（post方式，data={"project":myproject}）

/usr/local/bin/scrapyd-deploy:23: ScrapyDeprecationWarning: Module `scrapy.utils.http` is deprecated, Please import from `w3lib.http` instead.
from scrapy.utils.http import basic_auth_header
Error: no Scrapy project found in this location

#!d:\python37\python.exe

import sys
import os
import glob
import tempfile
import shutil
import time
from six.moves.urllib.request import (build_opener, install_opener,
                                      HTTPRedirectHandler as UrllibHTTPRedirectHandler,
                                      Request, urlopen)
from six.moves.urllib.error import HTTPError, URLError
import netrc
import json
from optparse import OptionParser
from six.moves.urllib.parse import urlparse, urljoin
from subprocess import Popen, PIPE, check_call

from w3lib.form import encode_multipart
import setuptools # not used in code but needed in runtime, don't remove!

from scrapy.utils.project import inside_project
#from scrapy.utils.http import basic_auth_header  #注释此行
from w3lib.http import basic_auth_header  #增加此行
from scrapy.utils.python import retry_on_eintr
from scrapy.utils.conf import get_config, closest_scrapy_cfg

............................

1. 编写自己的包项目

自行百度

2. 配置 .pypirc

路径 $HOME.pypirc

[distutils]
index-servers=pypi
[pypi]
repository = https://upload.pypi.org/legacy/
username = pypi.org 登录名
password = pypi.org 登陆密码

3. 编译包

生成tar.gz 和 egg

# 生成 tar.gz

python setup.py sdist

# 生成 egg
python setup.py bdist_egg

4. 上传包

使用 setup 上传

# 上传source 包
python setup.py sdist upload

# 上传egg包
python setup.py bdist_egg upload

或者使用 twine 上传

twine upload dist/*

上传生成的包，可以使用setuptools,或者twine上传,推荐使用twine上次，因为使用setuptools上传时，你的用户名和密码是明文或者未加密传输，安全起见还是使用twine吧。

Pandas 是 Python 中处理数据的首选库，它使用起来很容易，非常灵活，能够处理不同类型和大小的数据，而且它有大量的函数，这让操作数据简直是小菜一碟。

Pandas 基础之旅

用 Python 处理过数据的人大概对 pandas 不陌生。

如果想处理行或列排序的格式化数据，大多数情况下，你可以使用 pandas 处理。如果没安装 pandas，可以用你喜欢的命令终端安装，一定要用 pip 命令：

pip install pandas

现在，让我们看看默认的 pandas 实现都可以做什么：

非常简洁，但也很平淡无奇，“method”这列去哪儿？

我们解释一下上面代码和输出的含义：

Pandas 的任何“数据帧”都有一个 describe() 方法，这个方法会返回上面的输出。但请注意，这个方法的以上输出数据中，关于类别的变量漏掉了。在上面的例子中，输出信息里，“method”这一列被完全移除。

让我们看看是否能做得更好。

Pandas 剖析

这仅仅是剖析报告的开头部分

如果我告诉你，我仅用 3 行 Python 代码即可生成以下统计数据，你会感觉如何（如果不算 imports 语句的话，实际上只需要 1 行代码即可）：

• 核心信息：类型、唯一值、缺失值
• 分位数统计：如最小值、Q1、中位数、Q3、最大值、范围、四分位数范围等
• 描述性统计：如平均值、众数、标准差、求和、中位数绝对偏差、扰动系数、峰度、偏度等
• 高频使用的数值
• 直方图
• 相关性：会突出显示高相关度变量、Spearman、Pearson 和 Kendall 矩阵
• 缺失值：矩阵、计数、热力图和缺失值树状图

（以上特征列表直接摘自 Pandas Profiling GitHub 页面）

使用 Pandas Profiling 包，我们仅用 1 行代码就可以得到以上数据！在命令行终端只需使用 pip 即可安装 Pandas Profiling 包：

pip install pandas_profiling

乍一看，经验丰富的数据分析师可能会嘲笑这是华而不实的，但是，它可以帮助你快速获得你拥有的数据概况：

看到了吗，正如我所说，1 行代码搞定！

你看到的第一部分内容是“概览”（请看上图），这部分内容会呈现给你一些非常高级的数据和变量统计，以及像变量高相关性和高偏态性等这类警告。

但是它提供的信息远远不止这些。往下滑动，我们会发现这份输出报告包含多个部分。仅用图片显示这个 1 行代码的输出都是不大合适的，所以我制作了一张 GIF 图：

我强烈建议你自己来探索这个软件包里的特色——毕竟，这只有 1 行代码，而且你会在以后的数据分析中发现这个软件包真的很好用。

import pandas as pd
import pandas_profiling
pd.read_csv('https://raw.githubusercontent.com/mwaskom/seaborn-data/master/planets.csv').profile_report()

更多类似的代码库

如果你喜欢使用这些易用的东西来改进你的 Python 工作流，可以看看我的一些最新文章。

最后的思考

这篇文章真的很短小。我自己才刚刚发现 Pandas Profiling 这个库，觉得可以拿来分享！

原文链接：

Exploring your data with just 1 line of Python