书籍阅读-Python高手之路

书籍阅读-Python高手之路

前言

笔者之前已经看过《Flask Web开发:基于Python的Web应用开发实战》、《Head+First+Python(中文版)》、《Python学习手册(第4版)》、《python绝技:运用python成为顶级黑客》。

Flask Web开发:基于Python的Web应用开发实战: 用于作网站不错。
Head+First+Python(中文版):入门最简单。
Python学习手册(第4版):语言讲解最详细丰富。
python绝技:运用python成为顶级黑客:可以了解下黑客怎么玩的。

而这本《Python高手之路》显然不是给初学者看的,它是给有经验的Python程序员关于Python世界的一个整体视野,并不太关注于语法细节。
作者是150万行Python代码量级的OpenStack项目 技术负责人之一。是值得一读的,不建议初学者读,初学者看了估计很难消化。

第1章 项目开始

这一章对技术管理岗有用,一线员工可能并不太关心。

Python版本

比较了2.5,2.6,2.7,3.1,3.2,3.3,3.4。
建议支持2.7和3.3。(备注:现在已经有了3.5)
如果想支持所有版本,有个CherryPy项目可以参考(http://cherrypy.org/),它支持2.3及以后的所有版本。

需要支持2.7和3.3的话,可以参考13章。

项目结构

项目结构应该保持简单,审慎地使用包和层次结构,过深的层次结构在目录导航时将如同梦魇,但过平的层次结构则会让项目变得臃肿。
一个常犯的错误是将单元测试放在包目录的外面。这些测试实际上应该被包含在软件的子一级包中,以便:

  • 避免被setuptools(或者其他打包的库)作为tests顶层模块自动安装。
  • 能够被安装,且其他包能够利用它们构建自己的单元测试。

setup.py是Python安装脚本的标准名称。

下面这些顶层目录也比较常见。

  • etc 用来存放配置文件的样例。
  • tools 用来存放与工具相关的shell脚本。
  • bin 用来存放将被setup.py安装的二进制脚本。
  • data 用来存放其他类型的文件,如媒体文件。

一个常见的设计问题是根据将要存储的代码的类型来创建文件或模块。使用functions.py或者exceptions.py这样的文件是很糟糕的方式。这种方式对代码的组织毫无帮助,只能让读代码的人在多个文件之间毫无理由地来回切换。
此外,应该避免创建那种只有一个__init__.py文件的目录,例如,如果hooks.py够用的话,就不要创建hooks/init.py。 如果创建目录,那么其中就应该包含属于这一分类/模块的多个Python文件。

版本编号

PEP 440针对所有的Python包引入了一种版本格式,并且在理论上所有的应用程序都应该使用这种格式。

PEP440定义版本号应该遵从以下正则表达式的格式:

N[.N]+[{a|b|c|rc}N]].postN][.devN]

它允许类似1.2或1.2.3这样的格式,但需要注意以下几点。

  • 1.2等于1.2.0, 1.3.4等于1.3.4.0, 以此类推。
  • 与N[.N]+相匹配的版本被认为是最终版本
  • 基于日期的版本(如2013.06.22)被认为是无效的。针对PEP440格式版本号设计的一些自动化工具,在检测到版本号大于或等于1980时就会抛出错误。
  • N[.N]+aN(如1.2a1)表示一个alpha版本,即此版本不稳定或缺少某些功能。
  • N[.N]+bN(如2.3.1b2)表示一个beta版本,即此版本功能已经完整,但可能仍有bug。
  • N[.N]+cN或N[.N]+rcN(如0.4rc1)表示候选版本(常缩写为RC),通常指除非有重大的bug,否则很可能成为产品的最终发行版本。尽管rc和c两个后缀含义相同,但如果二者同时使用,rc版本通常表示比c更新一点。

通常用到的还有以下这些后缀。

  • .postN(如1.4.post2)表示一个后续版本。通常用来解决发行过程中的细小问题(如发行文档有错)。如果发行的是bug修复版本,则不应该使用.postN而应该增加小的版本号。
  • .devN(如2.3.4.dev3)表示一个开发版本。因为难以解析,所以这个后缀并不建议使用。它表示这是一个质量基本合格的发布前的版本,例如,2.3.4.dev3表示2.3.4版本的第三个开发版本,它早于任何的alpha版本、beta版本、候选版本和最终版本。

编码风格与自动检查

Python社区提出了编写Python代码的PEP8标准.
这些规范可以归纳成下面的内容。

  • 每个缩进层级使用4个空格。
  • 每行最多的79个字符。
  • 顶层的函数或类的定义之间空两行。
  • 采用ASCII或UTF-8编码文件。
  • 在文件顶端,注释和文档说明之下,每行每条import语句只导入一个模块,同时要按照标准库、第三方库和本地库的导入顺序进行分组。
  • 在小括号、中括号、大括号之间或者逗号之前没有额外的空格。
  • 类的命名采用驼峰命名法,如Came1Case;异常的定义使用Error前缀(如适用的话);函数的命名使用小写字符,如separated_by_underscores;用下划线开头定义私有的属性或方法,如_private。

为了保证代码符合PEP8规范,提供了一个pep8工具来自动检查Python文件是否符合PEP8要求。

pip install pep8 可安装。
pep8 file.py可以检查。
我测试的一个

pep8 config.py
config.py:6:80: E501 line too long (82 > 79 characters)
config.py:23:30: E225 missing whitespace around operator
config.py:39:1: E303 too many blank lines (3)
config.py:57:49: E231 missing whitespace after ‘,’
config.py:59:61: E231 missing whitespace after ‘,’
config.py:59:80: E501 line too long (119 > 79 characters)
config.py:59:105: E231 missing whitespace after ‘,’
config.py:61:80: E501 line too long (81 > 79 characters)
config.py:85:1: E303 too many blank lines (4)

也可以使用–ignore选项忽略某些特定的错误或警告,如下所求。

pep8 –ignore=E2 config.py
config.py:6:80: E501 line too long (82 > 79 characters)
config.py:39:1: E303 too many blank lines (3)
config.py:59:80: E501 line too long (119 > 79 characters)
config.py:61:80: E501 line too long (81 > 79 characters)
config.py:85:1: E303 too many blank lines (4)

相对于上面那个,少了E2xx的错误提示。

还有一些其他的工具能够检查真正的编码错误而非风格问题。下面是一些比较知名的工具。

  • pyflakes,它支持插件。
  • pylint,它支持PEP8,默认可以执行更多检查,并且支持插件。

pyflakes是按自己的规则检查而非按PEP8,所以仍然需要运行pep8。为了简化操作,一个名为flake8的项目将pyflakes和pep8合并成了一个命令。
flake8也是OpenStack使用的工具。
flake8又扩展了一个新的工具hacking,它可以检查except语句的错误使用、Python2与Python3的兼容性问题、导入风格、危险的字符串格式化及可能的本地化问题。

第2章 模块和库

导入系统

sys模块包含许多关于Python导入系统的信息。首先,当前可导入的模块列表都是通过sys.module变量才可以使用的。
它是一个字典,其中键(key)是模块名字,对应的值(value)是模块对象。

sys.module['os']

许多模块是内置的,这些内置模块在sys.buildin_module_names列出。

导入模块时,Python会依赖一个路径列表。这个列表存放在sys.path变量中,并且告诉Python去哪里搜索要加载的模块。
你可以在代码中修改sys.path,也可以修改环境变量PYTHONPATH,从而修改路径列表。

>>>import sys
>>>sys.path.append('/foo/bar')

$ PYTHONPATH=/foo/bar python
>>>import sys
>>>'/foo/bar' in sys.path
True

在sys.path中顺序很重要,因为需要遍历这个列表来寻找请求的模块。

也可以通过自定义的导入器(importer)对导入机制进行扩展。
导入钩子机制是由PEP302定义的。
它允许扩展标准的导入机制,并对其进行预处理,也可以通过追加一个工厂类到sys.path_hooks来添加自定义的模块查找器(finder)。
模块查找器对象必须有一个返回加载器对象的find_module(fullname,path=None)方法,这个加载器对象必须包含一个负责从源文件中加载模块的load_module(fullname)方法。

通过Hy的源码可以学习到。

Hy模块导入器

class MetaImporter(object):
    def find_on_path(self, fullname):
        fls = ["%/__init__.py","%s.py"]
        dirpath = "/".join(fullname.split("."))

        for pth in sys.path:
            pth = os.path.abspath(pth)
            for fp in fls:
                composed_path = fp % ("%s/%s" % (pth, dirpath))
                if os.path.exists(composed_path):
                    return composed_path

    def find_module(self, fullname, path=None):
        path = self.find_on_path(fullname)
        if path:
            return MetaLoader(path)

sys.meta_path.append(MetaImporter)

Hy模块加载器

class MetaLoader(object):
    def __init__(self,path):
        self.path = path


    def is_package(self,fullname):
        dirpath = "/".join(fullname.split("."))
        for pth in sys.path:
            pth = os.path.abspath(pth)
            composed_path = "%s/%s/__init__.py" % (pth, dirpath)
            if os.path.exists(composed_path):
                return True
        return False

    def load_module(self,fullname):
        if fullname in sys.modules:
            return sys.modules[fullname]

        if not self.path:
            return

        sys.modules[fullname] = None
        mod = import_file_to_module(fullname,self.path)#貌似是用的py_compile

        ispkg = self.is_package(fullname)

        mod.__file__ = self.path
        mod.__loader__ = self
        mod.__name__ = fullname

        if ispkg:
            mod.__path__ = []
            mod.__package__ = fullname
        else:
            mod.__package__ = fullname.rpartition('.')[0]

        sys.modules[fullname] = mod
        return mod

标准库

标准库可以参考这里
下面是一些必须了解的标准库模块。
* abc 提供抽象基类等功能。
* atexit 允许注册在程序退出时调用的函数
* argparse 提供解析命令行参数的函数。
* bisect 为可排序列表提供二分查找算法。
* calendar 提供一组与日期相关的函数。
* codecs 提供编解码数据的函数。
* collections 提供一组有用的数据结构。
* copy 提供复制数据的函数。
* csv 提供读写CSV文件的函数。
* datetime 提供用于处理日期和时间的类。
* fnmatch 提供用于匹配Unix风格文件名模式的函数。
* glob 提供用于匹配Unix风格路径模式的函数。
* io 提供用于处理I/O流的函数。
* json 提供用来读写JSON格式函数的函数。
* logging 提供对Python内置的日志功能的访问。可以参考这里
* multiprocessing 可以在应用程序中运行多个子进程。可以参考这里
* operator 提供实现基本的Python运算符功能的函数,可以使用这些函数而不是自己写lambda表达式。
* os 提供对基本的操作系统函数的访问。
* random 提供生成伪随机数的函数。。不能用在安全领域。
* re 提供正则表达式功能。
* select 提供对函数select()和poll()的访问,用于创建事件循环。
* shutil 提供对高级文件处理函数的访问。
* signal 提供用于处理POSIX信号的函数。可以参考这里
* tempfile 提供用于创建临时文件和目录的函数。可以参考这里
* threading 提供对处理高级线程功能的访问。可以参考这里
* urllib(以及Python2.x中的urllib2和urlparse)提供处理和解析URL的函数。
* uuid可以生成全局唯一标识符。

外部库

选择第三方库的检查列表。

  • Python3兼容。
  • 开发活跃。GithubOhloh通常提供足够的信息来判断一个库是否有维护者仍在工作。
  • 维护活跃。
  • 与各个操作系统发行版打包在一起。
  • API兼容保证。

对于外部库,不管它们多么有用,都需要注意避免让这些库和实际的源代码耦合过于紧密。否则,如果出了问题,你需要切换库,这很可能需要重写大量的代码。
更好的办法是写自己的API,用一个包装器对外部库进行封装,将其与自己的源代码隔离。

框架

有许多不同的Python框架可用于开发不同的Python应用。如果是Web应用,可以使用DjangoPylonsTurboGearsTornadoZope或者Plone
如果你正在找事件驱动的框架,可以使用Twisted或者Circuits等。

Doug Hellmann建议

当设计一人应用程序时,我会考虑用户界面是如何工作的,但对于库,我会专注于开发人员如何使用其API。
通过先写测试代码而不是库代码,可以让思考如何通过这个新库开发应用程序更容易一点儿。
我通常会以测试的方式创建一系统示例程序,然后依照其工作方式去构建这个库。
我还发现,在写任何库的代码之前先写文档让我可以全面考虑功能和流程的使用,而不需要提交任何实现的细节。它还让我可以记录对于设计我所做出的选择,以便读者不仅可以理解如何使用这个库,还可以了解在创建它时我的期望是什么。

建议自顶向下设计库和API, 对每一层应用单一职责原则这样的设计准则。
考虑调用者如何使用这个库,并创建一个API去支持这些功能。考虑什么值可以存在一个实例中被方法使用,以及每个方法每次都要传入哪些值。最后,考虑实现以及是否底层的代码的组织应该不同于公共API。

管理API的变化

在构造API时很难一蹴而就。API需要不断演化、添加、删除或者修改所提供的功能。
内部API可以做任意处理。
而暴露的API最好不要变化,但有时候不得不变化。

在修改API时要通过文档对修改进行详细地记录,包括:

  • 记录新的接口;
  • 记录废除的旧的接口;
  • 记录如何升级到新的接口。

旧接口不要立刻删除。实际上,应该尽量长时间地保留旧接口。因为已经明确标识为作废,所以新用户不会去使用它。在维护实在太麻烦时再移除旧接口。API变化的记录见下面示例。

class Car(object):
    def turn_left(self):
        """Turn the car left.
        .. deprecated::1.1
        Use :func:`turn` instead with the direction argument set to left
        """
       self.turn(direction='left') 
        
    def turn(self,direction):
        """Turn the car in some direction.
        
        :param direction: The direction to turn to.
        :type direction: str
        """
        #Write actual code here instead
        pass

使用Sphinx标记强调修改是个好主意。但你不要指望开发人员去读文档。
Python提供了一个很有意思的名为warings的模块用来解决这一问题。这一模块允许代码发出不同类型的警告信息,如PendingDeprecationWarningDeprecationWarning
这些警告能够用来通知开发人员某个正在调用的函数已经废弃或即将废弃。这样,开发人员就能够看到它们正在使用旧接口并且应该相应地进行处理。

使用示例:

warnings.warn("turn_left is deprecated, use turn instead",DeprecationWarning)

需要注意的是自Python2.7起,DeprecationWarning默认不显示了。
要显示出来,执行python时,需要加-W all选项。

第3章 文档

Python中文档格式的事实标准是reStructuredText,或简称reST。它是一种轻量级的标记语言(类似流行的Markdown),在易于计算机处理的同时也便于人类读写。Sphinx是处理这一格式最常用的工具,它能读取reST格式的内容并输出其他格式的文档。

项目的文档应该包括下列内容。

  • 用一两句话描述这个项目要解决的问题。
  • 项目所基于的分发许可。如果是开源软件的话,应该在每一个代码文件中包含相应信息。因为上传代码到互联网并不意味着人们知道他们可以对代码做什么。
  • 一个展示项目如何工作的小例子。
  • 安装指南。
  • 指向社区支持、邮件列表、IRC、论坛等的链接。
  • 指向bug跟踪系统的链接。
  • 指向源代码的链接,以便开发人员可以下载并立刻投入开发。

还应该包括一个README.rst文件,解释这个项目是做什么的。

Sphinx和reST入门

使用之前请先安装pip install sphinx(注意:如果你是在virtualenv环境中启的项目,也应该把sphinx安装在venv中。)
首先,需要在项目的顶层目录运行sphinx-quickstart。这会创建Sphinx需要的目录结构,同时会在文件夹doc/source中创建两个文件,一个是conf.py,它包含Sphinx的配置信息,另一个文件是index.rst,它将作为文档的首页。
然后就可以通过在调用命令sphinx-build时给出源目录和输出目录来生成HTML格式的文档:
sphinx-build doc/source doc/build
现在就可以打开doc/build/index.html了。

Sphinx模块

Sphinx是高度可扩展的:它的基本功能只支持手工文档,但它有许多有用的模块可以支持自动化文档和其他功能。例如,sphinx.ext.autodoc可以从模块中抽取rest格式的文档字符串(docstrings)并生成.rst文件。sphinx-quickstart在运行的时候会问你是否想激活某个模块,也可以编辑conf.py文件并将其作为一个扩展。

extensions = ['sphinx.ext.autodoc']

值得注意的是,autodoc不会自动识别并包含模块,而是需要显式地指明需要对哪些模块生成文档,类似下面这样(编辑index.rst文件):

.. automodule:: foobar
   :members:
   :undoc-members:
   :show-inheritance:

同时要注意以下几点。

  • 如果不包含任何指令, Sphinx不输出任何内容。
  • 如果只指定:members:,那么在模块/类/方法这一树状序列中未加文档的节点将被忽略,即使其成员是加了文档的。例如,如果给一个类的所有方法都加了文档,但这个类没有加文档,:members:除这个类及其方法。为发避免这种情况,要么必须为该类加上一个文档字符串,要么同时指定:undoc-members:。
  • 模块需要在Python可以导入的位置。通过添加.、..和/匮乏../..到sys.path中会对此有帮助。

autodoc可以将实际源代码中的大部分文档都包含进来,甚至还可以单独挑选某个模块或方法生成文档,而不是一个”非此即彼”的解决方案。通过直接关联源代码来维护文档,可以很容易地保证文档始终是最新的。
如果你正在开发一个Python库,那么通常需要以表格的形式来格式化你的API文档,表格中包含到各个模块的独立的文档页面的链接。sphinx.ext.autogen模块就是用来专门处理这一常见需要的。首先,需要在conf.py中启动它。

extensions = ['sphinx.ext.autodoc','sphinx.ext.autosummary']

现在就可以在一个.rst中加入类似下面的内容来自动为特定的模块生成TOC:

.. autosummary::
   mymodule
   mymodule.submodule

这会生成名为generated/mymodule.rst和generated/mymodule.submodule.rst的文件,其中会包含前面提到的autodoc指令。使用同样的格式,还可以指定希望模块API的哪部分包含在文档中。

通过特殊的doctest生成器,利用这个功能就像运行sphinx-build一样简单:

sphinx-build -b doctest doc/source doc/build

手动编写rst文件还是挺麻烦。不如直接在conf.py中写代码。自动生成.rst文件。

扩展Sphinx

针对其他HTTP框架,中Flask、Bottle和Tornado,可以使用sphinxcontrib.httpdomain。我个人的观点是,无论任何时候,只要能从代码中抽取信息帮助生成文档,都值得去做并且将其自动化。这比手工维护文档要好得多,尤其是可以利用自动发布工具(如Read The Docs)的时候。

第4章 分发

简史

  • distutils 是标准库的一部分,能处理简单的包的安装。
  • setuptools, 领先的包安装标准,曾经被废弃但现在又继续开发。
  • distribute 从0.7版本开始并入了setuptools。
  • distutils2(也称为packaginng)已经被废弃。
  • distlib 可能将来会取代distutils。

setuptools是目前分发库的主要选择,但在未来要对distlib保持关注。

使用pbr打包。

pbr使用的setup.py文件类似下面这样。

import setuptools
setuptools.setup(setup_requires=['pbr'],pbr=True)

就两行代码,非常简单。实际上安装所需要的元数据存储在setup.cfg文件中。

[metadata]
name=foobar
...
classifier = 
    Development Status :: 4 - Beta
    ...
[files]
packages = 
    foobar

Wheel格式

由setuptools引入的Egg格式只是一个有着不同扩展名的压缩文件。这一问题在官方安装标准最终敲定之后变得更加复杂,官方标准同已有标准并不兼容。

这了解决这些问题,PEP 427针对Python的分发包定义了新的标准,名为Wheel。已有wheel工具实现了这一格式。

python setup.py bdist_wheel

这条命令将在dist目录中创建.whl文件。和Egg格式类似,一个Wheel归档文件就是一个有着不同扩展名的压缩文件,只是Wheel归档文件不需要安装。可以通过在包名的后面加一个斜杠加载和运行代码:

$python wheel-0.21.0-py2.py3-none-any.whl/wheel -h
usage: wheel [-h]
    {keygen,sign,unsign,verify,unpack,install,install-scripts,convert,help}
positional arguments:
[...]

这其实是python自身支持的。

python foobar.zip

这等同于:

PYTHONPATH=foobar.zip python -m __main__

换句话说,程序中的main模块会自动从main.py中被导入。也可以通过在斜杠后面指定模块名字来导入__main__,就像Wheel:

python foobar.zip/mymod

这等同于:

PYTHONPATH=foobar.zip python -m mymod.__main__

包的安装

目前比较流行的pip。

pip install --user voluptuous

指定–user可以让pip把包安装在home目录中。这可以避免将包在系统层面安装而造成操作系统目录的污染。
提示:通过在~/.pip/pip.conf文件中添加download-cache选项,每次下载之前会先检查缓存。对于多个项目的虚拟环境有用。

可以用pip freeze 命令列出已安装的包。建议导入到requirements.txt
然后在其它地方用pip install -r requirements.txt 就可以重新下载软件包。

和世界分享你的成果

一旦有了合适的setup.py文件,很容易生成一个用来分发源代码tarball。只需要使用sdist命令即可。
python setup.py sdist
这会在你的源代码树的dist目录下创建一个tarball,这可以用来安装你的软件。

发布步骤:
1. 打开~/.pypirc文件并加入下列行:(用的测试服务器,正式发布需要修改)

[distutils]
index-servers = 
    testpypi

[testpypi]
username = <your username>
password = <your password>
repository = https://testpypi.python.org/pypi
  1. 在索引在注册项目。
python setup.py register -r testpypi
  1. 上传源代码发分tarball以及一个Wheel归档文件:
python  setup.py sdist upload -r testpypi
python setup.py bdist_wheel upload -r testpypi
  1. 测试。通过pip以及指定-i参数,可以测试是否上传成功。
pip install -i https://testpypy.python.org/pypi ceilometer
  1. 测试成功,就可以上传项目到PyPI主服务器了。步骤和前4一样。只是需要修改下配置文件~/.pypirc
[distutils]
index-servers = 
    pypi
    testpypi

[pypi]
username = <your username>
password = <your password>

[testpypi]
repository = https://testpypi.python.org/pypi
username = <your username>
password = <your password>

分别运行register和upload并配合参数-r pypi就能正确地将你的包上传以PyPI服务器了。

扩展点

可视化的入口点

要看到一个包中可用的入口点的最简单方法是使用一个叫entry_point_inspector的包。
安装后,它提供了名为epi的命令,可以从终端运行并能交互地发现某个安装包的入口点。

epi group list

输出结果:

Name
babel.checkers
babel.extractors
cliff.formatter.completion
cliff.formatter.list
cliff.formatter.show
console_scripts
distutils.commands
distutils.setup_keywords
egg_info.writers
epi.commands
lingua.extractors
paste.server_runner
pygments.lexers
python.templating.engines
setuptools.installation
stevedore.example.formatter
stevedore.test.extension

这个列表包含了console_scripts。
执行下列命令获得更多结果。

epi group show console_scripts

输出结果:

Name Module Member Distribution Error
wheel wheel.tool main wheel 0.24.0
sphinx-quickstart sphinx.quickstart main Sphinx 1.5.2
sphinx-autogen sphinx.ext.autosummar main Sphinx 1.5.2
y.generate
sphinx-build sphinx main Sphinx 1.5.2
sphinx-apidoc sphinx.apidoc main Sphinx 1.5.2
easy_install-3.5 setuptools.command.ea main setuptools 34.0.2
sy_install
easy_install setuptools.command.ea main setuptools 34.0.2
sy_install
pygmentize pygments.cmdline main Pygments 2.2.0
pip3.5 pip main pip 9.0.1
pip3 pip main pip 9.0.1
pip pip main pip 9.0.1
pbr pbr.cmd.main main pbr 1.10.0
mako-render mako.cmd cmdline Mako 1.0.6
gunicorn gunicorn.app.wsgiapp run gunicorn 19.4.5
gunicorn_paster gunicorn.app.pasterap run gunicorn 19.4.5 No module named
p ‘paste’
gunicorn_django gunicorn.app.djangoap run gunicorn 19.4.5
p
epi entry_point_inspector main entry-point-inspector
.app 0.1.1
pybabel babel.messages.fronte main Babel 2.3.4
nd
alembic alembic.config main alembic 0.8.10

使用控制台脚本

大多数项目都会有下面这样几行代码:

#!/usr/bin/python
import sys
import mysoftware

mysoftware.SomeClass(sys.argv).run()

这实际上是一个理想情况下的场景:许多项目在系统路径中会有一个非常长的脚本安装。但使用这样的脚本有一些主要的问题。

  • 没办法知道Python解释器的位置和版本。
  • 安装的二进制代码不能被其他软件或单元测试导入。
  • 很难确定安装在哪里。
  • 如何以可移植的方式进行安装并不明确(如是Unix还是Windows)。

setuptools有一个功能可以帮助我们解决这些问题,即console_scripts。console_scripts是一个入口点,能够用来帮助setuptools安装一个很小的程序到系统目录中,并通过它调用应用程序中某个模块的特定函数。

设想一个foobar程序,它由客户端和服务器端两部分组成。这两部分各自有自己独立的模块–foobar.client和foobar.server。

foobar/client.py

def main():
    print("Client started")

foobar/server.py

def main():
    print("Server started")

接下来可以在根目录添加下面的setup.py文件。

setup.py

from setuptools import setuptools
setup(
    name="foobar",
    version="1",
    author="Julien Danjou",
    author_email="julien@danjou.info",
    packages=["foobar"],
    entry_points={
        "console_scripts":[
            "foobard = foobar.server:main",
            "foobar = foobar.client:main",
        ]
    })

使用格式package.subpackage:function可以定义自己的入口点。

当运行python setup.py install时,setuptools会创建下面所示的脚本。

#!/usr/bin/python
# EASY-INSTALL-ENTRY-SCRIPT: 'foobar==1','console_scripts','foobar'
__requires__ = 'foobar==1'
import sys
from pkg_resources import load_entry_point

if __name__ == '__main__':
    sys.exit(load_entry_point('foobar==1','console_scripts','foobar')())

这段代码会扫描foobar包的入口点并从console_scripts目录中抽取foobar键,从而定位并运行相应的函数。

使用插件和驱动程序

可以使用pkg_resources从自己的Python程序中发现和加载入口点文件。
在本节中,我们将创建一个cron风格的守护进程,它通过注册一个入口点到pytimed组中即可允许任何Python程序注册一个每隔几秒钟运行一次的命令。该入口点指向的属性应该是一个返回number_of_seconds和callable的对象。

下面是一个使用pkg_resources发现入口点的pycrond实现。

pytimed.py

import time
def main():
    seconds_passed = 0
    while True:
        for entry_point in pkg_resources.iter_entry_points('pytimed'):
            try:
                seconds, callabel = entry_point.load()
            except:
                pass
            else:
                if seconds_passed % seconds == 0:
                    callable()
        time.sleep(1)
        seconds_passed += 1

现在写另一个Python程序,需要周期性地调用它的一个函数。
hello.py

def print_hello():
    print('Hello,world!')
    
def say_hello():
    return 2, print_hello

使用合适的入口点注册这个函数。

setup.py

from setuptools import setup

setup(
    name="hello",
    version="1",
    packages=["hello"],
    entry_points = {
        "pytimed":[
            "hello = hello:say_hello",
        ],
    },)

现在如果运行pytimed脚本,将会看到屏幕上每两秒钟打印一次”Hello, world!”

>>> import pytimed
>>> pytimed.main()
Hello,world!
Hello,world!
Hello,world!
...

这一机制提供了巨大的可能性:它可以用来构建驱动系统、钩子系统以及简单而通用的扩展。
在每一个程序中手动实现这一机制是非常繁琐,不过幸运的是,已经有Python库可以处理这部分无聊的工作。

stevedore基于我们在前面例子中展示的机制提供了对动态插件的支持。使用stevedore实现上面的功能。

pytimed_stevedore.py

from stevedore.extension import ExtensionManager 
import time

def main():
    seconds_passed = 0
    while True:
        for extension in ExtensionManager('pytimed',invoke_on_load=True):
            try:
                seconds, callable = extension.obj
            except:
                pass
            else:
                if seconds_passed % seconds == 0:
                    callable()
        time.sleep(1)
        seconds_passed += 1

第5章 虚拟环境

关于虚拟环境的,倒是到处可见。我之前有过篇文章,总结了下。Python虚拟环境virtualenv

第6章 单元测试

单元测试,我得推荐下Flask Web开发 基于Python的Web应用开发实战,这书里的代码有好多。可以参考下。
这章单独放到了Python单元测试

第7章 方法和装饰器

关于方法和装饰器,我觉得看完python学习手册就可以了。讲的是丰富详细和细致。
综合了下,写了篇文章python方法和装饰器

第8章 函数式编程

之前不知道yield的send用法,这次知道了。
同样知道了不建议使用lambda(我之前就喜欢用lambda),而是可以用functools.partial和operator。
也知道了itertools提供了强大工具。
文章已发布到Python函数式编程

第9章 抽象语法树

这个东东是第一次接触。其它书里也没有看到。
建议学学。作者还提到了hy,使用python实现的lisp方言。
lisp是我打算学的东西。在Python学到一定程度后,我会学会它。
不想看书,看简单内容的可以看这里Python抽象语法树

第10章 性能与优化

过早地优化是万恶之源。
用好了Python,你不需要自己去实现各种数据结构。
譬如dict的get方法本身就提供了key不存时,返回默认值的功能。dict.get(key,default)
譬如两个set()相减是可以求得差集的。
譬如collections.defaultdict结构可以提供key不存在时,自动构造值的功能,而不是抛KeyError。
此外,collections模块提供了一些新的数据结构用来解决一些特定问题,如OrderedDict或者Counter。

Python性能分析有cProfile,timeit。
配合cProfile和pyprof2calltree可以图像化展示。
通过dis模块可以反编译Python代码,从而看到更多细节的东西。

Python已经提供了很多有用的数据结构,你应该去了解他,然后直接用,而不是自己实现一个。
譬如 说bisect模块,其包含了二分查找算法。
还有blist和bintree。

通过使用Python类的__slots__属性可以将内存使用率提升一倍,这意味着在创建大量简单对象时使用__slots__属性是有效且高效的选择。

namedtuple就是利用__slots__实现的限制属性的方法。
namedtuple继承自tuple,并增加了__slots__来限制类属性,而属性的访问其实是利用的property。

从Python3.3开始,functools模块提供了一个LRU缓存装饰器。它提供了对函数结果的内存缓存,该模块还提供了对缓存命中、缺失等的统计。

如果你觉得CPython比较慢,可以考虑用PyPy。它声称比CPython快3倍。不过他同样有GIL。而且你决定要用的话,最好一开始就用,以避免在后期支持时可能带来的大量工作。

最后介绍了memoryview技术。针对切片操作会复制整个内容从而导致的内存低效。
对于实现了缓冲区协议的对象,可以使用其memoryview类的构建函数去构造一个新的memoryview对象,它会引用原始的对象内存。

对详情感兴趣的可以移步Python专题之性能与优化

第11章 扩展与架构

一个应用程序的可扩展性、并发性和并行性在很大程度上取决于它的初始架构和设计的选择。如你所见,有一些范例(如多线程)在Python中被误用,而其他一些技术(如面向服务架构)可以产生更好的效果。

由于GIL的存在,在Python中用多线程并不是个好主意,可以考虑多进程和事件驱动开发模型。

关于用哪个事件驱动的包,有如下建议:

  1. 只针对Python2,可以考虑基于libev的库,如pyev
  2. 如果目标是同时支持Python2和Python3,最好使用能同时支持两个版本的库,如pyev。
  3. 如果只针对Python3, 那就用asyncio。

关于面向服务架构的建议:

  1. 对外的API使用HTTP服务。最好是REST风格的。
  2. 对内的API使用RPC服务。可以考虑AMQ协议。

使用消息队列,可以把服务做成分布式的。推荐的是ZeroMQ。

详情可以参考Python专题之扩展与架构

第12章 RDBMS和ORM

介绍了一下RDBMS和ORM的概念。
在写代码时,应该把RDBMS的数据模型考虑进去。
在Python中用的多的ORM库是SQLAlchemy。 管理数据库升降级的是alembic。
最后建议了一下ORM的使用时机。
有兴趣的话可以看下Python专题之RDBMS和ORM

第13章 Python3支持策略

关于移植应用的官方文档(http://zeromq.org/)是有的,但不建议不折不扣地参考它。

最好还是兼容py2和py3,然后有够用的单元测试。
通过tox,来测试两个版本。
tox -e py27, py35
根据提示的错误进行修改,重新运行tox,直到所有测试都通过为止。
Porting to Python3这本书给出了要支持Python3所需做修改的良好概述。

有个库six,提供了py2和py3的兼容写法,如要同时支持,可以考虑。
更多细节参考Python3支持策略

第14章 少即是多

单分发器

这个略了,lisp方面的概念,以后再了解。

上下文管理器

Python2.6引入的with语句。
实现了上下文管理协议的对象就能使用with语句。open函数返回的对象就支持这个协议。

with open("myfile", "r") as f:
    line = f.readline()

open返回的对象有两个方法,一个称为__enter__,另一个称为__exit__。它们分别在with块的开始和结束时被调用。

简单实现示例:

class MyContext(object):
    def __enter__(self):
        pass
        
    def __exit__(self, exc_type, exc_value, traceback):
        pass

这个可以参考python学习手册里描述的,摘抄如下

with/as语句的设计是作为常见try/finally用法模式的替代方案。就像try/finally语句,with/as语句也是用于定义必须执行的终止或”清理”行为,无论处理步骤中是否发生异常。
不过,和try/finally不同的是,with语句支持更丰富的基于对象的协议,可以为代码块定义支持进入和离开动作。

with语句的基本格式如下。

with expression [as varibalbe]:
    with-block

在这里的expression要返回一个对象,从而支持环境管理协议。

环境管理协议
以下是with语句实际的工作方式。

  1. 计算表达式,所得到的对象称为环境管理器,它必须有__enter____exit__方法。
  2. 环境管理器的__enter__方法会被调用。如果as子句存在,其返回值会赋值给as子句中的变量,否则,直接丢弃。这里需要重点注意,很多人在这里会犯错。
  3. 代码块中的嵌套的代码会执行。
  4. 如果with代码块引发异常,__exit__(type,value,traceback)方法就会被调用(带有异常细节)。这引起也是由sys.exc_info返回的相同值。如果此方法返回值为假,则异常会重新引发。否则,异常会终止。正常情况下异常是应该被重新引发,这样的话才能传递到with语句之外。 如果with代码块没有引发异常,__exit__方法依然会被调用,其type、value以及traceback参数以None传递。

contextlib标准库提供了contextmanager, 通过生成器构造__enter____exit__方法,从而简化了这一机制的实现。可以使用它实现自己的简单上下文管理器,如下所求:

import contextlib

@contextlib.contextmanager
def MyContext():
    yield

作者提供了个案例,为了防止程序员忘记在流水线对象中最后调用flush()方法。
使用了上下文管理器。

import contextlib

class Pipeline(object):
    def _publish(self, objects):
        pass
        
    def _flash(self):
        pass
    
    @contextlib.contextmanager
    def publisher(self):
        try:
            yeild self._publish
        finally:
            self._flush()

现在用户使用以下代码就好了。

pipeline = Pipeline()
with pipeline.publisher() as publisher:
    publisher([1,2,3,4])

另外,是可以同时使用多个上下文管理器的。

同时打开两个文件

with open("file1", "r") as source:
    with open("file2", "w") as destination:
        destination.write(source.read())

with语句可以支持多个参数的。上述代码可以改为

with open("file1", "r") as source, open("file2", "w") as destination:
    destination.write(source.read())

发表评论

电子邮件地址不会被公开。 必填项已用*标注