标签 python 下的文章

检查你的代码的质量,通过这些外部库使其更易维护。

可读性很重要。
— Python 之禅 The Zen of Python ,Tim Peters

随着软件项目进入“维护模式”,对可读性和编码标准的要求很容易落空(甚至从一开始就没有建立过那些标准)。然而,在代码库中保持一致的代码风格和测试标准能够显著减轻维护的压力,也能确保新的开发者能够快速了解项目的情况,同时能更好地全程保持应用程序的质量。

使用外部库来检查代码的质量不失为保护项目未来可维护性的一个好方法。以下会推荐一些我们最喜爱的检查代码)(包括检查 PEP 8 和其它代码风格错误)的库,用它们来强制保持代码风格一致,并确保在项目成熟时有一个可接受的测试覆盖率。

检查你的代码风格

PEP 8 是 Python 代码风格规范,它规定了类似行长度、缩进、多行表达式、变量命名约定等内容。尽管你的团队自身可能也会有稍微不同于 PEP 8 的代码风格规范,但任何代码风格规范的目标都是在代码库中强制实施一致的标准,使代码的可读性更强、更易于维护。下面三个库就可以用来帮助你美化代码。

1、 Pylint

Pylint 是一个检查违反 PEP 8 规范和常见错误的库。它在一些流行的编辑器和 IDE 中都有集成,也可以单独从命令行运行。

执行 pip install pylint 安装 Pylint 。然后运行 pylint [options] path/to/dir 或者 pylint [options] path/to/module.py 就可以在命令行中使用 Pylint,它会向控制台输出代码中违反规范和出现错误的地方。

你还可以使用 pylintrc 配置文件来自定义 Pylint 对哪些代码错误进行检查。

2、 Flake8

Flake8 是“将 PEP 8、Pyflakes(类似 Pylint)、McCabe(代码复杂性检查器)和第三方插件整合到一起,以检查 Python 代码风格和质量的一个 Python 工具”。

执行 pip install flake8 安装 flake8 ,然后执行 flake8 [options] path/to/dir 或者 flake8 [options] path/to/module.py 可以查看报出的错误和警告。

和 Pylint 类似,Flake8 允许通过配置文件来自定义检查的内容。它有非常清晰的文档,包括一些有用的提交钩子,可以将自动检查代码纳入到开发工作流程之中。

Flake8 也可以集成到一些流行的编辑器和 IDE 当中,但在文档中并没有详细说明。要将 Flake8 集成到喜欢的编辑器或 IDE 中,可以搜索插件(例如 Sublime Text 的 Flake8 插件)。

3、 Isort

Isort 这个库能将你在项目中导入的库按字母顺序排序,并将其正确划分为不同部分(例如标准库、第三方库、自建的库等)。这样提高了代码的可读性,并且可以在导入的库较多的时候轻松找到各个库。

执行 pip install isort 安装 isort,然后执行 isort path/to/module.py 就可以运行了。文档中还提供了更多的配置项,例如通过配置 .isort.cfg 文件来决定 isort 如何处理一个库的多行导入。

和 Flake8、Pylint 一样,isort 也提供了将其与流行的编辑器和 IDE 集成的插件。

分享你的代码风格

每次文件发生变动之后都用命令行手动检查代码是一件痛苦的事,你可能也不太喜欢通过运行 IDE 中某个插件来实现这个功能。同样地,你的同事可能会用不同的代码检查方式,也许他们的编辑器中也没有那种插件,甚至你自己可能也不会严格检查代码和按照警告来更正代码。总之,你分享出来的代码库将会逐渐地变得混乱且难以阅读。

一个很好的解决方案是使用一个库,自动将代码按照 PEP 8 规范进行格式化。我们推荐的三个库都有不同的自定义级别来控制如何格式化代码。其中有一些设置较为特殊,例如 Pylint 和 Flake8 ,你需要先行测试,看看是否有你无法忍受但又不能修改的默认配置。

4、 Autopep8

Autopep8 可以自动格式化指定的模块中的代码,包括重新缩进行、修复缩进、删除多余的空格,并重构常见的比较错误(例如布尔值和 None 值)。你可以查看文档中完整的更正列表。

运行 pip install --upgrade autopep8 安装 Autopep8。然后执行 autopep8 --in-place --aggressive --aggressive <filename> 就可以重新格式化你的代码。aggressive 选项的数量表示 Auotopep8 在代码风格控制上有多少控制权。在这里可以详细了解 aggressive 选项。

5、 Yapf

Yapf 是另一种有自己的配置项列表的重新格式化代码的工具。它与 Autopep8 的不同之处在于它不仅会指出代码中违反 PEP 8 规范的地方,还会对没有违反 PEP 8 但代码风格不一致的地方重新格式化,旨在令代码的可读性更强。

执行 pip install yapf 安装 Yapf,然后执行 yapf [options] path/to/dir 或 yapf [options] path/to/module.py 可以对代码重新格式化。定制选项的完整列表在这里。

6、 Black

Black 在代码检查工具当中算是比较新的一个。它与 Autopep8 和 Yapf 类似,但限制较多,没有太多的自定义选项。这样的好处是你不需要去决定使用怎么样的代码风格,让 Black 来给你做决定就好。你可以在这里查阅 Black 有限的自定义选项以及如何在配置文件中对其进行设置。

Black 依赖于 Python 3.6+,但它可以格式化用 Python 2 编写的代码。执行 pip install black 安装 Black,然后执行 black path/to/dir 或 black path/to/module.py 就可以使用 Black 优化你的代码。

检查你的测试覆盖率

如果你正在进行编写测试,你需要确保提交到代码库的新代码都已经测试通过,并且不会降低测试覆盖率。虽然测试覆盖率不是衡量测试有效性和充分性的唯一指标,但它是确保项目遵循基本测试标准的一种方法。对于计算测试覆盖率,我们推荐使用 Coverage 这个库。

7、 Coverage

Coverage 有数种显示测试覆盖率的方式,包括将结果输出到控制台或 HTML 页面,并指出哪些具体哪些地方没有被覆盖到。你可以通过配置文件自定义 Coverage 检查的内容,让你更方便使用。

执行 pip install coverage 安装 Converage 。然后执行 coverage [path/to/module.py] [args] 可以运行程序并查看输出结果。如果要查看哪些代码行没有被覆盖,执行 coverage report -m 即可。

持续集成工具

持续集成 Continuous integration (CI)是在合并和部署代码之前自动检查代码风格错误和测试覆盖率最小值的过程。很多免费或付费的工具都可以用于执行这项工作,具体的过程不在本文中赘述,但 CI 过程是令代码更易读和更易维护的重要步骤,关于这一部分可以参考 Travis CI 和 Jenkins。

以上这些只是用于检查 Python 代码的各种工具中的其中几个。如果你有其它喜爱的工具,欢迎在评论中分享。


via: https://opensource.com/article/18/7/7-python-libraries-more-maintainable-code

作者:Jeff Triplett 选题:lujun9972 译者:HankChow 校对:wxy

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

五分钟创建定制 GUI。

对于 .exe 类型的程序文件,我们可以通过双击鼠标左键打开;但对于 .py 类型的 Python 程序,几乎不会有人尝试同样的操作。对于一个(非程序员类型的)典型用户,他们双击打开 .exe 文件时预期弹出一个可以交互的窗体。基于 Tkinter,可以通过 标准 Python 安装 standard Python installations 的方式提供 GUI,但很多程序都不太可能这样做。

如果打开 Python 程序并进入 GUI 界面变得如此容易,以至于真正的初学者也可以掌握,会怎样呢?会有人感兴趣并使用吗?这个问题不好回答,因为直到今天创建自定义 GUI 布局仍不是件容易的事情。

在为程序或脚本增加 GUI 这件事上,似乎存在能力的“错配”。(缺乏这方面能力的)真正的初学者被迫只能使用命令行方式,而很多(具备这方面能力的)高级程序员却不愿意花时间创建一个 Tkinter GUI。

GUI 框架

Python 的 GUI 框架并不少,其中 Tkinter,wxPython,Qt 和 Kivy 是几种比较主流的框架。此外,还有不少在上述框架基础上封装的简化框架,例如 EasyGUI,PyGUI 和 Pyforms 等。

但问题在于,对于初学者(这里是指编程经验不超过 6 个月的用户)而言,即使是最简单的主流框架,他们也无从下手;他们也可以选择封装过的(简化)框架,但仍难以甚至无法创建自定义 GUI 布局 layout 。即便学会了某种(简化)框架,也需要编写连篇累牍的代码。

PySimpleGUI 尝试解决上述 GUI 难题,它提供了一种简单明了、易于理解、方便自定义的 GUI 接口。如果使用 PySimpleGUI,很多复杂的 GUI 也仅需不到 20 行代码。

秘诀

PySimpleGUI 极为适合初学者的秘诀在于,它已经包含了绝大多数原本需要用户编写的代码。PySimpleGUI 会处理按钮 回调 callback ,无需用户编写代码。对于初学者,在几周内掌握函数的概念已经不容易了,要求其理解回调函数似乎有些强人所难。

在大部分 GUI 框架中,布局 GUI 小部件 widgets 通常需要写一些代码,每个小部件至少 1-2 行。PySimpleGUI 使用了 “auto-packer” 技术,可以自动创建布局。因而,布局 GUI 窗口不再需要 pack 或 grid 系统。

(LCTT 译注:这里提到的 pack 和 grid 都是 Tkinter 的布局管理器,另外一种叫做 place 。)

最后,PySimpleGUI 框架编写中有效地利用了 Python 语言特性,降低用户代码量并简化 GUI 数据返回的方式。在 窗体 form 布局中创建小部件时,小部件会被部署到对应的布局中,无需额外的代码。

GUI 是什么?

绝大多数 GUI 只完成一件事情:收集用户数据并返回。在程序员看来,可以归纳为如下的函数调用:

button, values = GUI_Display(gui_layout)

绝大多数 GUI 支持的用户行为包括鼠标点击(例如,“确认”,“取消”,“保存”,“是”和“否”等)和内容输入。GUI 本质上可以归结为一行代码。

这也正是 PySimpleGUI (的简单 GUI 模式)的工作原理。当执行命令显示 GUI 后,除非点击鼠标关闭窗体,否则不会执行任何代码。

当然还有更复杂的 GUI,其中鼠标点击后窗口并不关闭;例如,机器人的远程控制界面,聊天窗口等。这类复杂的窗体也可以用 PySimpleGUI 创建。

快速创建 GUI

PySimpleGUI 什么时候有用呢?显然,是你需要 GUI 的时候。仅需不超过 5 分钟,就可以让你创建并尝试 GUI。最便捷的 GUI 创建方式就是从 PySimpleGUI 经典实例中拷贝一份代码。具体操作流程如下:

  • 找到一个与你需求最接近的 GUI
  • 从经典实例中拷贝代码
  • 粘贴到 IDE 中并运行

下面我们看一下书中的第一个 经典实例 recipe :

import PySimpleGUI as sg

# Very basic form.  Return values as a list
form = sg.FlexForm('Simple data entry form')  # begin with a blank form

layout = [
          [sg.Text('Please enter your Name, Address, Phone')],
          [sg.Text('Name', size=(15, 1)), sg.InputText('name')],
          [sg.Text('Address', size=(15, 1)), sg.InputText('address')],
          [sg.Text('Phone', size=(15, 1)), sg.InputText('phone')],
          [sg.Submit(), sg.Cancel()]
         ]

button, values = form.LayoutAndRead(layout)

print(button, values[0], values[1], values[2])

运行后会打开一个大小适中的窗体。

如果你只是想收集一些字符串类型的值,拷贝上述经典实例中的代码,稍作修改即可满足你的需求。

你甚至可以只用 5 行代码创建一个自定义 GUI 布局。

import PySimpleGUI as sg

form = sg.FlexForm('My first GUI')

layout = [ [sg.Text('Enter your name'), sg.InputText()],
           [sg.OK()] ]

button, (name,) = form.LayoutAndRead(layout)

5 分钟内创建一个自定义 GUI

在简单布局的基础上,通过修改经典实例中的代码,5 分钟内即可使用 PySimpleGUI 创建自定义布局。

在 PySimpleGUI 中, 小部件 widgets 被称为 元素 elements 。元素的名称与编码中使用的名称保持一致。

(LCTT 译注:Tkinter 中使用小部件这个词)

核心元素

Text
InputText
Multiline
InputCombo
Listbox
Radio
Checkbox
Spin
Output
SimpleButton
RealtimeButton
ReadFormButton
ProgressBar
Image
Slider
Column

元素简写

PySimpleGUI 还包含两种元素简写方式。一种是元素类型名称简写,例如 T 用作 Text 的简写;另一种是元素参数被配置了默认值,你可以无需指定所有参数,例如 Submit 按钮默认的文本就是 “Submit”。

T = Text
Txt = Text
In = InputText
Input = IntputText
Combo = InputCombo
DropDown = InputCombo
Drop = InputCombo

(LCTT 译注:第一种简写就是 Python 类的别名,第二种简写是在返回元素对象的 Python 函数定义时指定了参数的默认值)

按钮简写

一些通用按钮具有简写实现,包括:

FolderBrowse
FileBrowse
FileSaveAs
Save
Submit
OK
Ok (LCTT 译注:这里 `k` 是小写)
Cancel
Quit
Exit
Yes
No

此外,还有通用按钮功能对应的简写:

SimpleButton
ReadFormButton
RealtimeButton

(LCTT 译注:其实就是返回 Button 类实例的函数)

上面就是 PySimpleGUI 支持的全部元素。如果不在上述列表之中,就不会在你的窗口布局中生效。

(LCTT 译注:上述都是 PySimpleGUI 的类名、类别名或返回实例的函数,自然只能使用列表内的。)

GUI 设计模式

对于 GUI 程序,创建并展示窗口的调用大同小异,差异在于元素的布局。

设计模式代码与上面的例子基本一致,只是移除了布局:

import PySimpleGUI as sg

form = sg.FlexForm('Simple data entry form')
# Define your form here (it's a list of lists)
button, values = form.LayoutAndRead(layout)

(LCTT 译注:这段代码无法运行,只是为了说明每个程序都会用到的设计模式。)

对于绝大多数 GUI,编码流程如下:

  • 创建窗体对象
  • 以“列表的列表”的形式定义 GUI
  • 展示 GUI 并获取元素的值

上述流程与 PySimpleGUI 设计模式部分的代码一一对应。

GUI 布局

要创建自定义 GUI,首先要将窗体分割成多个行,因为窗体是一行一行定义的。然后,在每一行中从左到右依次放置元素。

我们得到的就是一个“列表的列表”,类似如下:

layout = [  [Text('Row 1')],
            [Text('Row 2'), Checkbox('Checkbox 1', OK()), Checkbox('Checkbox 2'), OK()] ]

上述布局对应的效果如下:

展示 GUI

当你完成布局、拷贝完用于创建和展示窗体的代码后,下一步就是展示窗体并收集用户数据。

下面这行代码用于展示窗体并返回收集的数据:

button, values = form.LayoutAndRead(layout)

窗体返回的结果由两部分组成:一部分是被点击按钮的名称,另一部分是一个列表,包含所有用户输入窗体的值。

在这个例子中,窗体显示后用户直接点击 “OK” 按钮,返回的结果如下:

button == 'OK'
values == [False, False]

Checkbox 类型元素返回 True 或 False 类型的值。由于默认处于未选中状态,两个元素的值都是 False。

显示元素的值

一旦从 GUI 获取返回值,检查返回变量中的值是个不错的想法。与其使用 print 语句进行打印,我们不妨坚持使用 GUI 并在一个窗口中输出这些值。

(LCTT 译注:考虑使用的是 Python 3 版本,print 应该是函数而不是语句。)

在 PySimpleGUI 中,有多种消息框可供选取。传递给消息框(函数)的数据会被显示在消息框中;函数可以接受任意数目的参数,你可以轻松的将所有要查看的变量展示出来。

在 PySimpleGUI 中,最常用的消息框是 MsgBox。要展示上面例子中的数据,只需编写一行代码:

MsgBox('The GUI returned:', button, values)

整合

好了,你已经了解了基础知识,让我们创建一个包含尽可能多 PySimpleGUI 元素的窗体吧!此外,为了更好的感观效果,我们将采用绿色/棕褐色的配色方案。

import PySimpleGUI as sg

sg.ChangeLookAndFeel('GreenTan')

form = sg.FlexForm('Everything bagel', default_element_size=(40, 1))

column1 = [[sg.Text('Column 1', background_color='#d3dfda', justification='center', size=(10,1))],
           [sg.Spin(values=('Spin Box 1', '2', '3'), initial_value='Spin Box 1')],
           [sg.Spin(values=('Spin Box 1', '2', '3'), initial_value='Spin Box 2')],
           [sg.Spin(values=('Spin Box 1', '2', '3'), initial_value='Spin Box 3')]]
layout = [
    [sg.Text('All graphic widgets in one form!', size=(30, 1), font=("Helvetica", 25))],
    [sg.Text('Here is some text.... and a place to enter text')],
    [sg.InputText('This is my text')],
    [sg.Checkbox('My first checkbox!'), sg.Checkbox('My second checkbox!', default=True)],
    [sg.Radio('My first Radio!     ', "RADIO1", default=True), sg.Radio('My second Radio!', "RADIO1")],
    [sg.Multiline(default_text='This is the default Text should you decide not to type anything', size=(35, 3)),
     sg.Multiline(default_text='A second multi-line', size=(35, 3))],
    [sg.InputCombo(('Combobox 1', 'Combobox 2'), size=(20, 3)),
     sg.Slider(range=(1, 100), orientation='h', size=(34, 20), default_value=85)],
    [sg.Listbox(values=('Listbox 1', 'Listbox 2', 'Listbox 3'), size=(30, 3)),
     sg.Slider(range=(1, 100), orientation='v', size=(5, 20), default_value=25),
     sg.Slider(range=(1, 100), orientation='v', size=(5, 20), default_value=75),
     sg.Slider(range=(1, 100), orientation='v', size=(5, 20), default_value=10),
     sg.Column(column1, background_color='#d3dfda')],
    [sg.Text('_'  * 80)],
    [sg.Text('Choose A Folder', size=(35, 1))],
    [sg.Text('Your Folder', size=(15, 1), auto_size_text=False, justification='right'),
     sg.InputText('Default Folder'), sg.FolderBrowse()],
    [sg.Submit(), sg.Cancel()]
     ]

button, values = form.LayoutAndRead(layout)
sg.MsgBox(button, values)

看上面要写不少代码,但如果你试着直接使用 Tkinter 框架实现同样的 GUI,你很快就会发现 PySimpleGUI 版本的代码是多么的简洁。

代码的最后一行打开了一个消息框,效果如下:

消息框函数中的每一个参数的内容都会被打印到单独的行中。本例的消息框中包含两行,其中第二行非常长而且包含列表嵌套。

建议花一点时间将上述结果与 GUI 中的元素一一比对,这样可以更好的理解这些结果是如何产生的。

为你的程序或脚本添加 GUI

如果你有一个命令行方式使用的脚本,添加 GUI 不一定意味着完全放弃该脚本。一种简单的方案如下:如果脚本不需要命令行参数,那么可以直接使用 GUI 调用该脚本;反之,就按原来的方式运行脚本。

仅需类似如下的逻辑:

if len(sys.argv) == 1:
        # collect arguments from GUI
else:
    # collect arguements from sys.argv

创建并运行 GUI 最便捷的方式就是从 PySimpleGUI 经典实例中拷贝一份代码并修改。

快来试试吧!给你一直疲于手动执行的脚本增加一些趣味。只需 5-10 分钟即可玩转示例脚本。你可能发现一个几乎满足你需求的经典实例;如果找不到,也很容易自己编写一个。即使你真的玩不转,也只是浪费了 5-10 分钟而已。

资源

安装方式

支持 Tkinter 的系统就支持 PySimpleGUI,甚至包括 树莓派 Raspberry Pi ,但你需要使用 Python 3。

pip install PySimpleGUI

文档


via: https://opensource.com/article/18/8/pysimplegui

作者:Mike Barnett 选题:lujun9972 译者:pinewall 校对:wxy

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

通过学习这些关键的术语和概念来理解 Python 应用监测。

 title=

当我第一次看到术语“ 计数器 counter ”和“ 计量器 gauge ”和使用颜色及标记着“平均数”和“大于 90%”的数字图表时,我的反应之一是逃避。就像我看到它们一样,我并不感兴趣,因为我不理解它们是干什么的或如何去使用。因为我的工作不需要我去注意它们,它们被我完全无视。

这都是在两年以前的事了。随着我的职业发展,我希望去了解更多关于我们的网络应用程序的知识,而那个时候就是我开始去学习 监测指标 metrics 的时候。

我的理解监测的学习之旅共有三个阶段(到目前为止),它们是:

  • 阶段 1:什么?(王顾左右)
  • 阶段 2:没有指标,我们真的是瞎撞。
  • 阶段 3:出现不合理的指标我们该如何做?

我现在处于阶段 2,我将分享到目前为止我学到了些什么。我正在向阶段 3 进发,在本文结束的位置我提供了一些我正在使用的学习资源。

我们开始吧!

需要的软件

在文章中讨论时用到的 demo 都可以在 我的 GitHub 仓库 中找到。你需要安装 docker 和 docker-compose 才能使用它们。

为什么要监测?

关于监测的主要原因是:

  • 理解 正常的 和 不正常的 系统和服务的特征
  • 做容量规划、弹性伸缩
  • 有助于排错
  • 了解软件/硬件改变的效果
  • 测量响应中的系统行为变化
  • 当系统出现意外行为时发出警报

指标和指标类型

从我们的用途来看,一个指标就是在一个给定时间点上的某些数量的 测量 值。博客文章的总点击次数、参与讨论的总人数、在缓存系统中数据没有被找到的次数、你的网站上的已登录用户数 —— 这些都是指标的例子。

它们总体上可以分为三类:

计数器

以你的个人博客为例。你发布一篇文章后,过一段时间后,你希望去了解有多少点击量,这是一个只会增加的数字。这就是一个 计数器 counter 指标。在你的博客文章的生命周期中,它的值从 0 开始增加。用图表来表示,一个计数器看起来应该像下面的这样:

 title=

一个计数器指标总是在增加的。

计量器

如果你想去跟踪你的博客每天或每周的点击量,而不是基于时间的总点击量。这种指标被称为一个 计量器 gauge ,它的值可上可下。用图表来表示,一个计量器看起来应该像下面的样子:

 title=

一个计量器指标可以增加或减少。

一个计量器的值在某些时间窗口内通常有一个 最大值 ceiling 和<ruby最小值floor。

柱状图和计时器

柱状图 histogram (在 Prometheus 中这么叫它)或 计时器 timer (在 StatsD 中这么叫它)是一个跟踪 已采样的观测结果 的指标。不像一个计数器类或计量器类指标,柱状图指标的值并不是显示为上或下的样式。我知道这可能并没有太多的意义,并且可能和一个计量器图看上去没有什么不同。它们的不同之处在于,你期望使用柱状图数据来做什么,而不是与一个计量器图做比较。因此,监测系统需要知道那个指标是一个柱状图类型,它允许你去做哪些事情。

 title=

一个柱状图指标可以增加或减少。

Demo 1:计算和报告指标

Demo 1 是使用 Flask 框架写的一个基本的 web 应用程序。它演示了我们如何去 计算 和 报告 指标。

在 src 目录中有 app.py 和 src/helpers/middleware.py 应用程序,包含以下内容:

from flask import request
import csv
import time


def start_timer():
    request.start_time = time.time()


def stop_timer(response):
    # convert this into milliseconds for statsd
    resp_time = (time.time() - request.start_time)*1000
    with open('metrics.csv', 'a', newline='') as f:
        csvwriter = csv.writer(f)
        csvwriter.writerow([str(int(time.time())), str(resp_time)])

    return response


def setup_metrics(app):
    app.before_request(start_timer)
    app.after_request(stop_timer)

当在应用程序中调用 setup_metrics() 时,它配置在一个请求被处理之前调用 start_timer() 函数,然后在该请求处理之后、响应发送之前调用 stop_timer() 函数。在上面的函数中,我们写了时间戳并用它来计算处理请求所花费的时间。

当我们在 demo1 目录中运行 docker-compose up,它会启动这个 web 应用程序,然后在一个客户端容器中可以生成一些对 web 应用程序的请求。你将会看到创建了一个 src/metrics.csv 文件,它有两个字段:timestamp 和 request_latency。

通过查看这个文件,我们可以推断出两件事情:

  • 生成了很多数据
  • 没有观测到任何与指标相关的特征

没有观测到与指标相关的特征,我们就不能说这个指标与哪个 HTTP 端点有关联,或这个指标是由哪个应用程序的节点所生成的。因此,我们需要使用合适的元数据去限定每个观测指标。

《Statistics 101》

(LCTT 译注:这是一本统计学入门教材的名字)

假如我们回到高中数学,我们应该回忆起一些统计术语,虽然不太确定,但应该包括平均数、中位数、百分位和柱状图。我们来简要地回顾一下它们,不用去管它们的用法,就像是在上高中一样。

平均数

平均数 mean ,即一系列数字的平均值,是将数字汇总然后除以列表的个数。3、2 和 10 的平均数是 (3+2+10)/3 = 5。

中位数

中位数 median 是另一种类型的平均,但它的计算方式不同;它是列表从小到大排序(反之亦然)后取列表的中间数字。以我们上面的列表中(2、3、10),中位数是 3。计算并不是非常直观,它取决于列表中数字的个数。

百分位

百分位 percentile 是指那个百(千)分比数字低于我们给定的百分数的程度。在一些场景中,它是指这个测量值低于我们数据的百(千)分比数字的程度。比如,上面列表中 95% 是 9.29999。百分位的测量范围是 0 到 100(不包括)。0% 是一组数字的最小分数。你可能会想到它的中位数是 50%,它的结果是 3。

一些监测系统将百分位称为 upper_X,其中 X 就是百分位;upper 90 指的是在 90% 的位置的值。

分位数

“q-分位数”是将有 N 个数的集合等分为 qN 级。q 的取值范围为 0 到 1(全部都包括)。当 q 取值为 0.5 时,值就是中位数。( 分位数 quantile )和百分位数的关系是,分位数值 q 等于 100 百分位值。

柱状图

<ruby柱状图histogram这个指标,我们前面学习过,它是监测系统中一个实现细节。在统计学中,一个柱状图是一个将数据分组为 桶 的图表。我们来考虑一个人为的不同示例:阅读你的博客的人的年龄。如果你有一些这样的数据,并想将它进行大致的分组,绘制成的柱状图将看起来像下面的这样:

 title=

累积柱状图

一个 累积柱状图 cumulative histogram 也是一个柱状图,它的每个桶的数包含前一个桶的数,因此命名为累积。将上面的数据集做成累积柱状图后,看起来应该是这样的:

 title=

我们为什么需要做统计?

在上面的 Demo 1 中,我们注意到在我们报告指标时,这里生成了许多数据。当我们将它们用于指标时我们需要做统计,因为它们实在是太多了。我们需要的是整体行为,我们没法去处理单个值。我们预期展现出来的值的行为应该是代表我们观察的系统的行为。

Demo 2:在指标上增加特征

在我们上面的的 Demo 1 应用程序中,当我们计算和报告一个请求的延迟时,它指向了一个由一些特征 唯一标识的特定请求。下面是其中一些:

  • HTTP 端点
  • HTTP 方法
  • 运行它的主机/节点的标识符

如果我们将这些特征附加到要观察的指标上,每个指标将有更多的内容。我们来解释一下 Demo 2 中添加到我们的指标上的特征。

在写入指标时,src/helpers/middleware.py 文件将在 CSV 文件中写入多个列:

node_ids = ['10.0.1.1', '10.1.3.4']


def start_timer():
    request.start_time = time.time()


def stop_timer(response):
    # convert this into milliseconds for statsd
    resp_time = (time.time() - request.start_time)*1000
    node_id = node_ids[random.choice(range(len(node_ids)))]
    with open('metrics.csv', 'a', newline='') as f:
        csvwriter = csv.writer(f)
        csvwriter.writerow([
            str(int(time.time())), 'webapp1', node_id,
            request.endpoint, request.method, str(response.status_code),
            str(resp_time)
        ])

    return response

因为这只是一个演示,在报告指标时,我们将随意的报告一些随机 IP 作为节点的 ID。当我们在 demo2 目录下运行 docker-compose up 时,我们的结果将是一个有多个列的 CSV 文件。

用 pandas 分析指标

我们将使用 pandas 去分析这个 CSV 文件。运行 docker-compose up 将打印出一个 URL,我们将使用它来打开一个 Jupyter 会话。一旦我们上传 Analysis.ipynb notebook 到会话中,我们就可以将 CSV 文件读入到一个 pandas 数据帧 DataFrame 中:

import pandas as pd
metrics = pd.read_csv('/data/metrics.csv', index_col=0)

index_col 表明我们要指定时间戳作为索引。

因为每个特征我们都要在数据帧中添加一个列,因此我们可以基于这些列进行分组和聚合:

import numpy as np
metrics.groupby(['node_id', 'http_status']).latency.aggregate(np.percentile, 99.999)

更多内容请参考 Jupyter notebook 在数据上的分析示例。

我应该监测什么?

一个软件系统有许多的变量,这些变量的值在它的生命周期中不停地发生变化。软件是运行在某种操作系统上的,而操作系统同时也在不停地变化。在我看来,当某些东西出错时,你所拥有的数据越多越好。

我建议去监测的关键操作系统指标有:

  • CPU 使用
  • 系统内存使用
  • 文件描述符使用
  • 磁盘使用

还需要监测的其它关键指标根据你的软件应用程序不同而不同。

网络应用程序

如果你的软件是一个监听客户端请求和为它提供服务的网络应用程序,需要测量的关键指标还有:

  • 入站请求数(计数器)
  • 未处理的错误(计数器)
  • 请求延迟(柱状图/计时器)
  • 排队时间,如果在你的应用程序中有队列(柱状图/计时器)
  • 队列大小,如果在你的应用程序中有队列(计量器)
  • 工作进程/线程用量(计量器)

如果你的网络应用程序在一个客户端请求的环境中向其它服务发送请求,那么它应该有一个指标去记录它与那个服务之间的通讯行为。需要监测的关键指标包括请求数、请求延迟、和响应状态。

HTTP web 应用程序后端

HTTP 应用程序应该监测上面所列出的全部指标。除此之外,还应该按 HTTP 状态代码分组监测所有非 200 的 HTTP 状态代码的大致数据。如果你的 web 应用程序有用户注册和登录功能,同时也应该为这个功能设置指标。

长时间运行的进程

长时间运行的进程如 Rabbit MQ 消费者或任务队列的工作进程,虽然它们不是网络服务,它们以选取一个任务并处理它的工作模型来运行。因此,我们应该监测请求的进程数和这些进程的请求延迟。

不管是什么类型的应用程序,都有指标与合适的元数据相关联。

将监测集成到一个 Python 应用程序中

将监测集成到 Python 应用程序中需要涉及到两个组件:

  • 更新你的应用程序去计算和报告指标
  • 配置一个监测基础设施来容纳应用程序的指标,并允许去查询它们

下面是记录和报告指标的基本思路:

def work():
    requests += 1
    # report counter
    start_time = time.time()
    
    # < do the work >

    # calculate and report latency
    work_latency = time.time() - start_time
    ...

考虑到上面的模式,我们经常使用修饰符、内容管理器、中间件(对于网络应用程序)所带来的好处去计算和报告指标。在 Demo 1 和 Demo 2 中,我们在一个 Flask 应用程序中使用修饰符。

指标报告时的拉取和推送模型

大体来说,在一个 Python 应用程序中报告指标有两种模式。在 拉取 模型中,监测系统在一个预定义的 HTTP 端点上“刮取”应用程序。在推送 模型中,应用程序发送数据到监测系统。

 title=

工作在 拉取 模型中的监测系统的一个例子是 Prometheus。而 StatsD 是 推送 模型的一个例子。

集成 StatsD

将 StatsD 集成到一个 Python 应用程序中,我们将使用 StatsD Python 客户端,然后更新我们的指标报告部分的代码,调用合适的库去推送数据到 StatsD 中。

首先,我们需要去创建一个客户端实例:

statsd = statsd.StatsClient(host='statsd', port=8125, prefix='webapp1')

prefix 关键字参数将为通过这个客户端报告的所有指标添加一个指定的前缀。

一旦我们有了客户端,我们可以使用如下的代码为一个计时器报告值:

statsd.timing(key, resp_time)

增加计数器:

statsd.incr(key)

将指标关联到元数据上,一个键的定义为:metadata1.metadata2.metric,其中每个 metadataX 是一个可以进行聚合和分组的字段。

这个演示应用程序 StatsD 是将 statsd 与 Python Flask 应用程序集成的一个完整示例。

集成 Prometheus

要使用 Prometheus 监测系统,我们使用 Promethius Python 客户端。我们将首先去创建有关的指标类对象:

REQUEST_LATENCY = Histogram('request_latency_seconds', 'Request latency',
    ['app_name', 'endpoint']
)

在上面的语句中的第三个参数是与这个指标相关的标识符。这些标识符是由与单个指标值相关联的元数据定义的。

去记录一个特定的观测指标:

REQUEST_LATENCY.labels('webapp', request.path).observe(resp_time)

下一步是在我们的应用程序中定义一个 Prometheus 能够刮取的 HTTP 端点。这通常是一个被称为 /metrics 的端点:

@app.route('/metrics')
def metrics():
    return Response(prometheus_client.generate_latest(), mimetype=CONTENT_TYPE_LATEST)

这个演示应用程序 Prometheus 是将 prometheus 与 Python Flask 应用程序集成的一个完整示例。

哪个更好:StatsD 还是 Prometheus?

本能地想到的下一个问题便是:我应该使用 StatsD 还是 Prometheus?关于这个主题我写了几篇文章,你可能发现它们对你很有帮助:

指标的使用方式

我们已经学习了一些关于为什么要在我们的应用程序上配置监测的原因,而现在我们来更深入地研究其中的两个用法:报警和自动扩展。

使用指标进行报警

指标的一个关键用途是创建警报。例如,假如过去的五分钟,你的 HTTP 500 的数量持续增加,你可能希望给相关的人发送一封电子邮件或页面提示。对于配置警报做什么取决于我们的监测设置。对于 Prometheus 我们可以使用 Alertmanager,而对于 StatsD,我们使用 Nagios。

使用指标进行自动扩展

在一个云基础设施中,如果我们当前的基础设施供应过量或供应不足,通过指标不仅可以让我们知道,还可以帮我们实现一个自动伸缩的策略。例如,如果在过去的五分钟里,在我们服务器上的工作进程使用率达到 90%,我们可以水平扩展。我们如何去扩展取决于云基础设施。AWS 的自动扩展,缺省情况下,扩展策略是基于系统的 CPU 使用率、网络流量、以及其它因素。然而,让基础设施伸缩的应用程序指标,我们必须发布 自定义的 CloudWatch 指标。

在多服务架构中的应用程序监测

当我们超越一个单应用程序架构时,比如当客户端的请求在响应被发回之前,能够触发调用多个服务,就需要从我们的指标中获取更多的信息。我们需要一个统一的延迟视图指标,这样我们就能够知道响应这个请求时每个服务花费了多少时间。这可以用 分布式跟踪 来实现。

你可以在我的博客文章 《在你的 Python 应用程序中通过 Zipkin 引入分布式跟踪》 中看到在 Python 中进行分布式跟踪的示例。

划重点

总之,你需要记住以下几点:

  • 理解你的监测系统中指标类型的含义
  • 知道监测系统需要的你的数据的测量单位
  • 监测你的应用程序中的大多数关键组件
  • 监测你的应用程序在它的大多数关键阶段的行为

以上要点是假设你不去管理你的监测系统。如果管理你的监测系统是你的工作的一部分,那么你还要考虑更多的问题!

其它资源

以下是我在我的监测学习过程中找到的一些非常有用的资源:

综合的

StatsD/Graphite

Prometheus

避免犯错(即第 3 阶段的学习)

在我们学习监测的基本知识时,时刻注意不要犯错误是很重要的。以下是我偶然发现的一些很有见解的资源:


想学习更多内容,参与到 PyCon Cleveland 2018 上的 Amit Saha 的讨论,Counter, gauge, upper 90—Oh my!

关于作者

Amit Saha — 我是一名对基础设施、监测、和工具感兴趣的软件工程师。我是“用 Python 做数学”的作者和创始人,以及 Fedora Scientific Spin 维护者。

关于我的更多信息


via: https://opensource.com/article/18/4/metrics-monitoring-and-python

作者: Amit Saha 选题者: lujun9972 译者: qhwdw 校对: wxy

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

这些库可以使你更容易构架个人项目。

在 Python/Django 的世界里有这样一个谚语:为语言而来,为社区而留。对绝大多数人来说的确是这样的,但是,还有一件事情使得我们一直停留在 Python 的世界里,不愿离开,那就是我们可以很容易地利用一顿午餐或晚上几个小时的时间,把一个想法快速地实现出来。

这个月,我们来探讨一些我们喜欢用来快速完成 业余项目 side projects 或打发午餐时间的 Python 库。

在数据库中即时保存数据:Dataset

当我们想要在不知道最终数据库表长什么样的情况下,快速收集数据并保存到数据库中的时候,Dataset 库将是我们的最佳选择。Dataset 库有一个简单但功能强大的 API,因此我们可以很容易的把数据保存下来,之后再进行整理。

Dataset 建立在 SQLAlchemy 之上,所以如果需要对它进行扩展,你会感到非常熟悉。使用 Django 内建的 inspectdb 管理命令可以很容易地把底层数据库模型导入 Django 中,这使得和现有数据库一同工作不会出现任何障碍。

从网页抓取数据:Beautiful Soup

Beautiful Soup(一般写作 BS4)库使得从 HTML 网页中提取信息变得非常简单。当我们需要把非结构化或弱结构化的 HTML 转换为结构化数据的时候,就需要使用 Beautiful Soup 。用它来处理 XML 数据也是一个很好的选择,否则 XML 的可读性或许会很差。

和 HTTP 内容打交道:Requests

当需要和 HTTP 内容打交道的时候,Requests 毫无疑问是最好的标准库。当我们想要抓取 HTML 网页或连接 API 的时候,都离不开 Requests 库。同时,它也有很好的文档。

编写命令行工具:Click

当需要写一个简单的 Python 脚本作为命令行工具的时候,Click 是我最喜欢用的库。它的 API 非常直观,并且在实现时经过了深思熟虑,我们只需要记住很少的几个模式。它的文档也很优秀,这使得学习其高级特性更加容易。

对事物命名:Python Slugify

众所周知,命名是一件困难的事情。Python Slugify 是一个非常有用的库,它可以把一个标题或描述转成一个带有特性的唯一标识符。如果你正在做一个 Web 项目,并且你想要使用对 搜索引擎优化友好 SEO-friendly 的链接,那么,使用 Python Slugify 可以让这件事变得很容易。

和插件打交道:Pluggy

Pluggy 库相对较新,但是如果你想添加一个插件系统到现有应用中,那么使用 Pluggy 是最好也是最简单的方式。如果你使用过 pytest,那么实际上相当于已经使用过 Pluggy 了,虽然你还不知道它。

把 CSV 文件转换到 API 中:DataSette

DataSette 是一个神奇的工具,它可以很容易地把 CSV 文件转换为全特性的只读 REST JSON API,同时,不要把它和 Dataset 库混淆。Datasette 有许多特性,包括创建图表和 geo(用于创建交互式地图),并且很容易通过容器或第三方网络主机进行部署。

处理环境变量等:Envparse

如果你不想在源代码中保存 API 密钥、数据库凭证或其他敏感信息,那么你便需要解析环境变量,这时候 envparse 是最好的选择。Envparse 能够处理环境变量、ENV 文件、变量类型,甚至还可以进行预处理和后处理(例如,你想要确保变量名总是大写或小写的)。

有什么你最喜欢的用于业余项目的 Python 库不在这个列表中吗?请在评论中和我们分享。


via: https://opensource.com/article/18/9/python-libraries-side-projects

作者:Jeff Triplett 选题:lujun9972 译者:ucasFL 校对:wxy

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

Visual Studio Code,简称 VS Code,是一个开源的文本编辑器,包含用于构建和调试应用程序的工具。安装启用 Python 扩展后,VS Code 可以配置成理想的 Python 开发工作环境。本文将介绍一些有用的 VS Code 扩展,并配置它们以充分提高 Python 开发效率。

如果你的计算机上还没有安装 VS Code,可以参考文章 在 Fedora 上使用 VS Code 来安装。

在 VS Code 中安装 Python 扩展

首先,为了更方便地在 VS Code 中进行 Python 开发,需要从 VS Code 扩展商店中安装 Python 扩展。

Python 扩展安装完成后,就可以开始配置 Python 扩展了。

VS Code 通过两个 JSON 文件管理设置:

  • 一个文件用于 VS Code 的全局设置,作用于所有的项目
  • 另一个文件用于特殊设置,作用于单独项目

可以用快捷键 Ctrl+, (逗号)打开全局设置,也可以通过 文件 -> 首选项 -> 设置 来打开。

设置 Python 路径

您可以在全局设置中配置 python.pythonPath 使 VS Code 自动为每个项目选择最适合的 Python 解释器。

// 将设置放在此处以覆盖默认设置和用户设置。
// Path to Python, you can use a custom version of Python by modifying this setting to include the full path.
{
    "python.pythonPath":"${workspaceRoot}/.venv/bin/python",
}

这样,VS Code 将使用虚拟环境目录 .venv 下项目根目录中的 Python 解释器。

使用环境变量

默认情况下,VS Code 使用项目根目录下的 .env 文件中定义的环境变量。 这对于设置环境变量很有用,如:

PYTHONWARNINGS="once"

可使程序在运行时显示警告。

可以通过设置 python.envFile 来加载其他的默认环境变量文件:

// Absolute path to a file containing environment variable definitions.
"python.envFile": "${workspaceFolder}/.env",

代码分析

Python 扩展还支持不同的代码分析工具(pep8、flake8、pylint)。要启用你喜欢的或者正在进行的项目所使用的分析工具,只需要进行一些简单的配置。

扩展默认情况下使用 pylint 进行代码分析。你可以这样配置以使用 flake8 进行分析:

"python.linting.pylintEnabled": false,
"python.linting.flake8Path": "${workspaceRoot}/.venv/bin/flake8",
"python.linting.flake8Enabled": true,
"python.linting.flake8Args": ["--max-line-length=90"],

启用代码分析后,分析器会在不符合要求的位置加上波浪线,鼠标置于该位置,将弹窗提示其原因。注意,项目的虚拟环境中需要安装有 flake8,此示例方能有效。

格式化代码

可以配置 VS Code 使其自动格式化代码。目前支持 autopep8、black 和 yapf。下面的设置将启用 “black” 模式。

// Provider for formatting. Possible options include 'autopep8', 'black', and 'yapf'.
"python.formatting.provider": "black",
"python.formatting.blackPath": "${workspaceRoot}/.venv/bin/black"
"python.formatting.blackArgs": ["--line-length=90"],
"editor.formatOnSave": true,

如果不需要编辑器在保存时自动格式化代码,可以将 editor.formatOnSave 设置为 false 并手动使用快捷键 Ctrl + Shift + I 格式化当前文档中的代码。 注意,项目的虚拟环境中需要安装有 black,此示例方能有效。

运行任务

VS Code 的一个重要特点是它可以运行任务。需要运行的任务保存在项目根目录中的 JSON 文件中。

运行 flask 开发服务

这个例子将创建一个任务来运行 Flask 开发服务器。 使用一个可以运行外部命令的基本模板来创建新的工程:

编辑如下所示的 tasks.json 文件,创建新任务来运行 Flask 开发服务:

{
  // See https://go.microsoft.com/fwlink/?LinkId=733558
  // for the documentation about the tasks.json format
  "version": "2.0.0",
  "tasks": [
    {

      "label": "Run Debug Server",
      "type": "shell",
      "command": "${workspaceRoot}/.venv/bin/flask run -h 0.0.0.0 -p 5000",
      "group": {
          "kind": "build",
          "isDefault": true
       }
    }
  ]
}

Flask 开发服务使用环境变量来获取应用程序的入口点。 如 使用环境变量 一节所说,可以在 .env 文件中声明这些变量:

FLASK_APP=wsgi.py
FLASK_DEBUG=True

这样就可以使用快捷键 Ctrl + Shift + B 来执行任务了。

单元测试

VS Code 还支持单元测试框架 pytest、unittest 和 nosetest。启用测试框架后,可以在 VS Code 中单独运行搜索到的单元测试,通过测试套件运行测试或者运行所有的测试。

例如,可以这样启用 pytest 测试框架:

"python.unitTest.pyTestEnabled": true,
"python.unitTest.pyTestPath": "${workspaceRoot}/.venv/bin/pytest",

注意,项目的虚拟环境中需要安装有 pytest,此示例方能有效。


via: https://fedoramagazine.org/vscode-python-howto/

作者:Clément Verna 选题:lujun9972 译者:idea2act 校对:wxy

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

为了在 Python 中快速构建 API,我主要依赖于 Flask。最近我遇到了一个名为 “API Star” 的基于 Python 3 的新 API 框架。由于几个原因,我对它很感兴趣。首先,该框架包含 Python 新特点,如类型提示和 asyncio。而且它再进一步为开发人员提供了很棒的开发体验。我们很快就会讲到这些功能,但在我们开始之前,我首先要感谢 Tom Christie,感谢他为 Django REST Framework 和 API Star 所做的所有工作。

现在说回 API Star —— 我感觉这个框架很有成效。我可以选择基于 asyncio 编写异步代码,或者可以选择传统后端方式就像 WSGI 那样。它配备了一个命令行工具 —— apistar 来帮助我们更快地完成工作。它支持 Django ORM 和 SQLAlchemy,这是可选的。它有一个出色的类型系统,使我们能够定义输入和输出的约束,API Star 可以自动生成 API 的模式(包括文档),提供验证和序列化功能等等。虽然 API Star 专注于构建 API,但你也可以非常轻松地在其上构建 Web 应用程序。在我们自己构建一些东西之前,所有这些可能都没有意义的。

开始

我们将从安装 API Star 开始。为此实验创建一个虚拟环境是一个好主意。如果你不知道如何创建一个虚拟环境,不要担心,继续往下看。

pip install apistar

(译注:上面的命令是在 Python 3 虚拟环境下使用的)

如果你没有使用虚拟环境或者你的 Python 3 的 pip 名为 pip3,那么使用 pip3 install apistar 代替。

一旦我们安装了这个包,我们就应该可以使用 apistar 命令行工具了。我们可以用它创建一个新项目,让我们在当前目录中创建一个新项目。

apistar new .

现在我们应该创建两个文件:app.py,它包含主应用程序,然后是 test.py,它用于测试。让我们来看看 app.py 文件:

from apistar import Include, Route
from apistar.frameworks.wsgi import WSGIApp as App
from apistar.handlers import docs_urls, static_urls

def welcome(name=None):
    if name is None:
        return {'message': 'Welcome to API Star!'}
    return {'message': 'Welcome to API Star, %s!' % name}


routes = [
    Route('/', 'GET', welcome),
    Include('/docs', docs_urls),
    Include('/static', static_urls)
]

app = App(routes=routes)


if __name__ == '__main__':
    app.main()

在我们深入研究代码之前,让我们运行应用程序并查看它是否正常工作。我们在浏览器中输入 http://127.0.0.1:8080/,我们将得到以下响应:

{"message": "Welcome to API Star!"}

如果我们输入:http://127.0.0.1:8080/?name=masnun

{"message": "Welcome to API Star, masnun!"}

同样的,输入 http://127.0.0.1:8080/docs/,我们将看到自动生成的 API 文档。

现在让我们来看看代码。我们有一个 welcome 函数,它接收一个名为 name 的参数,其默认值为 None。API Star 是一个智能的 API 框架。它将尝试在 url 路径或者查询字符串中找到 name 键并将其传递给我们的函数,它还基于其生成 API 文档。这真是太好了,不是吗?

然后,我们创建一个 Route 和 Include 实例的列表,并将列表传递给 App 实例。Route 对象用于定义用户自定义路由。顾名思义,Include 包含了在给定的路径下的其它 url 路径。

路由

路由很简单。当构造 App 实例时,我们需要传递一个列表作为 routes 参数,这个列表应该有我们刚才看到的 Route 或 Include 对象组成。对于 Route,我们传递一个 url 路径,http 方法和可调用的请求处理程序(函数或者其他)。对于 Include 实例,我们传递一个 url 路径和一个 Routes 实例列表。

路径参数

我们可以在花括号内添加一个名称来声明 url 路径参数。例如 /user/{user_id} 定义了一个 url,其中 user_id 是路径参数,或者说是一个将被注入到处理函数(实际上是可调用的)中的变量。这有一个简单的例子:

from apistar import Route
from apistar.frameworks.wsgi import WSGIApp as App


def user_profile(user_id: int):
    return {'message': 'Your profile id is: {}'.format(user_id)}


routes = [
    Route('/user/{user_id}', 'GET', user_profile),
]

app = App(routes=routes)

if __name__ == '__main__':
    app.main()

如果我们访问 http://127.0.0.1:8080/user/23,我们将得到以下响应:

{"message": "Your profile id is: 23"}

但如果我们尝试访问 http://127.0.0.1:8080/user/some_string,它将无法匹配。因为我们定义了 user_profile 函数,且为 user_id 参数添加了一个类型提示。如果它不是整数,则路径不匹配。但是如果我们继续删除类型提示,只使用 user_profile(user_id),它将匹配此 url。这也展示了 API Star 的智能之处和利用类型和好处。

包含/分组路由

有时候将某些 url 组合在一起是有意义的。假设我们有一个处理用户相关功能的 user 模块,将所有与用户相关的 url 分组在 /user 路径下可能会更好。例如 /user/new、/user/1、/user/1/update 等等。我们可以轻松地在单独的模块或包中创建我们的处理程序和路由,然后将它们包含在我们自己的路由中。

让我们创建一个名为 user 的新模块,文件名为 user.py。我们将以下代码放入这个文件:

from apistar import Route


def user_new():
    return {"message": "Create a new user"}


def user_update(user_id: int):
    return {"message": "Update user #{}".format(user_id)}


def user_profile(user_id: int):
    return {"message": "User Profile for: {}".format(user_id)}


user_routes = [
    Route("/new", "GET", user_new),
    Route("/{user_id}/update", "GET", user_update),
    Route("/{user_id}/profile", "GET", user_profile),
]

现在我们可以从 app 主文件中导入 user_routes,并像这样使用它:

from apistar import Include
from apistar.frameworks.wsgi import WSGIApp as App

from user import user_routes

routes = [
    Include("/user", user_routes)
]

app = App(routes=routes)

if __name__ == '__main__':
    app.main()

现在 /user/new 将委托给 user_new 函数。

访问查询字符串/查询参数

查询参数中传递的任何参数都可以直接注入到处理函数中。比如 url /call?phone=1234,处理函数可以定义一个 phone 参数,它将从查询字符串/查询参数中接收值。如果 url 查询字符串不包含 phone 的值,那么它将得到 None。我们还可以为参数设置一个默认值,如下所示:

def welcome(name=None):
    if name is None:
        return {'message': 'Welcome to API Star!'}
    return {'message': 'Welcome to API Star, %s!' % name}

在上面的例子中,我们为 name 设置了一个默认值 None。

注入对象

通过给一个请求程序添加类型提示,我们可以将不同的对象注入到视图中。注入请求相关的对象有助于处理程序直接从内部访问它们。API Star 内置的 http 包中有几个内置对象。我们也可以使用它的类型系统来创建我们自己的自定义对象并将它们注入到我们的函数中。API Star 还根据指定的约束进行数据验证。

让我们定义自己的 User 类型,并将其注入到我们的请求处理程序中:

from apistar import Include, Route
from apistar.frameworks.wsgi import WSGIApp as App
from apistar import typesystem


class User(typesystem.Object):
    properties = {
    'name': typesystem.string(max_length=100),
    'email': typesystem.string(max_length=100),
    'age': typesystem.integer(maximum=100, minimum=18)
    }

    required = ["name", "age", "email"]


def new_user(user: User):
    return user


routes = [
    Route('/', 'POST', new_user),
]

app = App(routes=routes)

if __name__ == '__main__':
    app.main()

现在如果我们发送这样的请求:

curl -X POST \
  http://127.0.0.1:8080/ \
  -H 'Cache-Control: no-cache' \
  -H 'Content-Type: application/json' \
  -d '{"name": "masnun", "email": "[email protected]", "age": 12}'

猜猜发生了什么?我们得到一个错误,说年龄必须等于或大于 18。类型系允许我们进行智能数据验证。如果我们启用了 docs url,我们还将自动记录这些参数。

发送响应

如果你已经注意到,到目前为止,我们只可以传递一个字典,它将被转换为 JSON 并作为默认返回。但是,我们可以使用 apistar 中的 Response 类来设置状态码和其它任意响应头。这有一个简单的例子:

from apistar import Route, Response
from apistar.frameworks.wsgi import WSGIApp as App


def hello():
    return Response(
    content="Hello".encode("utf-8"),
    status=200,
    headers={"X-API-Framework": "API Star"},
    content_type="text/plain"
    )


routes = [
    Route('/', 'GET', hello),
]

app = App(routes=routes)

if __name__ == '__main__':
    app.main()

它应该返回纯文本响应和一个自定义标响应头。请注意,content 应该是字节,而不是字符串。这就是我编码它的原因。

继续

我刚刚介绍了 API Star 的一些特性,API Star 中还有许多非常酷的东西,我建议通过 Github Readme 文件来了解这个优秀框架所提供的不同功能的更多信息。我还将尝试在未来几天内介绍关于 API Star 的更多简短的,集中的教程。


via: http://polyglot.ninja/api-star-python-3-api-framework/

作者:MASNUN 译者:MjSeven 校对:wxy

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