使用 Pyramid 和 Cornice 构建和描述可扩展的 RESTful Web 服务。

Python 是一种高级的、面向对象的编程语言，它以其简单的语法而闻名。它一直是构建 RESTful API 的顶级编程语言之一。

Pyramid 是一个 Python Web 框架，旨在随着应用的扩展而扩展：这可以让简单的应用很简单，也可以增长为大型、复杂的应用。此外，Pyramid 为 PyPI （Python 软件包索引）提供了强大的支持。Cornice 为使用 Pyramid 构建和描述 RESTful Web 服务提供了助力。

本文将使用 Web 服务的例子来获取名人名言，来展示如何使用这些工具。

建立 Pyramid 应用

首先为你的应用创建一个虚拟环境，并创建一个文件来保存代码：

$ mkdir tutorial
$ cd tutorial
$ touch main.py
$ python3 -m venv env
$ source env/bin/activate
(env) $ pip3 install cornice twisted

导入 Cornice 和 Pyramid 模块

使用以下命令导入这些模块：

from pyramid.config import Configurator
from cornice import Service

定义服务

将引用服务定义为 Service 对象：

QUOTES = Service(name='quotes',
                 path='/',
                 description='Get quotes')

编写引用逻辑

到目前为止，这仅支持获取名言。用 QUOTES.get 装饰函数。这是将逻辑绑定到 REST 服务的方法：

@QUOTES.get()
def get_quote(request):
    return {
        'William Shakespeare': {
            'quote': ['Love all, trust a few, do wrong to none',
            'Some are born great, some achieve greatness, and some have greatness thrust upon them.']
    },
    'Linus': {
        'quote': ['Talk is cheap. Show me the code.']
        }
    }

请注意，与其他框架不同，装饰器不会更改 get_quote 函数。如果导入此模块，你仍然可以定期调用该函数并检查结果。

在为 Pyramid RESTful 服务编写单元测试时，这很有用。

定义应用对象

最后，使用 scan 查找所有修饰的函数并将其添加到配置中：

with Configurator() as config:
    config.include("cornice")
    config.scan()
    application = config.make_wsgi_app()

默认扫描当前模块。如果要扫描软件包中的所有模块，你也可以提供软件包的名称。

运行服务

我使用 Twisted 的 WSGI 服务器运行该应用，但是如果需要，你可以使用任何其他 WSGI 服务器，例如 Gunicorn 或 uWSGI。

(env)$ python -m twisted web --wsgi=main.application

默认情况下，Twisted 的 WSGI 服务器运行在端口 8080 上。你可以使用 HTTPie 测试该服务：

(env) $ pip install httpie
...
(env) $ http GET <http://localhost:8080/>
HTTP/1.1 200 OK
Content-Length: 220
Content-Type: application/json
Date: Mon, 02 Dec 2019 16:49:27 GMT
Server: TwistedWeb/19.10.0
X-Content-Type-Options: nosniff

{
    "Linus": {
        "quote": [
            "Talk is cheap. Show me the code."
        ]
    },
    "William Shakespeare": {
        "quote": [
            "Love all,trust a few,do wrong to none",
            "Some are born great, some achieve greatness, and some greatness thrust upon them."
        ]
    }
}

为什么要使用 Pyramid？

Pyramid 并不是最受欢迎的框架，但它已在 PyPI 等一些引人注目的项目中使用。我喜欢 Pyramid，因为它是认真对待单元测试的框架之一：因为装饰器不会修改函数并且没有线程局部变量，所以可以直接从单元测试中调用函数。例如，需要访问数据库的函数将从通过 request.config 传递的 request.config 对象中获取它。这允许单元测试人员将模拟（或真实）数据库对象放入请求中，而不用仔细设置全局变量、线程局部变量或其他特定于框架的东西。

如果你正在寻找一个经过测试的库来构建你接下来的 API，请尝试使用 Pyramid。你不会失望的。

via: https://opensource.com/article/20/1/python-web-api-pyramid-cornice

作者：Moshe Zadka 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

Zope.interface 可以帮助声明存在哪些接口，是由哪些对象提供的，以及如何查询这些信息。

zope.interface 库可以克服 Python 接口设计中的歧义性。让我们来研究一下。

隐式接口不是 Python 之禅

Python 之禅 很宽松，但是有点自相矛盾，以至于你可以用它来例证任何东西。让我们来思考其中最著名的原则之一：“显示胜于隐式”。

传统上，在 Python 中会隐含的一件事是预期的接口。比如函数已经记录了它期望一个“类文件对象”或“序列”。但是什么是类文件对象呢？它支持 .writelines吗？.seek 呢？什么是一个“序列”？是否支持步进切片，例如 a[1:10:2]？

最初，Python 的答案是所谓的“鸭子类型”，取自短语“如果它像鸭子一样行走，像鸭子一样嘎嘎叫，那么它可能就是鸭子”。换句话说，“试试看”，这可能是你能得到的最具隐式的表达。

为了使这些内容显式地表达出来，你需要一种方法来表达期望的接口。Zope Web 框架是最早用 Python 编写的大型系统之一，它迫切需要这些东西来使代码明确呈现出来，例如，期望从“类似用户的对象”获得什么。

zope.interface 由 Zope 开发，但作为单独的 Python 包发布。Zope.interface 可以帮助声明存在哪些接口，是由哪些对象提供的，以及如何查询这些信息。

想象编写一个简单的 2D 游戏，它需要各种东西来支持精灵界面（LCTT 译注：“ 精灵 Sprite ”是指游戏面板中各个组件）。例如，表示一个边界框，但也要表示对象何时与一个框相交。与一些其他语言不同，在 Python 中，将属性访问作为公共接口一部分是一种常见的做法，而不是实现 getter 和 setter。边界框应该是一个属性，而不是一个方法。

呈现精灵列表的方法可能类似于：

def render_sprites(render_surface, sprites):
    """
    sprites 应该是符合 Sprite 接口的对象列表：
    * 一个名为 "bounding_box" 的属性，包含了边界框
    * 一个名为 "intersects" 的方法，它接受一个边界框并返回 True 或 False
    """
    pass # 一些做实际渲染的代码

该游戏将具有许多处理精灵的函数。在每个函数中，你都必须在随附文档中指定预期。

此外，某些函数可能期望使用更复杂的精灵对象，例如具有 Z 序的对象。我们必须跟踪哪些方法需要 Sprite 对象，哪些方法需要 SpriteWithZ 对象。

如果能够使精灵是显式而直观的，这样方法就可以声明“我需要一个精灵”，并有个严格定义的接口，这不是很好吗？来看看 zope.interface。

from zope import interface

class ISprite(interface.Interface):

    bounding_box = interface.Attribute(
        "边界框"
    )

    def intersects(box):
        "它和一个框相交吗？"

乍看起来，这段代码有点奇怪。这些方法不包括 self，而包含 self 是一种常见的做法，并且它有一个属性。这是在 zope.interface 中声明接口的方法。这看起来很奇怪，因为大多数人不习惯严格声明接口。

这样做的原因是接口显示了如何调用方法，而不是如何定义方法。因为接口不是超类，所以它们可以用来声明数据属性。

下面是一个能带有圆形精灵的接口的一个实现：

@implementer(ISprite)
@attr.s(auto_attribs=True)
class CircleSprite:
    x: float
    y: float
    radius: float

    @property
    def bounding_box(self):
        return (
            self.x - self.radius,
            self.y - self.radius,
            self.x + self.radius,
            self.y + self.radius,
        )

    def intersects(self, box):
        # 当且仅当至少一个角在圆内时，方框与圆相交
        top_left, bottom_right = box[:2], box[2:]
        for choose_x_from (top_left, bottom_right):
            for choose_y_from (top_left, bottom_right):
                x = choose_x_from[0]
                y = choose_y_from[1]
                if (((x - self.x) ` 2 + (y - self.y) ` 2) <=
                    self.radius ` 2):
                     return True
        return False

这显式声明了实现了该接口的 CircleSprite 类。它甚至能让我们验证该类是否正确实现了接口：

from zope.interface import verify

def test_implementation():
    sprite = CircleSprite(x=0, y=0, radius=1)
    verify.verifyObject(ISprite, sprite)

这可以由 pytest、nose 或其他测试框架运行，它将验证创建的精灵是否符合接口。测试通常是局部的：它不会测试仅在文档中提及的内容，甚至不会测试方法是否可以在没有异常的情况下被调用！但是，它会检查是否存在正确的方法和属性。这是对单元测试套件一个很好的补充，至少可以防止简单的拼写错误通过测试。

via: https://opensource.com/article/19/9/zopeinterface-python-package

作者：Moshe Zadka 选题：lujun9972 译者：MjSeven 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

欢迎阅读“Python 光明节（Pythonukkah）”系列文章，这个系列文章将会讨论《Python 之禅》。我们首先来看《Python 之禅》里的前两个原则：美观与明确。

早在 1999 年，Python 的贡献者之一，Tim Peters 就提出了《Python 之禅》，直到二十年后的今天，《Python 之禅》中的 19 条原则仍然对整个社区都产生着深远的影响。为此，就像庆典光明的 光明节 Hanukkah 一样，我们举行了这一次的“ Python 光明节 Pythonukkah ”。首先，我们会讨论《Python 之禅》中的前两个原则：美观和明确。

“Hanukkah is the Festival of Lights,

Instead of one day of presents, we get eight crazy nights.”

—亚当·桑德勒，光明节之歌

美观胜于丑陋 （ Beautiful is better than ugly ）

著名的《 计算机程序的构造和解释 Structure and Interpretation of Computer Programs 》中有这么一句话： 代码是写给人看的，只是恰好能让机器运行。 Programs must be written for people to read and only incidentally for machines to execute. 机器并不在乎代码的美观性，但人类在乎。

阅读美观的代码对人们来说是一种享受，这就要求在整套代码中保持一致的风格。使用诸如 Black、flake8、Pylint 这一类工具能够有效地接近这一个目标。

但实际上，只有人类自己才知道什么才是真正的美观。因此，代码审查和协同开发是其中的不二法门，同时，在开发过程中倾听别人的意见也是必不可少的。

最后，个人的主观能动性也很重要，否则一切工具和流程都会变得毫无意义。只有意识到美观的重要性，才能主动编写出美观的代码。

这就是为什么美观在众多原则当中排到了首位，它让“美”成为了 Python 社区的一种价值。如果有人要问，”我们真的在乎美吗？“社区会以代码给出肯定的答案。

明确胜于隐晦 （ Explicit is better than implicit ）

人类会欢庆光明、惧怕黑暗，那是因为光能够让我们看到难以看清的事物。同样地，尽管有些时候我们会不自觉地把代码写得含糊不清，但明确地编写代码确实能够让我们理解很多抽象的概念。

“为什么类方法中要将 self 显式指定为第一个参数？”

这个问题已经是老生常谈了，但网络上很多流传已久的回答都是不准确的。在编写 元类 metaclass 时，显式指定 self 参数就显得毫无意义。如果你没有编写过元类，希望你可以尝试一下，这是很多 Python 程序员的必经之路。

显式指定 self 参数的原因并不是 Python 的设计者不想将这样的元类视为“默认”元类，而是因为第一个参数必须是显式的。

即使 Python 中确实允许非显式的情况存在（例如上下文变量），但我们还是应该提出疑问：某个东西是不是有存在的必要呢？如果非显式地传递参数会不会出现问题呢？有些时候，由于种种原因，这是会有问题的。总之，在写代码时一旦能够优先考虑到明确性，至少意味着能对不明确的地方提出疑问并对结果作出有效的估计。

via: https://opensource.com/article/19/12/zen-python-beauty-clarity

作者：Moshe Zadka 选题：lujun9972 译者：HankChow 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

将一个 awk 脚本移植到 Python 主要在于代码风格而不是转译。

脚本是解决问题的有效方法，而 awk 是编写脚本的出色语言。它特别擅长于简单的文本处理，它可以带你完成配置文件的某些复杂重写或目录中文件名的重新格式化。

何时从 awk 转向 Python

但是在某些方面，awk 的限制开始显现出来。它没有将文件分解为模块的真正概念，它缺乏质量错误报告，并且缺少了现在被认为是编程语言工作原理的其他内容。当编程语言的这些丰富功能有助于维护关键脚本时，移植将是一个不错的选择。

我最喜欢的完美移植 awk 的现代编程语言是 Python。

在将 awk 脚本移植到 Python 之前，通常值得考虑一下其原始使用场景。例如，由于 awk 的局限性，通常从 Bash 脚本调用 awk 代码，其中包括一些对 sed、sort 之类的其它命令行常见工具的调用。 最好将所有内容转换为一个一致的 Python 程序。有时，脚本会做出过于宽泛的假设，例如，即使实际上只运行一个文件，该代码也可能允许任意数量的文件。

在仔细考虑了上下文并确定了要用 Python 替代的东西之后，该编写代码了。

标准 awk 到 Python 功能

以下 Python 功能是有用的，需要记住：

with open(some_file_name) as fpin:
    for line in fpin:
        pass # do something with line

此代码将逐行循环遍历文件并处理这些行。

如果要访问行号（相当于 awk 的 NR），则可以使用以下代码：

with open(some_file_name) as fpin:
    for nr, line in enumerate(fpin):
        pass # do something with line

在 Python 中实现多文件的 awk 式行为

如果你需要能够遍历任意数量的文件同时保持行数的持续计数（类似 awk 的 FNR），则此循环可以做到这一点：

def awk_like_lines(list_of_file_names):
    def _all_lines():
        for filename in list_of_file_names:
            with open(filename) as fpin:
                yield from fpin
    yield from enumerate(_all_lines())

此语法使用 Python 的生成器和 yield from 来构建迭代器，该迭代器将遍历所有行并保持一个持久计数。

如果你需要同时使用 FNR 和 NR，这是一个更复杂的循环：

def awk_like_lines(list_of_file_names):
    def _all_lines():
        for filename in list_of_file_names:
            with open(filename) as fpin:
                yield from enumerate(fpin)
    for nr, (fnr, line) in _all_lines:
        yield nr, fnr, line

更复杂的 FNR、NR 和行数的 awk 行为

如果 FNR、NR 和行数这三个你全都需要，仍然会有一些问题。如果确实如此，则使用三元组（其中两个项目是数字）会导致混淆。命名参数可使该代码更易于阅读，因此最好使用 dataclass：

import dataclass

@dataclass.dataclass(frozen=True)
class AwkLikeLine:
    content: str
    fnr: int
    nr: int

def awk_like_lines(list_of_file_names):
    def _all_lines():
        for filename in list_of_file_names:
            with open(filename) as fpin:
                yield from enumerate(fpin)
    for nr, (fnr, line) in _all_lines:
        yield AwkLikeLine(nr=nr, fnr=fnr, line=line)

你可能想知道，为什么不一直用这种方法呢？使用其它方式的的原因是总用这种方法太复杂了。如果你的目标是把一个通用库更容易地从 awk 移植到 Python，请考虑这样做。但是编写一个可以使你确切地了解特定情况所需的循环的方法通常更容易实现，也更容易理解（因而易于维护）。

理解 awk 字段

一旦有了与一行相对应的字符串，如果要转换 awk 程序，则通常需要将其分解为字段。Python 有几种方法可以做到这一点。这将把行按任意数量的连续空格拆分，返回一个字符串列表：

line.split()

如果需要另一个字段分隔符，比如以 : 分隔行，则需要 rstrip 方法来删除最后一个换行符：

line.rstrip("\n").split(":")

完成以下操作后，列表 parts 将存有分解的字符串：

parts = line.rstrip("\n").split(":")

这种拆分非常适合用来处理参数，但是我们处于偏差一个的错误场景中。现在 parts[0] 将对应于 awk 的 $1，parts[1] 将对应于 awk 的 $2，依此类推。之所以偏差一个，是因为 awk 计数“字段”从 1 开始，而 Python 从 0 开始计数。在 awk 中，$0 是整个行 —— 等同于 line.rstrip("\n")，而 awk 的 NF（字段数）更容易以 len(parts) 的形式得到。

移植 awk 字段到 Python

例如，让我们将这个单行代码“如何使用 awk 从文件中删除重复行”转换为 Python。

awk 中的原始代码是：

awk '!visited[$0]++' your_file > deduplicated_file

“真实的” Python 转换将是：

import collections
import sys

visited = collections.defaultdict(int)
for line in open("your_file"):
    did_visit = visited[line]
    visited[line] += 1
    if not did_visit:
        sys.stdout.write(line)

但是，Python 比 awk 具有更多的数据结构。与其计数访问次数（除了知道是否看到一行，我们不使用它），为什么不记录访问的行呢？

import sys

visited = set()
for line in open("your_file"):
    if line in visited:
        continue
    visited.add(line)
    sys.stdout.write(line)

编写 Python 化的 awk 代码

Python 社区提倡编写 Python 化的代码，这意味着它要遵循公认的代码风格。更加 Python 化的方法将区分唯一性和输入/输出的关注点。此更改将使对代码进行单元测试更加容易：

def unique_generator(things):
    visited = set()
    for thing in things:
        if thing in visited:
            continue
        visited.add(things)
        yield thing

import sys
   
for line in unique_generator(open("your_file")):
    sys.stdout.write(line)

将所有逻辑置于输入/输出代码之外，可以更好地分离问题，并提高代码的可用性和可测试性。

结论：Python 可能是一个不错的选择

将 awk 脚本移植到 Python 时，通常是在考虑适当的 Python 代码风格时重新实现核心需求，而不是按条件/操作进行笨拙的音译。考虑原始上下文并产生高质量的 Python 解决方案。虽然有时候使用 awk 的 Bash 单行代码可以完成这项工作，但 Python 编码是通往更易于维护的代码的途径。

另外，如果你正在编写 awk 脚本，我相信您也可以学习 Python！如果你有任何疑问，请告诉我。

via: https://opensource.com/article/19/11/awk-to-python

作者：Moshe Zadka 选题：lujun9972 译者：wxy 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

最好将文档作为开发过程的一部分。Sphinx 加上 Tox，让文档可以轻松书写，并且外观漂亮。

Python 代码可以在源码中包含文档。这种方式默认依靠 docstring，它以三引号格式定义。虽然文档的价值是很大的，但是没有充足的文档的代码还是很常见。让我们演练一个场景，了解出色的文档的强大功能。

经历了太多在白板技术面试上要求你实现斐波那契数列，你已经受够了。你回家用 Python 写了一个可重用的斐波那契计算器，使用浮点技巧来实现 O(1) 复杂度。

代码很简单：

# fib.py
import math

_SQRT_5 = math.sqrt(5)
_PHI = (1 + _SQRT_5) / 2

def approx_fib(n):
    return round(_PHI**(n+1) / _SQRT_5)

（该斐波那契数列是四舍五入到最接近的整数的几何序列，这是我最喜欢的鲜为人知的数学事实之一。）

作为一个好人，你可以将代码开源，并将它放在 PyPI 上。setup.py 文件很简单：

import setuptools

setuptools.setup(
    name='fib',
    version='2019.1.0',
    description='Fibonacci',
    py_modules=["fib"],
)

但是，没有文档的代码是没有用的。因此，你可以向函数添加 docstring。我最喜欢的 docstring 样式之一是 “Google” 样式。标记很轻量，当它放在源代码中时很好。

def approx_fib(n):
    """
    Approximate Fibonacci sequence

    Args:
        n (int): The place in Fibonacci sequence to approximate

    Returns:
        float: The approximate value in Fibonacci sequence
    """
    # ...

但是函数的文档只是成功的一半。普通文档对于情境化代码用法很重要。在这种情况下，情景是恼人的技术面试。

有一种添加更多文档的方式，专业 Python 人的方式通常是在 docs/ 添加 rst 文件（ reStructuredText 的缩写）。因此 docs/index.rst 文件最终看起来像这样：

Fibonacci
=========

Are you annoyed at tech interviewers asking you to implement
the Fibonacci sequence?
Do you want to have some fun with them?
A simple
:code:`pip install fib`
is all it takes to tell them to,
um,
fib off.

.. automodule:: fib
   :members:

我们完成了，对吧？我们已经将文本放在了文件中。人们应该会看的。

使 Python 文档更漂亮

为了使你的文档看起来更漂亮，你可以利用 Sphinx，它旨在制作漂亮的 Python 文档。这三个 Sphinx 扩展特别有用：

• sphinx.ext.autodoc：从模块内部获取文档
• sphinx.ext.napoleon：支持 Google 样式的 docstring
• sphinx.ext.viewcode：将 ReStructured Text 源码与生成的文档打包在一起

为了告诉 Sphinx 该生成什么以及如何生成，我们在 docs/conf.py 中配置一个辅助文件：

extensions = [
    'sphinx.ext.autodoc',
    'sphinx.ext.napoleon',
    'sphinx.ext.viewcode',
]
# 该入口点的名称，没有 .rst 扩展名。
# 惯例该名称是 index
master_doc = "index"
# 这些值全部用在生成的文档当中。
# 通常，发布（release）与版本（version）是一样的，
# 但是有时候我们会有带有 rc 标签的发布。
project = "Fib"
copyright = "2019, Moshe Zadka"
author = "Moshe Zadka"
version = release = "2019.1.0"

此文件使我们可以使用所需的所有元数据来发布代码，并注意扩展名（上面的注释说明了方式）。最后，要确保生成我们想要的文档，请使用 Tox 管理虚拟环境以确保我们顺利生成文档：

[tox]
# 默认情况下，`.tox` 是该目录。
# 将其放在非点文件中可以从
# 文件管理器或浏览器的
# 打开对话框中打开生成的文档，
# 这些对话框有时会隐藏点文件。
toxworkdir = {toxinidir}/build/tox

[testenv:docs]
# 从 `docs` 目录内运行 `sphinx`，
# 以确保它不会拾取任何可能进入顶层目录下的
# 虚拟环境或 `build/` 目录下的其他工件的杂散文件。
changedir = docs
# 唯一的依赖关系是 `sphinx`。
# 如果我们使用的是单独打包的扩展程序，
# 我们将在此处指定它们。
# 更好的做法是指定特定版本的 sphinx。
deps =
    sphinx
# 这是用于生成 HTML 的 `sphinx` 命令。
# 在其他情况下，我们可能想生成 PDF 或电子书。
commands =
    sphinx-build -W -b html -d {envtmpdir}/doctrees . {envtmpdir}/html
# 我们使用 Python 3.7。
# Tox 有时会根据 testenv 的名称尝试自动检测它，
# 但是 `docs` 没有给出有用的线索，因此我们必须明确它。
basepython = python3.7

现在，无论何时运行 Tox，它都会为你的 Python 代码生成漂亮的文档。

在 Python 中写文档很好

作为 Python 开发人员，我们可以使用的工具链很棒。我们可以从 docstring 开始，添加 .rst 文件，然后添加 Sphinx 和 Tox 来为用户美化结果。

你对好的文档有何评价？你还有其他喜欢的方式么？请在评论中分享它们！

via: https://opensource.com/article/19/11/document-python-sphinx

作者：Moshe Zadka 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

当你想要争论代码复杂性时，Pylint 是你的朋友。

in VIM")

Pylint 是更高层级的 Python 样式强制程序。而 flake8 和 black 检查的是“本地”样式：换行位置、注释的格式、发现注释掉的代码或日志格式中的错误做法之类的问题。

默认情况下，Pylint 非常激进。它将对每样东西都提供严厉的意见，从检查是否实际实现声明的接口到重构重复代码的可能性，这对新用户来说可能会很多。一种温和地将其引入项目或团队的方法是先关闭所有检查器，然后逐个启用检查器。如果你已经在使用 flake8、black 和 mypy，这尤其有用：Pylint 有相当多的检查器和它们在功能上重叠。

但是，Pylint 独有之处之一是能够强制执行更高级别的问题：例如，函数的行数或者类中方法的数量。

这些数字可能因项目而异，并且可能取决于开发团队的偏好。但是，一旦团队就参数达成一致，使用自动工具强制化这些参数非常有用。这是 Pylint 闪耀的地方。

配置 Pylint

要以空配置开始，请将 .pylintrc 设置为

[MESSAGES CONTROL]

disable=all

这将禁用所有 Pylint 消息。由于其中许多是冗余的，这是有道理的。在 Pylint 中，message 是一种特定的警告。

你可以通过运行 pylint 来确认所有消息都已关闭：

$ pylint <my package>

通常，向 pylint 命令行添加参数并不是一个好主意：配置 pylint 的最佳位置是 .pylintrc。为了使它做一些有用的事，我们需要启用一些消息。

要启用消息，在 .pylintrc 中的 [MESSAGES CONTROL] 下添加

enable=<message>,
       ...

对于看起来有用的“消息”（Pylint 称之为不同类型的警告）。我最喜欢的包括 too-many-lines、too-many-arguments 和 too-many-branches。所有这些会限制模块或函数的复杂性，并且无需进行人工操作即可客观地进行代码复杂度测量。

检查器是消息的来源：每条消息只属于一个检查器。许多最有用的消息都在设计检查器下。默认数字通常都不错，但要调整最大值也很简单：我们可以在 .pylintrc 中添加一个名为 DESIGN 的段。

[DESIGN]
max-args=7
max-locals=15

另一个有用的消息来源是“重构”检查器。我已启用一些最喜欢的消息有 consider-using-dict-comprehension、stop-iteration-return（它会查找正确的停止迭代的方式是 return 而使用了 raise StopIteration 的迭代器）和 chained-comparison，它将建议使用如 1 <= x < 5，而不是不太明显的 1 <= x && 5 > 5 的语法。

最后是一个在性能方面消耗很大的检查器，但它非常有用，就是 similarities。它会查找不同部分代码之间的复制粘贴来强制执行“不要重复自己”（DRY 原则）。它只启用一条消息：duplicate-code。默认的 “最小相似行数” 设置为 4。可以使用 .pylintrc 将其设置为不同的值。

[SIMILARITIES]
min-similarity-lines=3

Pylint 使代码评审变得简单

如果你厌倦了需要指出一个类太复杂，或者两个不同的函数基本相同的代码评审，请将 Pylint 添加到你的持续集成配置中，并且只需要对项目复杂性准则的争论一次就行。

via: https://opensource.com/article/19/10/python-pylint-introduction

作者：Moshe Zadka 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出