Full Stack Python logo Full Stack Python

全部主题 | Blog | 时讯 | @fullstackpython | Facebook | 源码

简介

你想深入学习 Python 编程语言。 你对语法已经驾轻就熟了。 有好几次，当在学习条件语句、 for 循环、类以及玩转开源库（正是这些库让 Python 变得如此强大）时，你突然领悟到了它的精义。

现在你想用已掌握的Python知识来做一个真正的应用，一个可以在网上展示，或者能为他人提供服务的应用。 那么你算来对地方了，Full Stack Python就是这样一个网站，在这里你能学到如何创建、部署并且运行生产级Python web应用的一切知识。

学习编程

学习如何来编程就是理解如何将想法转换成源代码，再在计算机上运行以实现一个或多个目标。

学习如何编程，包含很多个步骤：

  • 设置 开发环境
  • 选择一门编程语言，例如 Python
  • 掌握本语言的语法和命令
  • 写代码时，通常要用到 第三方库 和 框架
  • 运行程序
  • 调试错误和异常结果
  • 为目标用户 部署 并运行应用

我怎样才能学好编程呢？

关于应该如何开始学习编程存在好几种思想学派。 有一种思想学派认为像汇编语言或 C 语言等低级编程语言最适合作为启蒙语言，因为它们要求 新手们编写他们自己的数据结构，学习指针，并且经常要求自行解决计算机科学中的难题。

当然这种“低层优先”的哲学存在些许合理性，因为它迫使初学者在移到像 Web 和移动应用开发等 更高级的主题前先牢固掌握好基础知识。这种哲学理念通常在大学计算机科学教学计划中使用。

“低层优先“型方法的学习过程分为

  • 理解编程语言的各个特性（类型系统、语法）
  • 编写并且能够使用多种数据结构（堆栈、队列）
  • 掌握常用算法（快速排序、二分查找）

另一种思想学派认为新手们应该通过参与实际项目来提升自己，项目可以是 用任何编程语言编写的，关键是要能足够引起他们的兴趣以使他们能坚持 解决那些不可避免会出现的难题。

在这种”基于项目“的思想流派中，完成的项目数量是进步的基本单元，这些项目扩展了程序员的能力。 要想实现额外的提升，可以通过参与开源项目，和经验丰富的导师一起工作来学习他们如何改善他们自己的项目等途径获得。

我应该先学 Python 吗？

在基于项目的方法中，Python 是个不错的选择，因为它有大量 免费和低成本的入门资料， 并且很多资料中都能找到可用作进一步开发的例子项目。

需要注意的是，对于一个有抱负的程序员来说， Python 是否是一门不错的首选语言这个问题 是非常主观的，并且这些方法并不相互排斥。Python 在大学中也被广泛用于教学，以便 解译计算机科学中的基本概念，这相较与项目优先的方法，似乎更符合”低层优先“的哲学了。

总之，Python 作为学习编程的首选语言是否适合，取决于你自己的学习风格和感觉。 如果你觉得 Ruby 或者 Java 看起来比 Python 更容易学习，那就选它们吧。 编程语言，以及围绕它们的生态系统，都是人造结构。找到一门看起来符合你个人 风格的语言然后尝试下，要知道无论你选择哪种语言，你都需要投入很多个日日夜夜才能 成为一个合格的软件开发人员。

为什么要用 Python？

Python 有丰富的软件库资源，包括开源数据分析工具、 Web 框架、测试工具等， 正是这些库资源使 Python 生态系统成长为最大的编程社区之一。

Python 社区提供了丰富的 入门资料， 因此对于初学者来说，它是一门相当易学的语言。 Python 在大学里也广泛被用于教学，并且也在像 树莓派 那样的 对于初学者来说易于上手的设备上使用。

如果你想了解为何要选用 Python，你应该也看下 最佳 Python 资源 和 “全栈”指的是什么.

Python 编程语言的流行度

现在有好几种编程语言流行排行榜。 尽管我们可能会指责这些统计不太准确，但是所有的排行榜上都将 Python 列为一门 Top10 的编程语言—如果还未进前五的话。

IEEE 在 2016 年 将 Python 列为 Top3 的编程语言, 而 RedMonk 2015 年 1 月排行榜 将 Python 列为第 4 名。

TIOBE 指数, 一份运营了相当长时间的语言排行榜上，Python 总是稳稳地排在第 8 名。

编程语言流行指数 (PYPL)， 一份基于谷歌趋势上的搜索关键字分析数字的排行榜，将 Python 列为第 3 名。（译者注：2016年5月已经是第 2 名了。）

GitHut, 一个Github 语言流行度可视化网站上，总的来说也将 Python 订在第 3 名。

这些排行榜提供了语言流行度的大体度量。 它们不是想作为一种精确测量工具来确切地统计出有多少开发人员使用某种语言。 不过，纵观以上的数据可以看出， Python 一直保持为一门稳定的编程语言，并且 其生态系统也在不断成长。

为什么编程语言的选择很重要？

每门编程语言都有自己独特的生态系统、文化和哲学。 如果你的编程方法不遵循你选择的编程语言的哲学，你将很难融入社并且会感到很难学习。

Python 的文化价值体现在 开源软件活动、 社区在 地方性、国内和国际性的事务 上的参与度以及 乐与指导初学者等方面。 如果这些价值对你/或者你的组织同样重要，那么 Python 就很适合你。

Python 非常注重语言哲学，这种哲学甚至被嵌入进了语言本身，例如当解译器执行 "import this"后 会显示 Python 之禅的内容。

  1. >>> import this
  2. The Zen of Python, by Tim Peters
  3.  
  4. Beautiful is better than ugly.
  5. Explicit is better than implicit.
  6. Simple is better than complex.
  7. Complex is better than complicated.
  8. Flat is better than nested.
  9. Sparse is better than dense.
  10. Readability counts.
  11. Special cases aren't special enough to break the rules.
  12. Although practicality beats purity.
  13. Errors should never pass silently.
  14. Unless explicitly silenced.
  15. In the face of ambiguity, refuse the temptation to guess.
  16. There should be one-- and preferably only one --obvious way to do it.
  17. Although that way may not be obvious at first unless you're Dutch.
  18. Now is better than never.
  19. Although never is often better than *right* now.
  20. If the implementation is hard to explain, it's a bad idea.
  21. If the implementation is easy to explain, it may be a good idea.
  22. Namespaces are one honking great idea -- let's do more of those!

有关为什么要用 Python 的更多观点

Python 2 还是 3？

Python 编程语言目前正处在从版本 2 升级到版本 3 的漫长过渡期中。初学者通常会有到底该学哪个版本的问题。Python 3 最初是在 2008 年发布的，但目前仍不是作为默认版本安装在很多操作系统上，听到这些很令人困惑。

告诉你个好消息： 无论你从哪个版本开始学起都不会有问题的。尽管这两个版本在 unicode 处理和语法上有些许不同，但对于其它大部分来说，你先学的 Python 2 然后再学 Python 3 不会又要从头学起。

我个人推荐初学者现在应该从 Python 3 开始学起。因为现在已经能找到足够多的 资料 来指导我们从零基础开始学习 Python 3。

但是，如果你对 DevOps 型工作感兴趣，并且使用像 Ansible 或 Fabric 等 配置管理工具，那么你还是应该用 Python 2，因为这些工具还不支持 Python 3。如果你知道项目中必须要用到某些库，先在 Python 超能墙 网站上查下兼容性。如果你用 Django 的话，也有个类似的网站叫 常用 Django 包的 Python 3 兼容性。

从 Python 2 转到 3 的相关资源

企业 Python

关于 Python 等动态类型语言的一个错误观念认为它们用于构建企业级应用还不太可靠。然而，几乎所有的商业和政府机构都已经或多或少使用 Python 了，无论是作为不同的应用程序之间的粘合代码还是构建应用程序本身。

什么是企业软件？

企业软件是为机构的需求而非个人的需要创建的。为企业编写的软件通常需要与历史遗留系统，例如现有的数据库和单机应用程序进行整合。通常也需与 轻量级目录访问协议 (LDAP) 和 活动目录 (AD) 这样的认证系统整合。

机构开发企业软件，包含大量的定制需求以适应其运营模式的具体需要。 因此，由于组织内部不同派系之间为争取软件能优先解决其各自的需求而罔顾他人的斗争，往往会导致软件开发过程变得异常复杂。

因企业软件建设过程涉及到许多利益相关者而产生的复杂局面，导致了大量的预算以及由机构中非技术人员执行的过度审查。而这些非技术人员通常在编程语言和框架的选择上妄加评断—而他们是不应该做出技术设计决策的。

为什么企业环境中存在对 Python 的误解？

传统大型机构使用静态类型语言如 C++、 .NET 和 Java 构建企业软件。上世纪80年代和90年代的大公司，如微软、Sun 和 甲骨文将这些语言标榜为”企业级“语言进行市场销售。其直接后果是，其它语言受到了冷落，并被看作不适应 CIO 的艰难技术环境。除了 Java、C++ 和 .NET，其它语言都被认为是有风险的，因而不值得投资使用。

此外， 在 20 世纪 90 年代， ”脚本语言“如 Python、Perl 和 Ruby 都还不够强大， 因为他们的核心标准库都仍处在开发阶段。像 Django、Flask 以及 Rails (Ruby 语言) 这样的框架还没有产生。 那时的网络还刚刚开始，大多数企业应用还只是 Windows 系统上的桌面应用程序。 而 Python 根本不适合用于那样的环境。

为什么说 Python 现在适合于构建企业级软件？

从本世纪初到现在，许多动态类型语言及其生态系统有了很大的发展，而且在某些方面往往超越了其它生态系统。Python、 Ruby 以及其它之前被冷落的语言现在有了更广阔并且维护良好的开源生态系统，它们受到独立开发者和大公司的支持，包括微软、IBM、谷歌、Facebook、Dropbox、Twilio等等。

Python的开源库，特别是针对Web开发和数据分析的那些代码，对于任何语言来说，都是维护良好功能完备的典范。

同时，一些传统的企业软件开发语言如 Java 因受主要企业支持者投资不足影响，已经衰落了。当 Oracle 于2009 年收购 Sun 时，在 Java 中增加新的语言特性以升级到 Java 7 的计划已被拖了很多一段时间。Oracle 还在 Java 安装包中捆绑了不需要的广告软件，而 Python 社区绝不会容忍这种情况发生，因为这门语言是开源的，并不受某一公司控制。

其他的生态系统，如微软的 .NET 平台则发展的较好。微软在整个新世纪的早期阶段对 .NET 平台进行了持继投资以促进及发展。

然而，微软的企业产品，它们的应用程序服务器和相关软件往往有昂贵的许可费用。此外，微软也是开源运动的主要支持者， 尤其对于 Python 来说，他们的 Visual Studio Python 工具集 提供了一流的 开发环境。

最终的结果是企业软件开发在过去的几十年中发生了翻天覆地的变化。CIO和技术管理人员，如果想继续为他们的业务侧客户提供商业价值的话，不再能忽视 Python 及伟大的开源社区在企业软件开发领域所取得的进展了。

开源企业 Python 项目

  • 由美国政府机构 消费者金融保护局 (CFPB)主导的 Collab 是一个为大型机构服务的企业内联网及协作平台。该项目目前已投入运行，并被成千上万的 CFPB 员工使用着。

  • Pants 是一个针对大型机构软件项目的构建系统，这些项目通常包含许多个由不同的编程语言编写的子项目 。

企业 Python 软件开发资源

Python Community

The Python programming language has a global community with millions of software developers who interact online and offline in thousands of virtual and physical locations.

Who drives the Python community?

There are tens of thousands of Python developers who help steer the community with local, regional and global events. Most, if not all of them, are members of the Python Software Foundation (PSF). The PSF is a 501(c)(3) non-profit with the mission to "promote, protect, and advance the Python programming language, and to support and facilitate the growth of a diverse and international community of Python programmers."

Python community resources

Best Python Podcasts

The Python community produces an incredible wealth of free and low cost resources for both new and experienced software developers. These great resources include several Python podcasts that are released on a regular schedule.

Note that podcasts that have not been updated in the past twelve months are not included on this page.

Favorite podcast episodes

Here are a list of my favorite episodes from various Python podcasts before we dive into entire podcast recommendations in the next section. Dig into these episodes to get a feel for various personalities and styles in podcast presentation.

Python-specific podcasts

  • Talk Python to Me focuses on the people and organizations coding on Python. Each episode features a different guest interviewee to talk about his or her work.

  • Podcast.init is another regular podcast that presents stories about Python and interviews "with the people who make it great".

  • Test and Code Podcast focuses on testing and related topics such as mocking and code metrics.

  • Python Bytes is a new podcast from the creators of the above mentioned "Talk Python to Me" and "Test and Code Podcast".

  • Import This is an occasional podcast from Ken Reitz and Alex Gaynor with very in-depth interviews with influential Python community members.

If you prefer to learn by reading check out the best Python resources page or view all topics.

General software development podcasts

  • Embedded.fm

  • The Changelog

  • Full Stack Radio

  • Exponent is not a software development podcast but it covers the intersection of corporate strategy and technology in an in-depth way that allows me to better understand the decisions businesses make when building and releasing software. I listen to every episode (at 1.5x speed) and it's well worth the 45 to 60 minutes spent listening to Ben Thompson and James Allworth go deep on a weekly topic.

最佳 Python 资源

Python 社区善于分享资源，并且乐与帮助初学者学习用这门语言编程。当前已经有很多资源了，虽然很难知道如何才能找到它们。

本页整理出了最佳的常用 Python 资源，并附有其提供给读者的相关资源描述。

如果你更喜欢通过观看视频来学习，请查看 最佳 Python 视频。 你还可能对编写代码要用到的 开发环境 也感兴趣。

初学编程者

如果你是刚开始学习第一门编程语言，那么下面的这些资料就是特意为你准备的。如果你是作为第二门或之后的语言而学习 Python 的开发人员，应该跳到下一节“有经验的开发者”。

  • 想同时了解有关 Python、 Django 和 Flask 的入门知识，考虑下购买由 Fletcher、 Michael 和 Jeremyat 三位专家讲授的 Real Python 课程及其资料。

  • 这份 5 分钟视频 解释了为何在着手创建项目或解决问题前，要先用编程思想进行思考。要先对这些项目和问题进行研究，而不是一开始就认定使用由你朋友推荐的某门编程语言。

  • CS for All 是一本由哈威穆德学院（Harvey Mudd College）多位教授执笔的开源图书。该学院致力于使用 Python 教授计算机科学的基本知识。这本书通俗易懂，非常适合编程初学者。

  • 如果你之前从来没有写过代码，那么看下由 Laurence Bradford 编写的教程 Learn To Code with Me 的 开始 页。 她还难得地将学习过程逐步分解，这对于那些从哪里开始学习都毫无头绪的初学者来说是相当有帮助的。

  • Learn Python the Hard Way 是一本由 Zed Shaw 写的免费图书。

  • Twilio 博客的 Python 项目标签页 上经常会上传一些有趣的教程，你可以通过这些教程来学习 Python，比如 用 Flask 和 Redis-Queue 制作国际空间站追踪器、 用 Flask 和 WebSockets 制作交互的演示文稿 以及 用 OpenCV 制作火星人照片。

  • Dive into Python 3 是一本开源图书，以创作共享许可授权（Creative Commons license），提供 HTML 和 PDF 格式的版本。

  • A Byte of Python 是一本适合 Python 语言初学者的教程。

  • Code Academy 网站上的 Python track 也是针对初学者的。

  • Introduction to Programming with Python 讲述了 Python 的基本语法和控制结构。在这本免费图书中，针对每个主题都有大量的代码示例。

  • Google 汇编了大量的资料和课程，如果想成为 专业程序员 的话，你应该仔细阅读并认真学习下。这些资源不仅对 Python 初学者很有帮助，对每一位想在软件业中拥有成功的职业生涯的开发人员也不无裨益。

  • 由 O'Reilly 出版的图书 Think Python: How to Think Like a Computer Scientist 能在网络上找到 HTML 格式的免费版本。

  • Python Practice Book 是一本有关 Python 实践练习的图书，能帮助你学习基本的语言语法。

  • 想知道能通过哪些项目来学习编程吗？看下 推荐给 Python 初学者的 5 个 编程项目。

  • 在优达学城上（Udacity）有一堂由 Reddit的一位创始人讲授的课程， 讲述了如何 使用 Python 创建一个 blog 系统。这是通过实践学习 Web 开发相关概念的很好的入门教程。

  • 我写过一篇简短的博客叫 学习 Python，想学习编程的非技术人员可能会觉得有用。

  • Python for you and me 通俗易懂，内容包含 Python 语法及主要语言特性等知识。书本的最后还包含了一篇简短教程，指导程序员创建他们的首个 Flask Web 应用 。

特定行业的 Python

Python 对很多行业都很有用。如果你想在某一特定领域使用 Python，那么下面的这些教程可能最适合你。

  • Python for Social Scientists 上包含了一套大学课程的教科书、课程大纲和幻灯片，该课程教授社会科学工作者如何在职业生涯中使用 Python。

  • Practical Business Python 是一博客文章，覆盖的内容包括如何自动创建大型 Excel 表格，或者如何用 Microsoft 办公文件中的数据进行分析等主题。

  • Python for the Humanities 是一套有关 Python 基础知识和文本处理知识的教材和课件。注意：如果你之前从没用过 Python, 你会发现除第一章之后的其它章节内容都很难掌握，因此你可能需要结合其它一些 Python 资料来一起学习。

  • Practical Python for Astronomers 提供了开源的研讨会资料，以指导学习天文学的学生使用 Python 进行数据分析。

有经验的开发者初学 Python

如果你已经会用其它语言编程的话，使用下面的这些资源能更快地提高学习速度，因为它们在阐述入门性知识时更加地简洁。

  • Learn Python in y minutes 对 Python 语言进行了简单的介绍。如果你之前已经有开发经验，并且想快速掌握这本语言是如何组织的话，会感觉这份指南特别有用。

  • 熟悉其它语言的开发人员通常会难以接受 Python 的代码风格。一定要看看 PEP8 代码风格指南和 The Elements of Python Style，以确保了解 Python 社区的标准。

  • How to Develop Quality Python Code 是一篇有关开发环境、应用依赖包及项目结构等知识的非常不错的文章。

  • Python module of the week 上的各章节是你快速学习标准库的很好的资料。由于 Python 从 2.x 升级到 3 而引起的修正内容，Doug Hellmann 现在也进行了相应的更新。

  • Kenneth Reitz 写的 The Hitchhiker’s Guide to Python 包含了有关 Python 编程语言本身及其社区的丰富信息。

  • Composing Programs 阐述了如何用 Python 3 创建编译器。如何你不仅想更加深入地学习 Python 语言，还想了解编译器的工作原理，那么这是一份不错的资料。

  • Good to Great Python Reads 汇集了网络上有关 Python 的中高级文章，这些文章主要讲述 Python 语言自身的细节知识。

视频、屏幕录像和演示文稿

会议的相关视频及屏幕录像资源都列在 [最佳 Python 视频]页上。

精选的 Python 包列表

  • awesome-python 是一份有关 Python 框架、库和软件等资源的列表，这份列表相当精彩，我刚开始学时如果有这份列表就好了。

  • easy-python 和 awesome-python 类似，但它不仅仅是个 Git 代码库，它还是个 Read the Docs 格式的网站。

播客

  • Talk Python to Me 是一个针对那些用 Python 写代码的个人和组织的播客。每一集都邀请不同的采访者来讲述他或她的工作。

  • Podcast.init 是另一个“关于 Python 以及相关人物”的播客。

时讯

  • Python Weekly 是一份提供最新 Python 文章、视频、项目和即将发生的事件的免费周刊。

  • PyCoder's Weekly 是另一份不错的电子邮件时讯周刊，和 Python Weekly 类似。最佳资源在这两份周刊里一般都能找到，但是它们通常会从网络上收录不同的文章和项目信息。

  • Import Python 和 Python Weekly 、PyCoder's Weekly 比起来算是一份较新的时讯。到目前为止，我发现它的文章来源和其它两个都不相同。这三份都值得订阅，这样你就不会错失任何资讯了。

  • Full Stack Python monthly newsletter 是一份月度时讯，每月只集中讨论一个主题。比如，某月讲述 Flask 的相关资源，那么下一个将会提供 WSGI 服务器配置的相关信息。

最佳 Python 视频

如果你更喜欢通过观看视频来学习 Python 的话，那么这里的资源很适合你。我观看了上百部技术访谈视频节目，并且从这些视频中梳理出了这些最佳资源，视频中的这些专家会向你传授有关这门语言及其生态系统的大量知识。

本页列出了最好的免费视频链接，以及其它一些视频列表，这些视频都是在过去几年的讨论会和见面会上发布的，你可以在这些视频集中搜索你需要的内容。

务必看下 最佳 Python 资源，通过上面的书籍和文章链接，以及 Web 框架 来深入学习 Web 开发。

Live Coding

通过观看开发人员写代码来学习。在 Twitch Creative 上关注我的账号，当我要开始的时候，请打开电子邮件提醒功能。 每周三我都会写 Python 和 Swift 程序，到时会回答每一个提问。每周五我也会安排办公时间，到时你可以来问有关写代码的问题。

用 Django、 Flask 和 其它框架进行 Web 开发

核心 Python 语言视频

  • Jessica McKellar 在视频 Building and breaking a Python sandbox 中对 Python 解译器的低层知识进行了深刻的讲解。

  • Brandon Rhodes 在视频 All Your Ducks In A Row: Data Structures in the Std Lib and Beyond中，就数据结构是如何实现的、如何选取适合你的应用的数据结构、如何在各种情况下使用列表和元组等问题进行了讲解。

  • Simeon Franklin 在 Python Descriptors 这份演讲视频中，解译了什么是描述子以及为什么需要该核心 Python 语言特性。

  • David Beazley 在即时编程视频中，使用线程、事件循环和协程等机制向我们展示了 Python 的并发性。David 的即时编程看起来很容易，但他一定是为这次演讲做了大量的准备工作。

屏幕录像和课堂录像

  • Google Python 课堂 包含学习 Python 的教学视频及练习。

  • 虽然不会总有在线直播，但我们还是值得到 Livecoding.tv 网站的 Python 类目 上逛逛，找找是否有人在上面进行 Python 相关项目的直播，或者录像资料。即使是经验丰富的开发人员也能通过观看其他开发人员如何在他们的项目上工作，而学到很多东西。我每周也会直播几次，如果你 关注了我的名字 的话，我上线时你会得到通知的。

视频汇编

  • PyVideo 对来自主流讨论会及见面会的上千份视频资源进行了整理和索引编排。

  • Incredible Technical Speakers 是我整理的一份 Git 库，收集了一份具有软件开发背景的演讲人员名单，他们的演讲主题都和编程语言无关。这份名单重点意在收集那些有能力给同行的观众奉献一场精彩演讲的专业软件开发人员。

开发环境

开发环境就是文本编辑器和 Python 解译器的组合。文本编辑器用来输入源代码。而解译器用来执行你写的代码。文本编辑器可以很简单，比如 Windows 系统上的 Notepad，也可以相当复杂，比如 PyCharm，它就是一个完整的集成开发环境（IDE）， 并且在当前主流的操作系统上都能运行。

为什么需要开发环境？

Python 代码需要经过编写、执行、测试然后才能构建成应用程序。文本编辑器提供输入代码的功能。解译器使得代码能够运行。测试用来检验代码是否按预期运行，而测试工作要么通过手动进行，或者通过单元测试和功能测试进行。

当你在学习开发环境的相关知识时，请务必查看 Vim 和 Emacs。

开发环境案例

这是我（Full Stack Python 的作者 Matt Makai） 用于开发我的大部分 Python 应用的开发环境。我有一台安装了 Mac OS X 系统的 Macbook Pro。Ubuntu 14.04 LTS 是通过 Parallels 安装在虚拟机上的。我的代码在 vim 里输入，然后在命令行上由 Python 2.7.x 解译器执行。我使用 virtualenv 创建独立的 Python 解译器，每个解译器包含各自独立的 应用程序依赖包 。我使用 virtualenvwrapper 在各个解译器间进行快速切换。

这是一套常见的设置方案，当然你也能用更简单的方案或者基于云计算的开发环境来写出好代码。

开源文本编辑器

  • vim 是我选择的编辑器，该编辑器在大多数类 unix 系统都已默认安装。

  • emacs 是另一款在类 unix 上常用的编辑器。

  • Atom 是一款由 GitHub 团队创建的开源编辑器。

专有（封闭源码） 编辑器

  • Sublime Text 版本 2 和 3 （当前还是 beta 版）都是较流行的文本编辑器，通过插件扩展，能够在它上面增加代码补全、代码检查、语法高亮等功能。

  • Komodo 是一款跨平台的文本编辑器和 IDE，它支持主流的语言，包括 Python、 Ruby、 JavaScript、 Go 等。

Python 专用 IDE

  • PyCharm 是一款基于 JetBrains 平台的 Python 专用 IDE 。它对学生和开源项目提供免费版本。

  • Wing IDE 是一款需要付费的开发环境，它有集成的调试环境和代码补全功能。

  • PyDev 是 Eclipse 上的一个 Python IDE 插件。

托管的开发环境服务

在过去的几年中，出现了一些基于云计算的开发环境。当在一台只有浏览器且无法安装软件的机器上学习时，你会觉得这些工具很有用。它们大部分对入门级使用免费，但当你需要提升应用需求时对你进行收费。

  • Nitrous.io 提供了一个云 IDE，同时提供的主机托管服务也能随着应用系统流量的提高而能助你进行扩展。

  • Cloud9 最先是作为一个独立公司的，而现在它由 Amazon 所有，并作为了 Amazon Web Services 的一部分。

  • Terminal 是另一个云环境，除了 IDE 它还主推托管数据库服务。

开发环境相关资源

Vim

Vim， 即 Vi IMproved 的缩写，是一个可配置的文本编辑器，通常用作 Python 的开发环境。Vim 用户通常使用大量的插件、Vim 脚本和逻辑命令语言来扩展 Vim 功能。

为什么 Vim 适合用作 Python 开发环境

Vim 的哲学是：当开发人员的手不离开键盘时，工作效率会更高。代码应该从开发人员的头脑自然地流经键盘，再到达屏幕。使用鼠标等外设会降低开发者的思想与代码的转换速率。

Vim 内含一种逻辑结构化的命令语言。当开始学习时，我们会觉得理解全部的命令是不可能的。但是，这些命令是按一定逻辑组织起来的，因此，随着时间推移，这个编辑器会变得得心应手。

如果你喜欢 Vim，你应该也想了解 写代码的开发环境 和 什么使 Python 变得如些强大。

利用 Vimrc 配置 Vim

Vimrc 是 Vim 编辑器的配置文件。一个 Vimrc 文件可以是一个空文件，也可以包含成百上千行配置命令。

下面是我用于 Python 开发的一个简短的 .vimrc 示例文件，并附带注释。从中你可以感受一下它的配置语句：

  1. " 开启语法高亮
  2. syntax enable
  3.  
  4. " 显示行号
  5. set number
  6.  
  7. " 设置 tab 符为 4 个空格
  8. set ts=4
  9.  
  10. " 写代码时，移到下一行时自动缩进
  11. set autoindent
  12.  
  13. " 将 tab 符自动扩展成空格
  14. set expandtab
  15.  
  16. " 使用 >> 和 << 命令时, 移动 4 个空格
  17. set shiftwidth=4
  18.  
  19. " 在光标所在的当前行下显示一条行指示线
  20. set cursorline
  21.  
  22. " 显示 [] {} 和 () 匹配的另一半符号
  23. set showmatch
  24.  
  25. " 开启全部 Python 语法高亮特性
  26. let python_highlight_all = 1

下面的图片是我在 Mac OS X 上编辑本页 markdown 文件的截图，你可以这到这些配置选项在暗色背景后的显示效果是什么样的。

在暗色背景上设置了基本配置选项的 Vim 。

看一下另一个例子，同样的配置选项，这次使用的是浅色背景，图片是我在写 制作交互的演示文稿 项目的 Python 代码时的截图。

在浅色背景上设置了基本配置选项的 Vim 。

Vimrc 文件位于运行 Vim 的用户帐号的 home 目录下。例如，我的用户账号是 'matt'， 在 Mac OS X 上，我的 Vimrc 文件可以在 /home/matt/ 目录下找到。

如果 Vimrc 文件还没有创建，你只需在用户的 home 目录下创建一个即可，这样，当你下次打开 Vim 时，它就能被加载了。

Vim 教程

Vim 有难学的坏名声，但是通过这些教程，入门会变得更加容易。

  • Learn Vim Progressively 是一本很精彩的教程，里面提到的学习方式和我学习 Vim 时用的是一样的：先学会编辑器的基本知识就会日常使用，然后再学习更加高级的命令。

  • A vim Tutorial and Primer 深入研究了如何从初学者进阶到 Vim 专家。

  • Why Atom Can't Replace Vim 探讨了 Vim 的一个核心理念： 命令的可组合性。Vim 的内置语言能将简单的命令组合成一个更加高级的组合操作命令。例如在命令模式下， $ 的功能是移动到行尾，但当 $ 前加 d 后，就能删除从当前位置到行尾的所有内容。随着时间的推移，这些简单的命令会变成你的直觉，而组合命令会比在下拉菜单中设置一个特定选项来删除到行尾的全部内容这样的方式更加强大。

  • Vim as a Language 解译了其语言语法及如何通过日积月累掌握这个编辑器。

  • How to install and use Vim on a cloud server 和 How to use Vim for advanced editing of code on a VPS 这两份详细教程都来自 Digital Ocean，内容是如何设置和运行 Vim，无论你是在本地还是在云服务器上使用 Vim, 都值得一看。

  • Vim 冒险 是一款小巧好玩的浏览器游戏，通过玩这个冒险游戏能帮你学习 Vim 命令。

  • 在 Vim: revisited 中， 作者解释了他时断时续使用 Vim 的经历。然后阐述他如何配置和使用该编辑器，并坚持以它作为主要的代码编辑工具。

  • 关于 Vim 中我希望老早就知道的知识 讲述了一位专门使用 Vim 多年的开发人员的经验教训。他使用相对而非绝对行号，设置了大量的配置选项及通过模糊查询来快速打开其它目录下的文件而无需展开完整的路径。

Vimrc 资源

这些是学习如何组织 .vimrc 文件的资源。我建议一项项增加配置选项，每次添加一条，然后再单独测试一下，而不是一股脑儿地把你不熟悉的 Vimrc 都拷贝进来。

Vim 安装指南

这些安装指南将指导你在 Mac OS X、Linux 和 Windows 上安装和运行 Vim 。

  • Upgrading Vim on OS X 阐述了为什么要从 Vim 7.2 升级到 7.3+，以及如何通过 Homebrew 升级。

  • 在 Windows 7+ 上安装 Vim 的最简单方法是下载并运行 gvim74.exe 文件。

  • 在 Linux 上应该使用 sudo apt-get install vim 来安装 vim 软件包。

  • 如果你将 PyCharm 作为你的 IDE 的话，你不需要再单独安装 Vim 文本编辑器。你可以用 PyCharm 的 IdeaVim 插件，并利用 ~/.ideavimrc 及其它的 Vim 模拟功能来实现 Vim 按键绑定、视觉/插入模式等。

将 Vim 作为 Python IDE

一旦你已熟悉 Vim 编译器，就可以用一些配置选项和插件来提高你的 Python 工作效率。到了这一步，你可以看下这些资料：

Vim 插件管理

  • Vundle 是一个被大量推荐的 Vim 插件管理器。

  • Pathogen 是一个广泛使用的插件管理器。

  • Vim-plug 宣称自己是一个最小的 Vim 插件管理器。

Vim 插件资源

Emacs

Emacs 是一个可扩展的文本编辑器，可以通过编写 Lisp 代码来定制。

为什么说 Emacs 适合用来编写 Python 代码？

Emacs 旨在可以通过内置的 Lisp 解释器和包管理器进行定制。它的包管理器叫 package.el，具有安装管理功能。其最大的 Lisp 软件包仓库是 Melpa，它能获取软件源上的数据并提供自动更新。

在 Emacs 中，宏对于执行重复的动作非常有用。宏就是对之前一组按键序列的记录，并通过重放该记录来执行之前的动作。

所谓挂勾，就是包含一组可调用函数的 Lisp 变量，它是 Emacs 的一种扩展机制。例如，kill-emacs-hook 能在 Emacs 退出前运行，从而使那些函数能被导入到那个挂勾中，以便在退出工作完成前执行必要的操作。

当你在阅读有关使用 Emacs 编写 Python 代码的知识时，可以去了解下使用何种Web 框架 及 如何部署一个应用。

常用 Emacs 资源

著名的 Elisp 软件包

  • Magit 能让用户在 Emacs 中检查和修改 Git 仓库。

  • company-mode 发明了一种模块化的内存代码补全框架。

  • Flycheck 提供语法检查。

  • anaconda-mode 专用于 Python 开发，允许进行代码浏览跳转、文档查找和代码补全。其核心使用 jedi 库实现。

  • Tern 是一个独立的 JavaScript 代码分析引擎。它能通过 tern-django 包与 Django 项目进行整合。

流行的用户配置

  • Prelude 是一个 Emacs V24 的增强版。

  • A reasonable Emacs config 展示了一套功能完备的 Emacs 配置方案。

  • Emacs settings 这个库包含了 Emacs Rocks 上的屏幕录像里用到的所有 Emacs 配置。

  • Spacemacs 整合了 Emacs 的扩展性和 Vim 的符合人体工程学的文本编辑功能。

Python 编程语言

Python 编程语言是一个 开源的, 广泛应用于 开发软件应用的工具。

Python 能做什么？

Python 通常用于 构建 并 部署 Web 应用 和 Web API。 Python 也可以用于分析及可视化 数据 和 软件测试，即便待测试的软件不是用 Python 写的也可以。

常用 Python 语言资源

Python 生态资源

最佳 Python 资源 页面上有整页的资源链接，但是当你看完了那些入门主题后，下面的这些资源会更加适合你。

  • Python 生态：简介 提供了有关虚拟机、Python 包、pip、virtualenv 等很多主题的背景情况。

  • Python Subreddit 收集了大量的 Python 链接，并且有一个活跃的社区时刻准备着回答从菜鸟到高手等不同级别的 Python 开发者提出的问题。

  • 免费 Python 提示 这个博客提供了 Python 各主题的相关文章及 Python 生态系统的相关新闻。

  • Python 图书 整理了一份关于 Python、Django 和 数据分析的免费图书列表。

  • Python IAQ: 非常问问题集 是一份有关罕见 Python 功能，以及这些语法为什么放入或者不放入语言中等怪异问题的列表。

  • Python 程序员函数式编程的实用指南 对于想学习该语言函数式编程范式的开发者来说是一份不错的入门教程。

  • Python 内部机理入门 对 CPython 代码进行了解析，从中我们能学到 Python 本身是如何构建的。

生成器

生成器是 Python 的一个核心语言构件，它能使函数的返回值表现为一个迭代器。在进行大量迭代操作时，生成器能通过不断地分配和释放内存来提高内存的使用效率。 PEP255 文档描述了生成器， 2001 年的 Python 2.2 首次对其进行了实现。

Python 生成器资源

  • Intermediate Pythonista 上的 Python 生成器简介 是一篇相当不错的文章，上面附有示例代码。

  • 这篇名叫 Python 生成器 的博文着重讲述了字典的生成。特别适合 Python 初学者阅读。

  • Python 201: 生成器简介 是另一篇短小精悍的文章，上面附有生成器示例代码。

  • 迭代器 & 生成器 为这两种语言构件分别提供了示例代码，并进行了一些简单说明。

  • Python: 生成器 - 如何使用及其优点 是一份屏幕录像，展示了如何在 Python 中使用生成器代码。

  • Stack Overflow 上的 怎样理解 Python 生成器？ 这个问题有一个令人印象深刻的解答，它清晰地阐述了与 Python 生成器有关的代码和概念。

  • 系统程序员生成器使用技巧 提供了如何使用生成器的示例代码。这份资料最先是在一次针对系统程序员的 PyCon 研讨会上发布的。但是对于那些想理解如何正确使用生成器的 Python 开发人员来说，都值得一读。

推导式

推导式是 Python 语言的构件之一，使用它能简洁地构建列表、字典和集合。列表推导式在 Python 2 中引入，而字典和集合的推导式是在 Python 3 时引用的。

推导式为什么很重要？

在 Python 核心数据结构中填充条件式数据，推导式是一种较清晰的语法。如果没有推导式，实现相同的功能通常需要使用嵌套的循环和条件语句，这使得代码阅读者很难进行适当的评估。

示例代码

列表推导式:

  1. >>> double_digit_evens = [e*2 for e in range(5, 50)]
  2. >>> double_digit_evens
  3. [10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]

集合推导式:

  1. >>> double_digit_odds = {e*2+1 for e in range(5, 50)}
  2. {11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99}

字典推导式:

  1. >>> {e: e*10 for e in range(1, 11)}
  2. {1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60, 7: 70, 8: 80, 9: 90, 10: 100}

推导式相关资源

  • Intermediate Python 上的 Python 推导式 这篇文章对 Python 这三个核心数据结构的推导式做了相当不错的总结。

  • Python 列表推导式： 可视化讲解 讲解了这种迭代的惯用法是如何变成语言本身的语法糖的以及如何在自己的程序中使用它。

  • Python 3 模式及惯用法网站对 推导式 做了总结，并用代码示例和图表讲解了它们是如何运作的。

  • 以绝地武士的方式讲解 Python 的推导式 以星球大战的主题风格展示推导式，并演示了它的各要点知识。所有示例都用 Python 3.5 写成。

  • Python 惯用法： 推导式 讲解了 Python 推导式如何受到 Haskell 列表推导式的启发。并以清晰的例子讲解推导式是如何简化普通迭代代码的—例如将一个列表复制到另一个列表并对其中的元素进行一些操作。

  • 通过例子学 Python ：列表推导式 先给出一个不正确的列表推导式的例子，然后讲解如何修正错误。

  • Python 的列表推导式 这篇文章涉及列表推导式代码是怎样的，并提供一些示例代码以展示它们是如何工作的。

  • Python 列表简介 对 Python 列表做了大体而可靠的综述，其中当然也涉及到列表推导式。

Web 开发

Web 开发是对概念化、构建、 部署 和运营　Web 应用程序及 Web 应用程序接口 的统称。

为什么 Web 开发很重要？

自从 第一个网站 于 1989 年诞生以来，网络在网站数量、用户数和容量上取得了难以置信的发展。 Web 开发这个概念包含了与网站及 Web 应用程序相关的所有活动。

Python 如何用于 Web 开发？

Python 能用于创建服务端 Web 应用程序。虽然 Web 框架 对于创建 Web 应用来说不是必需的，但是不用现存的开源库来加快开发进度的开发人员还是很少的。

Python 不能用于浏览器。能在 Chrome、 Firefox 和 Internet Explorer 等浏览器上运行的语言是 JavaScript。像 pyjs 等项目能将 Python 程序编译成 JavaScript 程序。但是，大多数 Python 开发人员都结合 Python 和 JavaScript 来开发他们的 Web 应用程序。Python 在服务端执行而 JavaScript 会下载到客户端然后由 Web 浏览器运行。

Web 开发相关资源

  • Web 应用开发是不同的并且更好 提供了 Web 开发如何从只需要写静态 HTML 文件进化到如今需要由复杂的 JavaScript 客户端应用动态生成的相关背景。

  • 虽然不是只针对 Python，Mozilla 为想学习建网站的初学者和中级网络用户整理了一份 Web 学习 的教程。它对于想学习通用 Web 开发知识的人来说还是值得一看的。

  • Web 的进化 形象化地展示了浏览器及其相关技术的发展历程，以及 Internet 数据传输量的总体发展状况。值得注意的是上面的数据只统计到 2013 年年初，但对于探索最初 24 年中所发生的事件，也不啻为一种很好的途径。

  • Web 开发涉及到与服务器的 HTTP 通信，托管网站或 Web 应用，以及客户端－一个浏览器。理解浏览器的工作原理对于一个开发者来说是很重要的，因此建议看下这篇文章 Web 浏览器里都有些什么。

  • 经历两周痛苦的慢速网络后给网站开发者的三个忠告 对于每位 Web 开发人员来说都是必读的。不是每个人都使用高速网络服务的，因为他可能地处世界边远地区，或者刚好在地铁隧道中。优化网站以适应这些情况是非常重要的，它能保持用户的满意度。

Web 框架

Web 框架就是一份代码库，它能帮助开发人员创建可靠、可扩展、易维护的 Web 应用。

为什么 Web 框架很有必要？

Web 框架封装了开发人员在过去二十年中学到的网站和 Web 应用开发的经验总结。它使得重用代码（例如通用 HTTP 操作和项目代码组织等）变得更加容易，因而熟悉该框架的其他开发人员就能快速创建和维护应用程序。

Web 框架的基本功能

框架通过它们自己的代码或扩展代码提供功能，以实现运行 Web 应用所需的基本操作。这些基本操作包括：

  • URL 路由
  • HTML、 XML、JSON 及其它输出模式模板
  • 数据库处理
  • 跨站请求伪造安全问题（CSRF）和其它攻击
  • session 存取

不是所有的 Web 框架都包含以上全部功能。框架种类从执行单一的用例到提供每个开发人员熟知的每个 Web 框架功能，不一而足。一些框架奉行“即插即用”的理念，把所有可能的东西都打包进来，而其它一些框架却有一个很小的内核包，以方便通过第三方代码包来扩展功能。

例如，Django Web 应用框架 含有一个对象关系映射 (ORM) 层来对关系型数据库的读、写、查询和删除操作进行抽象。但是，Django 的 ORM 如果不进行大量修改的话，是不能操作像 MongoDB 等的非关系型数据库的。

其它一些框架，像 Flask 和 Pyramid 可以通过包含进外部 Python 库来更加容易地与非关系型数据库一起使用。框架的实现，都需要在最少功能和易扩展性，以及将所有东西都包含进来以提高整合度这两个选择之间进行抉择。

Web 框架对比

你对一个项目用 Django 实现和用 Flask 实现的代码对比感兴趣吗？看下 这篇 Django Web 应用教程 然后再看下 由 Flask 实现的相同的应用。

还有一份代码库叫 compare-python-web-frameworks，上面的一个相同的 Web 应用由不能的 Python Web 框架、模板引擎和 对象关系映射器来实现。

既然已经学了 Web 框架，你也应该学下 Web 应用部署 和 Web API。

我需要使用 Web 框架吗？

你的项目是否需要使用 Web 框架取决于你的网站开发经验和你的目标。如果你是一个初级程序员并且以学习为目的来开发一个 Web 应用，那么框架能帮助你理解下面的这些概念，例如 URL 路由、数据处理和认证等这些主流的 Web 应用都具有的功能。

另一方面，如果你是一位有经验的程序员，具有丰富的网站开发经验，你可能会觉得现有的框架不能满足你的项目需求。如果那样的话，你可以将 Werkzeug 等开源库、WSGI 功能包和你自己的代码进行混合匹配来创建你自己的框架。 Python 的生态系统仍然为新框架留了足够的空间，以便去满足那些不能从Django、 Flask、 Pyramid、 Bottle 和 许多其它框架 中得到满足的程序员的需求。

简言之，你是否需要使用 Web 框架来创建 Web 应用取决于你的经验和你的目标。使用框架来创建 Web 应用当然不是必需的，但是在多数情况下，它能让开发人员的生活变得更加轻松。

Web 框架相关资源

Web 框架学习清单

  • 选择一个主流 Python Web 框架 (推荐 Django 和 Flask)，然后坚持使用。刚开始的时候最好只学习一个框架，而不要试图去理解每个框架。

  • 根据那个框架的网站上的资源链接，寻找一份详细的教程，并据此进行练习。

  • 研究用你所选框架开发的开源案例，这样你就能参与这些项目并在你的应用中重用这些代码。

  • 写完你的 Web 应用的第一个版本，然后参考 部署 那一章，将它发布到网上。

Django

Django 是一个广为使用的 Python Web 应用框架，它奉行 “包含一切” 的哲学。该理念即为：创建 Web 应用所需的通用功能都应该包含到框架中，而不应存在于独立的软件包中。

Official Django logo. Trademark Django Software Foundation.

例如，身份验证、 URL 路由、 模板系统、 对象关系映射 (ORM) 和 数据库迁移 (版本 1.7) 等功能都已包含在 Django 框架 中。 Flask 框架与 Django 相比，并没有包含这么多的功能，例如它还需要一个独立的 Flask-Login 库来实现用户身份验证。

包含一切和易扩展性是实现框架时采用的两种不同哲学罢了，再两种方式各有千秋，不能说哪一种会再好。

Django 是对Web 框架 概念的一种实现。在 Web 开发 那一章你可以框架的各部分组件是如何协同工作的，或者到 总目录 页去查看其它所有主题。

为什么说 Django Web 框架是一个不错的选择

自创建以来， Django 项目的稳定性、高性能和它的社区在过去的十年中有了长足的发展。现在已经有大量的在线资源和图书资料，从中你能找到详细的教程和实践指南。该框架还在不断地往新版本中增加诸如 数据迁移 新功能。

我非常推荐 Python Web 开发新手使用 Django 框架，因为它的官方文档和一些教程的质量在软件开发界都是数一数二的。许多城市都有 Django 团体，如 Django District、 Django Boston 和 San Francisco Django，因此新手在碰到难题时能获得帮助。

虽然有 通过使用 Django 来学习 Python 是不好的 这样的争议。但是，对于先前已经花时间学过 Python 语法和语义，然后才转入 Web 开发的人来说，这样的说法是站不住脚的。

Django 图书和教程

已经有大量的免费或低价的 Django 资源。不过 Django 是在 10 年前发布的，并且之后又进行了大量的更新，因此当你要找一本与时俱进的 Django 图书时，应该先看看下面的这份列表，或者读下这篇文章 当前的 Django 图书，截止到 Django 1.8，1.9。

Django 视频资源

除了文章，你还想找 Django 视频吗？在 最佳 Python 视频 页上有一节专门针对 Django 和 Web 开发的。

Django 迁移

  • Paul Hallett 发布在 Twilio 博客上的文章 Django 1.7 应用升级详细指南 讲述了他对 django-twilio 包的使用经验。

  • Real Python 上的 迁移入门教程 探讨了 South 与 Django 内置的迁移功能之间的区别，并介绍了它们的使用方法。

  • Andrew Pinkham 写的 ”升级到 Django 1.7“ 系列文章是很好的学习材料，据此你能了解该版本主要进行了哪些更新，以及能学到应如何相应地对你的 Django 项目进行更新。 第 1 部分、 第 2 部分、 第 3 部分 和 第 4 部分 现在都能找到。

  • 不下线迁移 Django 展示了如何在 Django 站点不下线的情况下进行数据迁移。

1.9+ 中的通道

通道是 Django 1.9 的一种新机制(作为一个独立应用，稍后会合并到核心框架中），它能基于 WebSocket 实现浏览器与服务器之间的实时双向通讯。

Django 测试

Django 及 Angular (Djangular) 资源

Django ORM 资源

Django 有自己内置的的对象关系映射器(ORM), 通常指代为 "the Django ORM"。到 Python 对象关系映射页 上了解 Django ORM 相关的更多信息，那上面有一节是专门解读 Django ORM的，当然上面还有其它的资源和教程。

静态和媒体文件

Django 初级开发人员对于如何部署和处理静态和媒体文件会感觉困惑。下面列出的资料以及 静态内容 那一页上的资源对于搞清楚如何正确处理这些文件很有帮助。

开源 Django 示例项目

  • 使用 Django 和 Twilio 制作浏览器通话器 展示了如何利用 Django 和 Twilio 客户端 来创建一个 Web 应用，将用户的浏览器改造成一个全功能的电话机。非常有趣。

  • Txt 2 React 是一个 Django Web 应用，它能让观众一边观看演示，一边输入反馈信息或者提问。

  • Openduty 是一个网站状态检查和报警系统，类似于 PagerDuty。

  • Courtside 是一个收集体育活动信息的 Web 应用，由 PyCoder‘s Weekly 的作者编写和维护。

  • Django 交互式语音应答系统 (IVR)，它的两份 Web 应用代码库： 第 1 部分 和 第 2 部分 向你展示了如何创建一个真正有趣的 Django 应用 。它还有相应的 文章， 对其中的每一个步骤进行了详细的讲解。

  • Taiga 是一个项目管理工具，后端用 Django 开发，前端用 AngularJS 开发。

Django 项目模板

Django 学习清单

  • 在你的本地开发机器上 安装 Django。

  • 依据 "polls" 这个教程进行练习。

  • 依据 “Django 资源” 那一节上的相关教程，创建一些简单的应用。

  • 参考 官方文档 以及上面的资源链接，开始编写你自己的 Django 项目。当然你会犯错误，但这是你学习如何正确的创建应用的必经之路。

  • 阅读 2 Scoops of Django 来理解 Django 的最佳实践，并学会什么是创建 Django Web 应用的更好方式。

  • 查看 部署那一章，将你的 Django 项目发布到网上。

Flask

Flask 是一个 Python Web 框架，它在设计实现时奉行 小核心且易于扩展的哲学。

Official Flask logo. Flask Artwork License.

为什么说 Flask Web 框架是一个不错的选择？

人们认为 Flask 相比 Django 更加的 Pythonic， 因为 Flask Web 应用的代码在多数情况下都会更加清晰明确。 由于创建和运行一个简单的 Flask 应用只需很少的样板文件， Flask 对于初学者来说，更易于上手。

例如，下面是一个 Flask 版本的 "hello world" 应用(它的 Django 版本将需要更多的代码量）：

  1. from flask import Flask
  2. app = Flask(__name__)
  3.  
  4. @app.route('/')
  5. def hello_world():
  6.     return 'Hello World!'
  7.  
  8. if __name__ == '__main__':
  9.     app.run()

Flask 是距 Django 好几年后才开发的，因此它能从 Django 框架的发展历程中学到很多东西。Jökull Sólberg 在他的这篇文章 从 Flask 换回到 Django 经历中就很好地阐明了这个问题。

Flask 是对Web 框架 概念的一种实现。在 Web 开发 那一章你可以了解框架的各部分组件是如何协同工作的，或者到 总目录 页去查看其它所有主题。

Flask 资源

开源 Flask 示例项目

Flask 项目模板

Flask 框架学习清单

  • 在你的本地开发机上 安装 Flask 。

  • 根据上面的 “Flask 资源”节里列出的那 18 个 Flask 教程，依次练习。

  • 在 Flask 扩展中心 查找你的项目所需的扩展。

  • 在学习和研究完那 18 个 Flask 教程以及下面列出的开源示例应用后，开始编写你自己的 Flask 应用 。

  • 查看 部署那一章，将你的 Flask 项目发布上网上。

Bottle

Bottle 是一个与 WSGI 标准兼容的 单文件 Web 框架，它除了 标准库 (stdlib) ，没有其它的任何外部依赖。

Official Bottle logo.

我应该使用 Bottle 进行开发吗？

Bottle 特别适合于以下几种情况：

  • 进行原型概念开发
  • 学习 Web 框架是如何构建的
  • 创建和运行简单的个人网络应用

原型开发

相比于庞大复杂的 Django, 使用 Bottle 对简单的概念进行原型开发更加容易，因为创建一个 Django 项目需要相当数量的样板代码。 项目中的 Django App 都是以 模型-视图-模板 方式组织的，这样虽然易于项目维护，但是对于一个初始项目来说，会显得有点笨拙，因为你现在只是想尝试实现一些灵感，并不想考虑应用系统的长期代码结构。

学习框架知识

Bottle 包含在一个单独的大文件中，名叫 bottle.py，因此能够从中学习 WSGI Web 框架是如何运行的。关于你的 Web 应用代码与 Bottle 框架是如何关联的等等所有你需要了解的东西都在那个单独的源代码文件中。

个人项目

个人项目的部署只需要 Bottle 这个唯一的依赖文件。 如果你之前从没进行过 Python Web 应用部署工作，部署涉及到的大量概念和步骤会让你望而却步的。通过将 bottle.py 和你的应用源代码一起打包，可以让你省掉一些步骤，从而使你的 Web 应用更易上线运行。

Bottle 是对 Web 框架 概念的一种实现。在 Web 开发 那一章你可以了解框架的各部分组件是如何协同工作的，或者到 总目录 页去查看其它所有主题。

Bottle 资源

开源 Bottle 示例项目

  • Pattle 是 pastebin 的克隆版本， 它是用 Bottle 创建的。

  • Decanter 是一个对 Bottle 项目进行组织管理的库。

  • compare-python-web-frameworks 上提供了一个示例应用，并以 Bottle 作为其中的一种实现方式。

Bottle 框架学习清单

  • 下载 Bottle 或者使用 pip 在你的本地开发机上通过 pip install bottle 安装。

  • 练习 Bottle 教程。

  • 在通读官方的教程及对上面列出的开源示例应用进行研究后，开始编写你自己的 Bottle 应用。

  • 查看 部署那一章, 将你的首个 Bottle 应用发布上网上。

Pyramid

Pyramid 是一个开源的 WSGI Web 框架，它基于 模型-视图-控制器 (MVC) 结构模式。

Pyramid web framework logo.

开源 Pyramid 示例应用

Pyramid 资源

Morepath

Morepath 是一个 Web 微框架，它使用模型驱动的方式来创建 Web 应用和 Web API。

Morepath 的框架理念是： 数据模型应该驱动 Web 框架的应用开发过程。该框架默认将 URL 直接路由到模型代码中，而不像 Django 等框架还需要开发者显式指定 URL 路由。

为何说 Morepath 是一个很有趣的 Web 框架？

简单的 CRUD 型 Web 应用 和 API 应用 的创建过程会比较枯燥乏味，因为这种应用都是与数据模型直接打交道的，而模型与视图间的逻辑关联很少。你可以从 Morepath 作者那里了解更多有关该框架 与其它 Web 框架的对比情况。

随着前端 JavaScript 框架的出现，许多 Python Web 框架开始被用来创建 RESTful API 应用，这些应用只返回 JSON，而不是通过模板系统来呈现 HTML。 Morepath 在设计之初就考虑了 RESTful API 模式方法，并且抛弃了模板驱动用户界面这样的假设。

Morepath 资源

其它 Web 框架

除了通常用的 Django、 Flask、 Pyramid 和 Bottle 之外， Python 还有很多其它的 Web 框架。

TurboGears2

TurboGears2 原来只是 Pylons 的一个扩展，现在已经发展成为一个独立的 Web 框架。它可被用作一种全栈解决方案（像 Django），也可作为一个微框架使用。

Falcon

Falcon 是一个简洁的 Web 框架，Web 应用的运行速度是其设计重点。

web.py

web.py 是一个意在简化 Web 应用开发过程的 Python Web 框架。

web2py

Web2py 是一个基于“包含一切”哲学的框架，其项目结构使用模型-视图-控制器的模式。

CherryPy

CherryPy 号称是一个最简洁的 Web 框架。以编写一个 Web 应用所需的代码量这个角度来看，确实是这样。这个项目经历了 很长的一段历史，并在第二版和第三版之间进行了重大的修改。

Muffin

Muffin 是一个基于 asyncio（一个 Python 3.4+ 标准库）创建的 Web 框架。Muffin 参考 Flask，通过视图函数上的装饰器来定义 URL 路由。它使用 Peewee ORM 来替代更加常用的 SQLAlchemy ORM。

其它 Web 框架资源

其它框架学习清单

  • 了解上面列出的这些 Web 框架，并访问它们的项目网站。

  • 除了 Django 和 Flask 之外，知识还存在哪些 Web 框架是非常有用的。但是，如果你现在只想开始学习编程的话，那么在网上找到 Django 和 Flask 的相关教程的资源会更容易也更多。我的建议是：先从这两个框架开始学习，然后再扩展你的知识。

Web 设计

Web 设计就是使用 CSS 和 JavaScript 来创造 Web 应用的风格和用户交互界面。

为什么说 Web 设计很重要？

你不会喜欢使用看起来像下面这样的 Web 应用吧？

没有 CSS 和 JavaScript 的 HTML 页面。

创建具有自有风格和交互性的 Web 页面，以便用户能更加容易完成他们的工作是现代 Web 应用创建过程的主要任务。

响应式设计

将内容和显示规则分离，使得设备能根据诸如屏幕大小和设备类型等不同的因素呈现不同的输出内容。基于不同的屏幕参数来显示不同的内容的技术，通常被叫作 响应式设计。响应特性是通过在 CSS 中使用 媒体查询功能 实现的。

例如，移动设备没有足够的空间将导航栏显示在页面的侧边，因而它通常将导航栏下推，显示在主要内容之下。 Bootstrap 上的 Blog 例子 演示了这个效果，当你改变浏览器的宽度时，导航栏会重新定位。

设计相关资源

  • Web 设计仓库 是一个一站式服务的网站，上面有博客、播客、灵感、教程和工具等与 Web 设计有关的各种链接。

  • 前端指南 是一篇讲述 HTML、CSS 和 JS 最佳实践的文章。

  • 如何使用颜色 这篇精彩的文章来自一位专业设计师，讲述他对颜色的理解以及如何使用颜色来实现他的设计中的某个特定效果。

  • Bootstrapping 设计 这本书是我迄今为止读到的有关学习设计的最清晰简洁的资源了。特别推荐给那些感觉自己没有设计才能但又需要学习设计的人。

  • 学习设计原理 就如何根据特定的规则如轴、对称性、层次和节律等来思考设计给出了清晰的讲解。

  • Kuler 是一款来自 Adobe 的辅助取色器，能帮助你在设计中选取颜色。

  • 如果你想了解浏览器的工作原理，这里是 关于如何创建浏览器引擎的系列文章，它会向你展示了如何创建一个简单的渲染引擎。

级联样式表 (CSS)

级联样式表 (CSS) 文件包含了浏览器如何显示和布局 HTML 内容的规则。

为什么说 CSS 是必需的？

CSS 将 HTML 文件内容与其如何显示进行了分离。将内容与其应该如何呈现的规则分离的重要性主要在于：可以在多个页面中更加容易复用这些规则。相比于嵌在 HTML 文件中的样式内容，大型项目中使用 CSS 文件还更易于维护。

CSS 是怎样从 Web 服务器上获取的？

由 Web 服务器发送的 HTML 文件中包含有指向 CSS 文件（用于呈现内容）的引用地址。浏览器获取到 HTML 文件后，再请求 CSS 文件，如下面的截图所示，该图是从 Chrome Web 开发者工具中的网络流量标签页截取的。

Google Chrome Web 开发者工具显示了 CSS 是如何与 HTML 内容分离的。

发送了一个对 fsp.css 文件的请求是因为 Full Stack Python 的 HTML 文件中包含了一个到 theme/css/fsp.css 的引用，如下面的显示源代码截图所示。

View source screenshot for the fsp.css file in index.html.

CSS 预处理器

CSS 预处理器将处理语言编译成纯 CSS 代码。CSS 处理语言通过增设变量、mixin、函数等语法结构来减少代码的重复度。有了这些额外的语法，使得设计人员使用这些基本的编程结构来编写可维护的前端代码变得可能。

  • Sass 是一款目前在设计界备受青睐的预处理器。Sass 具有很多高级的语言特性，因此被认为是功能最强大的 CSS 预处理器。

  • LESS 是一款与 Sass 不分上下的预处理器，由于 Bootstrap 框架 是用 LESS 写的，LESS 现在变得越来越受欢迎了。

  • Stylus 经常被认为是排名第三的最受欢迎的 CSS 预处理语言。

CSS 预处理器资源

  • 《Advanced Guide to HTML and CSS》这本书中有一章是专门讲 预处理器的，写的很好。

  • Sass 对比 LESS 先是对应该选用哪个框架这个问题给出了个精简的回答，然后为那些想了解细节的用户给出来一份详实的答案。

  • 如何选择一个合适的 CSS 预处理器 对 Sass、LESS 和 Stylus 进行了对比。

  • 对 CSS 预处理器的思考 这篇文章中包含了一些很有用的建议，内容包括从如何在团队环境中使用预处理器到你该用什么应用程序来辅助你的工作流等等不一而足。

CSS 框架

CSS 框架为 Web 应用的设计提供架构和样板文件。

CSS 资源

  • 前端开发书签 是一个有关前端知识的最有价值的资料库之一，里面即包含 CSS 也包含 Javascript。

  • CSS 复习摘记 对于之前一直是零星学习 CSS知识，现在又想填充知识空白的你来说相当有帮助。

  • Mozilla 开发者网络中的 CSS 页面 上包含有 CSS 知识的丰富资源、教程和示例。

  • CSS 定位 101 这份详细指南讲解了如何用 CSS 进行正确的元素定位。

  • CSS3 小抄。

  • 学习 CSS 布局 这篇简单的指南将 CSS 布局相关主题分成几个章节来讲解，因此你可以按步每次学一部分内容。

  • Google Web 基础课程 讲解了如何创建响应式的设计和高性能的网站。

  • CSS 性能调优 是一篇很有意思的文章，因为很多开发人员不会考虑 CSS 的复杂性对浏览器渲染时间的影响。

  • 我能用 … 是一个兼容表格，显示了哪个版本的浏览器实现了哪些特定的 CSS 功能。

CSS 学习清单

  • 创建一个只含基本元素的简单 HTML 文件。使用 python -m SimpleHTTPServer 命令来开启服务端进程。在 HTML 文件的 区域中创建一个 。 在 style 元素中通过试验 CSS 来改变页面的外观。

  • 研究 Bootstrap 或 Foundation 等前端框架，并将框架集成到 HTML 页面中。

  • 练习该框架的网格系统、样式选项和定制功能，以便熟悉如何使用该框架。

  • 将该框架应用到你的 Web 应用中并调整设计，直到实现比通用 HTML 更好的效果。

JavaScript

JavaScript 是一种小型的脚本编程语言，它嵌于 Web 浏览器中，用于实现动态内容和用户交互。

为什么说 JavaScript 是必需的？

JavaScript 在客户端执行，它能实现单独的 HTML 和 CSS 不可能实现的动态内容和用户交互。现在的每个 Python Web 应用都在前端使用 JavaScript。

前端框架

前端 JavaScript 框架将 Web 应用的绝大多数呈现功能移到了客户端。因为网页在每次点击新链接时不用重新加载，这种类型的应用通常非正式地被称为 “单面应用”。相反的，这种应用中的部分 HTML 页面会加载到文档对象模型中，或者通过 API 调用获取的数据会显示到已存在的页面上。

这些前端框架包括：

前端框架发展非常迅速。过不了几年，关于框架使用的最佳实践的共识将会达成。

JavaScript 的起源？

JavaScript 是对 ECMAScript 规范 的一种实现，该规范是由 Ecma 国际标准组织 定义的。

JavaScript 资源

  • 2015 年前端工具 显示了一份关于前端开发人员在 CSS 预处理/后处理过程及其它构建步骤中都使用哪些工具的调查结果。

  • 浏览器工作原理 对 JavaScript 和 CSS，以及页面是如何在浏览器中呈现的等知识进行了非常好的概述。

  • 由 Mozilla 发布的 重新介绍 JavaScript 对 JavaScript 的基本语法和操作符进行了讲解。

  • 代码工具与 JavaScript 库 是一份由 Smashing Magazine 整理的长清单，列出了与 JavaScript 相关的库与工具，并对列出的每一项进行了讲解。

  • Superhero.js 是一份关于如何测试、组织、理解 JavaScript 及其一般性用法的资源列表，它设计的相当赞。

  • Unheap 收集了一份非常不错的可重用 JQuery 插件集，从导航栏到显示媒体内容，内容涉及各个方面。

  • 2015 年的 JavaScript 状况 论述了这样一个观点：因生态系统变动，比起大型框架，人们现在更倾向于使用小型、单一用途的 JavaScript 库。

  • 当代 JavaScript 开发者工具集 为那些在他们的 Web 应用中使用 Javascript 的开发者，提供了一份客户端和服务端常用工具的高度概括。

JavaScript 学习清单

  • 创建一个只含基本元素的简单 HTML 文件。使用 python -m SimpleHTTPServer 命令来开启服务端进程。在 HTML 文件的 区域的最末尾创建一个 。 在 script 元素中通过试验 JavaScript 来学习基本语法。

  • 下载 JQuery 并将它添加到页面中的 JavaScript 元素之前，开始使用 JQuery 并理解它如何使 JavaScript 的基本功能变得更加易用。

  • 在页面上使用 JavaScript。将上面列出的开源项目中的示例和 JQuery 插件加入到页面中。到 Unheap 上查找大量的分类 JQuery 插件集。

  • 查看上面列出的 JavaScript 资源，学习更多的高级概念并研究开源库。

  • 将 JavaScript 加入到你的 Web 应用中，查看 静态内容 那一章来学习如何发布 JavaScript 文件。

WebSockets

WebSocket 是一种 标准协议，用于在客户端和服务端之间进行双向数据传输。WebSockets 协议没有运行在 HTTP 之上，它是基于 TCP 的一种独立实现。

为什么要用 WebSockets？

一个 WebSocket 连接允许在客户端和服务端之间进行全双工通讯，从而每一端都可以通过建立的连接向另一端推送数据。 WebSocket，以及与其相关的 服务端发送事件 (SSE) 及 WebRTC 数据通路 等技术之所以重要的原因是：HTTP不能打开并一直保持连接，不能在服务端和 Web 浏览器之间进行频繁的数据推送。在这之前，大多数的 Web 应用会通过频繁的异步 JavaScript 和 XML (AJAX) 请求来实现长轮循，如下图所示。

通过 AJAX 的长轮循对于一些应用来说相当的低效。

服务端推送相比长轮循效率更高且更具扩展性，因为 Web 浏览器不再需要通过一系列的 AJAX 请求来持续地获取更新。

对于获取服务端所发送的更新来说，WebSocket 比 长轮循理有效率。

虽然上图中所示的是服务端将数据推送给客户端，但是 WebSocket 是一个全双工的连接，因此客户端也能将数据推送给服务端，如下图所示。

WebSocket 也允许客户端向服务端推送数据。

用 WebSockets 来获取服务端/客户端推送的更新，这种方式适合特定类型的 Web 应用，例如聊天室，这也是它之所以经常被用作 WebSocket 库的示例应用的原因。

实现 WebSocket

Web 浏览器和服务端都必须要实现 WebSocket 协议，以便建立和维护连接。因为 WebSocket 的连接是持续连通的，不像经典的 HTTP 连接，因此服务器需要做更多工作。

基于多线程或多进程的服务器不能很好地提供 WebSockets 服务，因为它们的设计是：打开一个连接，尽快处理完请求，然后关闭连接。因此，采用 Tornado 或 打包了 gevent 的 Green Unicorn 等异步服务器，对于实现一个实用的服务端 WebSockets 都是必要的。

而在客户端，使用 WebSocket 并不要求有某个 JavaScript 库。实现了 WebSocket 的 Web 浏览器都会通过 WebSockets 对象 导出所有必要的客户端功能。

但是，JavaScript 封装库实现了优雅地降级（不支持 WebSocket 的情况下通常会采用长轮循机制），并隐藏了不同浏览器间的羞异，使用这些封闭库，会使开发者工作起来更加轻松。 有关 JavaScript 客户端库及 Python 实现的示例在下面列出。

JavaScript 客户端库

  • Socket.io 的客户端 JavaScript 库能与实现了 WebSocket 的服务端进行连接。

  • web-socket-js 是一个基于 Flash 的客户端 WebSocket 实现。

Python 实现

  • Autobahn 使用 Twisted 或 asyncio 来实现 WebSocket 协议。

  • Crossbar.io 构建于 Autobahn 之上，并且包含一个独立的服务器， 如果 Web 应用开发者需要的话，可以用它来对 WebSocket 连接进行单独处理。

Nginx WebSocket 代理

Nginx 从 第 1.3 版 开始就正式支持 WebSocket 代理了，通过配置 Upgrade 和 Connection 头可以确保请求通过 Nginx 并到达你的 WSGI 服务器。第一次设置可能会有一点难度。

下面是我的 WebSockets 代理的 Nginx 配置。

  1. # this is where my WSGI server sits answering only on localhost
  2. # usually this is Gunicorn monkey patched with gevent
  3. upstream app_server_wsgiapp {
  4.   server localhost:5000 fail_timeout=0;
  5. }
  6.  
  7. server {
  8.  
  9.   # typical web server configuration goes here
  10.  
  11.   # this section is specific to the WebSockets proxying
  12.   location /socket.io {
  13.     proxy_pass http://app_server_wsgiapp/socket.io;
  14.     proxy_redirect off;
  15.  
  16.     proxy_set_header Host $host;
  17.     proxy_set_header X-Real-IP $remote_addr;
  18.     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  19.  
  20.     proxy_http_version 1.1;
  21.     proxy_set_header Upgrade $http_upgrade;
  22.     proxy_set_header Connection "upgrade";
  23.     proxy_read_timeout 600;
  24.   }
  25. }

值得注意的是，如何上面的示例配置不能工作，你应该查看 官方的 HTTP 代理模块文档。

下面的这些资源对于正确的配置也很有帮助。

使用 WebSockets 的开源 Python 示例

python-websockets-example 包含了创建一个简单 Web 应用的代码，它使用 Flash、Flask-SocketIO 和 gevent 来提供 WebSockets。

  • Flask-SocketIO 项目中有一个 聊天室 Web 应用，演示了如何发送服务端生成的事件，以及如何通过表单的文本输入框来获取用户输入。

通用 WebSocket 资源

  • 官方的 W3C WebSockets API 候选草案 和 WebSockets 工作草案 都是不错的参考材料，但是对于刚接触 WebSockets 概念的开发者来说会有点难度。我建议先看下面列出的一些对初学者来说较容易的资料，然后再读那份工作草案。

  • 由 Armin Ronacher 写的 WebSockets 101 提供了一份有关 HTTP 代理对 WebSockets 低水平支持的详细评估报告。同时对 WebSockets 协议的复杂性及其实现也进行了探讨。

  • "我能使用吗？" 网站上有一份 非常有用的 WebSockets 参照表，指出了哪些浏览器及其版本支持 WebSockets。

  • Mozilla 的 WebSockets 开发者资源 是一个查找 WebSockets 开发相关文档与工具的好地方。

  • 从零开始学 WebSockets 先对该协议进行了概述，然后对 WebSockets 的低层知识进行了讲解，这些知识对于只使用 Socket.IO 等库的开发人员来说通常是个黑盒子。

  • websocketd 是一个 WebSockets 服务程序，意在成为 "WebSockets 的 CGI"。值得一看。

Python 相关的 WebSockets 资源

模板引擎

模板引擎对模板文件进行处理，模板文件是处于你的 Python 代码和需要输出的格式化内容（如 HTML 和 PDF 等）之间的一种中间格式文件。

为什么说模板引擎很重要？

模板引擎允许开发人员创建 HTML 等所需的内容形式，同时，它还提供条件判断和 for 循环等编程构件来对输出进行处理。 模板文件由预定义的标记和待插入内容的模板标签段组成， 这些文件由开发人员创建，然后再由模板引擎处理。

例如，查看当前网页的 HTML 内容的前 10 行源代码：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  5.     <meta charset="utf-8">
  6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  8.     <meta name="author" content="Matt Makai">
  9.     <meta name="description" content="Template engines provide programmatic output of formatted content such as HTML, XML or PDF.">
  10.     <link rel="shortcut icon" href="//static.fullstackpython.com/fsp-fav.png">

除了 这行，它是为各个单独页面提供包含哪些内容的简短描述之外， 上面的各行 HTML 代码对于 Full Stack Python 网站的每个页面来说都是一样的。

base.html 是用于创建 Full Stack Python 的 Jinja 模板，它使得网站的每个页面都有一致的 HTML 内容结构，同时又能为每个页面动态生成那些在 静态网站生成器 执行时需要修改的内容。下面的代码来自 base.html 模板，可以看到 meta 描述是要求子模板来生成的。

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  5.     <meta charset="utf-8">
  6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  8.     <meta name="author" content="Matt Makai">
  9.     {&#37; block meta_header &#37;}{&#37; endblock &#37;}
  10.     <link rel="shortcut icon" href="//static.fullstackpython.com/fsp-fav.png">

在一个典型的 WSGI 应用中，当某个特定 URL 的 HTTP 请求进来后，模板引擎将生成一个 HTML 文件的应答。

Python 模板引擎

Python 有几个比较流行的模板引擎。从允许执行任意代码，到只准许通过模板标签来执行有限的功能，每个模板引擎都有各自的实现方式。从下图可以看出 Python 的四个主要模板引擎的模板代码功能。

从不含任何逻辑代码到能执行任意代码。

Jinja

Jinja, 也叫做 "Jinja2"， 这个广受欢迎的 Python 模板引擎是作为一个独立的开源项目开发的，而不像其它的一些模板引擎那样是某个较大的 Web 框架的一部分。

主要的 Python 开源应用如 配置管理 工具 Ansible 和 SaltStack，以及 静态网站生成器 Pelican 等都默认使用 Jinja 来创建输出文件 。

在 Jinja2 页还有很多很多关于 Jinja 的学习内容。

Django 模板

Django （如 Django 1.9） 除了支持 Jinja 等其它一些可替代的模板引擎外，它还有 自己的模板引擎。

Mako

Mako 是 Pyramid Web 框架 的默认模板引擎，并且因作为许多 其它 Web 框架的替代模板引擎而广受支持。

模板引擎资源

Web 应用安全

构建 Web 应用的每个阶段都必须要考虑网络安全问题。但是，本节包含的主题内容，如跨站脚本 (XSS)， SQL 注入， 跨站请求伪造 (CSRF) 和公钥/私钥对的使用等，都值得我们特别关注。

网络安全开源项目

  • Bro 是一个网络安全及流量监测器。

  • 快速 NIX 安全脚本 能用于提升 Linux 发行版的安全性。

  • lynis 是一个非常好的安全审计工具，它能以 shell 脚本的形式在 Linux 系统上运行，以便找出系统漏洞加以修复，从而避免被恶意份子利用。

HTTPS 资源

通用网络安全资源

Web 安全学习清单

  • 阅读和了解那些经常会被恶意份子加以利用的主要 Web 应用安全漏洞。包括跨站请求伪造 (CSRF)、跨站脚本 (XSS)、SQL注入和会话劫持等。OWASP 前 10 位 Web 应用漏洞列表 是了解这些主题概念信息的好地方。

  • 检查你所选的框架是如何妥善处理这些漏洞的。

  • 确保你的代码也使用了框架提供的漏洞处置技术。

  • 以攻击者的角度进行思考，并主动攻击自己的系统。如果你没有经验来攻破安全防线，可以考虑雇用一位认识的白帽黑客。一旦攻破了应用的安全防线，应报告应用中最易被利用的漏洞，并帮助实现针对这些漏洞的保护措施。

  • 认识到没有系统是完全安全的。但是，应用系统越流行，就越可能会成为攻击目标。应经常对你的 Web 应用的安生性进行重新评估。

静态网站生成器

静态网站生成器结合标记语言（如 Markdown 或 reStructuredText）以及模板引擎，如 Jinja, 来生成 HTML 文件。这些 HTML 文件可以通过 Web 服务器 或者 内容分发网络 (CDN) 进行部署发布，而无需依赖 WSGI 服务器 等其它东西。

为什么说静态网站生成器很有用？

静态内容文件 如 HTML、CSS 和 JavaScript 文件可以由内容分发网络 (CDN) 来提供服务，以实现高规模及低成本的目标。静态内容网站一旦遇到高并发流量，能很容易地通过 CDN 来提供服务而不会丢失连接。

例如，在Full Stack Python 网站被推到 Hacker News 首页 的那个周末，由于本网站是通过将 GitHub Pages 作为 CDN 来提供服务的，因此并发连接即便接近 400 个时也没有碰到任何问题，如下图所示，该图是在流量井喷期间截取的 Google Analytics 截图。

Example of how static websites scale with a CDN based on Full Stack Python on Hacker News front page traffic.

静态网站生成器是如何工作的？

静态网站生成器允许用户通过使用某种标识语言编写模板文件来创建 HTML 文件。然后静态网站生成器结合标记语言和模板文件来生成 HTML 文件。输出的 HTML 文件不需要手工维护，因为当标签或者模板每次被修改后，它都能重新被创建出来。

例如，如下图所示， Pelican 静态网站生成器能将 reStructuredText 文件和 Jinja2 模板文件作为输入，然后将它们组合并输出一组静态 HTML 文件。

Example of how static site generators work with a markup language and templates.

使用静态网站生成器的缺点是什么？

最大的缺点是： 代码无法在网站生成后执行。你只能使用这些输出文件，因此如果你习惯用传统的 Web 框架 创建 Web 应用的话，你得改变下你的期望。

那些需要数据库来实现的功能，如评论、会话及用户数据，只能通过第三方的服务来提供。例如，如果你想在一个静态网站上添加评论功能，你需要 嵌入 Disqus 的评论框，从而只能完全依赖他们提供的功能。

很多的 Web 应用都不能简单地通过静态网站生成器来生成。但是，静态网站生成器可以用来生成网站的部分内容，并通过 Web 服务器来部署，而网站的其它页面可以由 WSGI 服务器来处理。如果处理得当，这种类型的 Web 应用比那些全部页面都由 WSGI 服务器呈现的应用更具扩展潜力。其增加的复杂度对于你的特定应用来说，可能是值得的，也可能并不值得。

Python 的实现

存在很多用不同的语言实现的静态网站生成器。以下列出的这些主要都是用 Python 编写的。

  • Pelican (源代码) 是一个常用的 Python 静态网站生成器， Full Stack Python 网站就是用它创建的。它的主要模板引擎是 Jinja，并且在默认配置下就支持 Markdown、 reStructuredText 及 AsciiDoc。

  • MkDocs (源代码) 使用 YAML 配置文件，并能将 Markdown 文件和一个可选的主题作为输入来创建一个文档网站。它的模板引擎是 Jinja，但是用户通常不必创建自己的模板，除非该特定的网站真得需要，但是如果是这样的话，采用其它的静态网站生成器可能会更加合适。

  • Nikola (源代码) 支持 reStructuredText、 Markdown 及 Jupyter (IPython) Notebooks 等文件，它能将这些文件与 Mako 或 Jinja2 模板结合来创建静态网站。它同时兼容 Python 2.7 和 3.3。对 Python 2.7 的支持会一直到 2016 年年初，而 Python 3.3 会继续得到支持。

  • Acrylamid (源代码) 使用增量方式来生成静态网站，因此相比每次当输入文件被修改后都重新生成所有页面的生成方式，它处理的更快。

  • Hyde (源代码) 最初是作为 Ruby 流行的 静态网站生成器 Jekyll 的 Python 版本而开始开发的。今天的这个项目已经不是原来的 "Jekyll 克隆版" 了。Hyde 支持 Jinja 及其它的模板语言，它更加注重通过标记文件中的元数据来指示生成器如何产生输出文件。 通过浏览这些 使用了 Hyde 的网站 页面，可以看看用 Hyde 创建的实际网站示例。

  • Grow SDK (源代码) 使用工程（通过叫 pods ），工程中包含一个特殊文件和目录结构，来生成网站。该项目当前停留在 "试验“ 阶段。

  • Lektor (源代码) 是一个 Python 的静态内容管理系统，它可以部署到任何的 Web 服务器上。它的 模板引擎 采用 Jinja2。

  • Complexity (源代码) 是一款为喜欢使用 HTML 的人准备的网站生成器。它使用 HTML 来创建模板，同时又从 Jinja 那继承了一些功能。它同时兼容 Python 2.6+、 3.3+ 和 PyPy。

  • Cactus (源代码) 使用 Django 模板引擎，该引擎在创建时就考虑了前端设计人员的需求。它同时兼容 Python 2.x 和 3.x。

开源 Python 静态网站生成器示例

静态网站生成器资源

静态网站部署相关资源

  • 在 AWS 上使用 S3 和 CloudFront 部署一个静态网站 上提供了一份非常不错的教程，并附有截图，讲解了任何类型的静态网站如何在 AWS 上使用 S3 和 Cloudfront 进行设置。

  • 使用 S3 和 Cloudflare 部署静态网站 讲解了如何设置 S3 存储段，并在前端配置 Cloudflare 作为 CDN，以通过 HTTPS 来提供内容服务。你应该可以使用 Amazon Cloudfront 来实现大致相同的设置，但是作为一个 Cloudflare 用户，我还是喜欢它们的这种静态网站配置服务。

  • Google Cloud 提供了一篇教程讲解了如何使用它们来 部署你的静态网站。值得注意的是你现在还无法在 Google 存储服务器上使用 HTTPS，这是一个很大的遗憾。

Jinja2

Jinja2 是一个 Python 模板引擎，用于创建 HTML、XML 等其它标记格式文件，这些文件能通过 HTTP 响应返回给用户。

为什么说 Jinja2 很有用？

Jinja2 有用的原因是：它具有一致的模板标签语法，并且该项目完全是作为 一个独立的开源项目 存在的，因此它能用于其它的代码库中。

Jinja2 是对 模板引擎 概念的一种实现。 到 Web 开发 那一章去学习更多相关知识，或者到 总目录 页去查看其它所有主题。

对于一个模板引擎的代码功能来说，一个极端是允许将任意的代码嵌入到模板中，另一个极端是允许一个开发者在模板中编写任何她想要的功能。Jinja2 的实现经过了大量的考虑 ，并在这两者之前取得了一个很好的平衡。

Jinja2 的起源和发展

Jinja2 的第一个有记录的公开发行版是 2008 的 2.0rc1。自那之后，该引擎进行了大量的更新，且一直处于活跃开发状态。

Jinja2 引擎当然不是最好的模板引擎。实际上，Jinja2 语法是受到 Django 内置模板引擎启发的， Django 的相关引擎在好几年前就已发布了。之前就已经有很多的模板系统了，例如 JavaServer 页面 (JSPs)，它就比 Jinja2 将近早了十年。Jinja2 的创建吸收了其它模板引擎的经验，而今它在 Python 社区中有着广泛应用。

哪些项目使用了 Jinja2？

Jinja2 是一个在 Web 框架 中经常使用的模板引擎，像 Flask、Bottle、 Morepath 以及随着 1.8 版的更新，现在的 Django 也可选用该引擎了。 Jinja2 也被 配置管理 工具 Ansible 、静态网站生成器 Pelican 等其它许多类似工具用作模板语言。

其目标是：当开发人员已经通过某个项目学会了 Jinja2，那么在另一个需要模板功能的项目中就可以使用完全相同的语法和样式。复用降低了学习曲线并使得开源项目作者免于重造一种新的模板样式。

Jinja2 相关资源

数据

虽然数据是一个极其庞大的主题，但它可以细分成许多的子主题，包括（排序不分先后）：

针对以上的所有主题， Python 社区已经创建并将持续创建大量的开源库和教程资料。

为什么说 Python 是一门处理数据任务的好语言？

Python 有着广泛的开源代码库，它的社区成员来自各行各业，具有不同的行业背景，他们的贡献使得这些库变得日益精良。

另外， Python 处理数据的相关代码能和 Web 框架 及 Web API 结合，从而创建一些很难用其它语言创建的软件。例如，Ruby 对于创建 Web 应用来说是一门极好的语言，但是它的数据分析和可视化的相关库，相比于 Python 生态系统的当前状况，会显得相当匮乏。

Python 基于数据的应用为何变得如此广泛？

Python 是一门通用编程语言，它适用于很多的问题领域。在过去的几十年中， Python 在科学和金融社区中变得越来越流行。那些项目，像 pandas 已经成长为一个由对冲基金赞助的项目了，而 NumPy 和 SciPy 都是在学术环境中创建的，之后的改进由更广大的开源社区进行。

问题是：为什么使用 Python 来创建这些项目？答案是运气和开源社区的成长皆而有之：随着 Python 的成熟，那些没有按计算机科学家的标准通过正式培训的人也能开始使用了。它的实效型语法和显式方式，使得那些没有编程背景知识的高智商的人们能够立即拾起这门语言，以相比于其它编程语言更加自然的方式完成他们自己的工作，而正是这种广泛采用促进了社区的发展。随着时间的推移，在金融界和科学社区中使用的这些代码被共享了出来，与此同时，全球的开源社区也正在蓬勃发展，这进一步促进了它在更多的软件开发者中的流行和使用。

在 Python 被广泛用于处理所有类型的数据的背后，毫无疑问有这样的因素：它恰好是那个地点那个时间最合适的那门语言。尽管如此，创建如今这么多的数据处理代码库，对于全球范围内的大量工程师和科学家来说，也是一项相当艰巨的工作。

通用 Python 数据相关的资源

数据库

数据库是建立在操作系统的文件系统之上的一种抽象，它使得对持久性数据的创建、读取、更新和删除等的操作变得更加容易。

为什么说数据库很有必要？

Web 应用在更高的层次上存储数据并以更有用的方式将数据呈现给用户。例如，Google 存储道路相关的数据，但它通过 地图 应用可向我们提供从一个地点到另一个地点的驾驶向导。因为数据是按结构化方式存储的，因此提供驾驶向导是可能的。

数据库使得结构化存储变得即可靠又快速。它们还提供了一种数据应该如何被保存和提取的认知模型，因而你无需在每次创建新应用时都要指出如何处理数据。

对数据库这个概念的实现有很多种，包括 PostgreSQL、 MySQL 和 SQLite 等。 还存在被称为 NoSQL 数据存储 的非关系型数据库。到 数据 这一章学习更多的相关知识，或者到 总目录页 去查看全部主题。

关系型数据库

Python Web 应用中用得最多的数据存储抽象是一组关系型数据表。另外的存储抽象会在 NoSQL 页讲解。

关系型数据库将数据存储在一系列的数据表中。数据表之间的互连关系通过 外键 指定。外键是从一个关系型数据表的一行指向某表的另一行的一个唯一引用，被指向的某表可以和指向的表相同，但是通常是不同的表。

数据库存储的实现在复杂度上各有不同。SQLite，是一种包含在 Python 中的数据库系统，它为每个数据库创建一个单独的文件来存放数据。其它的数据库系统，如 PostgreSQL、 MySQL、 Oracle 和 Microsoft SQL Server 都具有更加复杂的持久化方案，并且提供对 Web 应用很有用的额外高级功能。这些高级功能包括但不限于：

  • 一个主数据库和一个或多个只读从数据库实例之间的数据复制功能
  • 能高效存储如 JavaScript 对象标记 (JSON) 等半结构化数据的高级列类型
  • 允许在多个数据库间进行水平扩展的数据分片，分片以数据一致性的延迟为代价，使得每个分片都能作为一个可读写的实例使用。
  • 监测、分析及能提供数据库模式和表的其它有用的运行时信息的功能。

通常， Web 应用开始时只使用一个数据库实例，比如用只有一个直接模式的 PostgreSQL。随着时间的推移，数据库模式演变成了使用模式迁移的更加复杂的结构，而像复制、分片、监测等高级功能，随着应用用户的需求及数据库使用的增加，也变得越来越有用。

Python Web 应用最常用的数据库

PostgreSQL 和 MySQL 是用于存储 Python Web 应用数据的两个最常用的开源数据库。

SQLite 是一种将数据存储在存储器的单个文件上的数据库。 SQLite 内置在 Python 中，但是每次允许一个连接对它进行存取。因此强烈建议不要 在 Web 应用的生产环境中使用 SQLite。

PostgreSQL

PostgreSQL 是被推荐在 Python Web 应用中使用的一种关系型数据库。它的功能集、活跃的开发及稳定性使得当今数以百万计的 Web 应用都将它作为后端使用。

在 PostgreSQL 页 上了解更多关于在 Python 中使用 PostgreSQL 的知识。

MySQL

MySQL 是能在 Python 应用中使用的另一种可靠的开源数据库实现。MySQL 相比 PostgreSQL 更易入门，但是它没有 PostgreSQL 功能丰富。

到专门的 MySQL 页 上了解有关在 Python 应用中使用 MySQL 的知识。

用 Python 连接数据库

要通过 Python 来处理关系型数据库，你需要使用代码库。 连接关系型数据库的最常用库是：

对 SQLite 的支持已内置于 Python 2.7+ 中，因此不需要另外的库。只需 "import sqlite3" 就能开始与这个基于单文件的数据库进行交互了。

对象-关系 映射

对象-关系 映射器 (ORM) 使得开发人员无需写 SQL 查询语句，而只需编写 Python 代码就能从后端存取数据。每个 Web 应用框架对 ORM 的集成处理都有所不同。有 一整页是专门讲述对象-关系 映射 (ORM) 的，你应该可以通过它来了解这个主题知识。

数据库第三方服务

许多公司运营着可扩展的数据库服务器来提供托管服务。托管的数据库，根据提供商的不同，通常能提供自动化的备份和恢复，强化了的安全配置和方便的垂直扩展等功能。

  • Amazon 关系型数据库服务 (RDS) 提供预配置的 MySQL 和 PostgreSQL 实例。根据存储和性能的需求，这些实例可以按需扩大或缩小配置。

  • Google 云 SQL 服务提供受控的、可备份、可复制和自动进行补丁更新的 MySQL 实例。云 SQL 与 Google App Engine 集成在一起，但是也可以单独使用。

  • BitCan 同时提供 MySQL 和 MongoDB 托管服务器，并具有可扩展的备份服务。

  • ElephantSQL 是一家 “服务即服务” 的公司，它托管 PostgreSQL 数据库，并且基于 Amazon Web 服务实例对服务器的配置、备份和数据连接进行处理。

通用数据库相关资源

  • 关系型数据库是如何运作的？ 这篇长文详细讲述了排序、查询、合并及其它我们使用像 PostgreSQL 等已连接的关系型数据库时常常熟视无睹的这些操作。

  • 我为什么喜欢数据库 是一篇非常精彩的文章，讲述了 CAP 原理（CAP Theorem）、分布式系统以及有关数据库理论和实现的核心知识的其它主题。

  • 编写更好的 SQL 代码 这篇简短的代码风格指南能教你编写出更加易读的查询语句。

  • 数据库引擎 对最流行的数据库管理系统进行了排序。

  • 数据库周刊 是一份关于通用数据库的文章和资源的每周集锦。

  • 数据库集成测试策略 讲述的这个不一样的主题，在每一个现实项目中都会碰到。

  • 异步 Python 和数据库 这篇文章就阻塞与异步事件模型的差异，导致许多 Python 数据库驱动不进行修改不能使用这个问题进行了深入的讲解。假如你想通过 Tornado 或 gevent 使用 WebSockets 的话，绝对值得一读。

  • PostgreSQL vs. MS SQL 服务器 以一个数据分析师的视角对这两个数据库服务器之间的区别进行了说明。

数据库学习清单

  • 在你的服务器上安装 PostgreSQL。假设你在 Ubuntu 上使用以下命令安装： sudo apt-get install postgresql。

  • 确保 psycopg2 库在你的应用的依赖文件中。

  • 配置你的 Web 应用，使其连接到这个 PostgreSQL 实例。

  • 可以通过 Django 内置的 ORM 或者 Flask 的 SQLAlchemy，在你的 ORM 中创建数据模型。

  • 创建数据库表，或者如果使用了 ORM 的话，将你的 ORM 模型与 PostgreSQL 实例进行同步。

  • 通过你的 Web 应用，开始在数据库中创建、读取、更新和删除数据。

NoSQL 数据存储

绝大多数的 Web 系统都采用关系型数据库存储系统来持久化数据。但是还有另外几种不同的存储表示形式。

  • 键值对
  • 面向文档
  • 列簇表
  • 图

这些持久化数据存储表示法通常不是用来完全替代关系型数据库的，而是作为辅助使用的。由于 NoSQL 数据库所采用的低层持久化形式与关系型数据库不同，这通常也导致了不同的性能特性：在某些读/写条件下有更好的表现，而在另外一些条件下则性能欠佳。

键值对

键值对型的数据存储系统基于 哈希映射 这个数据结构。

键值对数据存储

  • Redis 是一个开源的内存键值对数据存储系统。Redis 经常被称为 ”Web 应用开发的瑞士军刀“。它可用于存储缓存、列队、和会话数据等，在多数案例中，它的存取速度都比传统关系型数据库快。 Redis-py 是 Python 用于操作 Redis 的一个健壮的客户端。

  • Memcached 是另一个广泛使用的内存键值对存储系统。

键值对相关资源

Redis 相关资源

Redis 安全性

应该对 Redis 的默认配置进行修改，从而能防范未认证和未授权的用户。下面这些资源提供了关于 Redis 安全性及数据防护的一些建议。

  • 针对 Redis 服务器的渗透测试 阐述了安全问题无论在你的应用中还是你使用的数据库上都是非常重要的。

  • Redis，和其它任何的关系型或者 NoSQL 数据库一样，都需要依据 安全准则 进行安全设置。这有一篇文章讲述了 Redis 的主要作者 通过攻击 Redis 来展示了 Redis 默认配置在易用性和安全性之间进行的权衡。

面向文档

面向文档的数据库为嵌套数据提供半结构化的表示方式。

面向文档的数据存储系统

  • MongoDB 是一个开源的面向文档的数据存储系统，它使用二进制对象表示法 (BSON）存储格式，该格式和 JSON 类似，因此 Web 开发人员都很熟悉。PyMongo 这个客户端在 Python 代码中通常被用于和一个或多个 MongoDB 实例交互。MongoEngine 是一个针对 MongoDB 的 Python ORM 系统，它基于 PyMongo 开发。

  • Riak 是一个开源的分布式数据存储系统，它注重可用性、容错性和大规模可部署性。

  • Apache CouchDB 也是一个开源项目，它的关注点是倡导使用 RESTful 风格的 HTTP 存取方式来处理存储的 JSON 数据。

面向文档的数据存储系统相关资源

  • 初创公司使用 MongoDB 是关于在新兴领域使用非关系型数据库的一篇指南性文章。

  • PyMongo 的创造者和维护者总结了他们在创建这个广受使用的 Python MongoDB 驱动时所下的四个错误决定。

  • “和我一起聊 Python” 播客上的 Python 和 MongoDB 这期节目对 MongoDB 的 Python 驱动维护者进行了一次精彩的采访。

  • MongoDB 查询不是总能返回全部的匹配文档！ 演示了如何去了解 MongoDB 查询操作的实际工作原理，并阐述了依赖那些你还没有完全理解其运作原理的技术会埋下潜在的意想不到的风险。

列蔟表

列蔟表形式的 NoSQL 数据存储系统基于键值对类型。 每个键值对可以被认为是一行，而列蔟则可类比于关系型数据库模型中的一个表。

列蔟表数据存储系统

图

图数据库通过三个方面来表示和存储数据：结点、边和属性。

一个 结点 表示一个实体，如一个人或一家公司。

一条 边 表示两个实体之间的关系。例如，一条边可以表示人实体结点和公司实体结点之间的雇佣关系。

属性 用于表示结点的相关信息。例如，表示一个人的实体可能会有一个性别属性。

图数据存储系统

  • Neo4j 是一个最常用的图数据库，它运行于 Java 虚拟机系统之上。

  • Cayley 是一个开源的图数据存储系统，它由 Google 发布，并且主要是用 Go 编写的。

  • Titan 是针对多结点簇而开发的一个分布式图数据库。

图数据存储系统相关资源

  • 图数据库简介 上的内容涵盖了 NoSQL 数据存储的发展趋势以及图数据库与其它类型的数据存储系统的对比。

NoSQL 第三方服务

  • MongoHQ 提供 MongoDB 服务。 它无论是在标准的 LAMP 堆栈上还是在 Heroku 上都非常容易设置。

NoSQL 数据存储系统相关资源

  • NoSQL 数据库: 概论 讲解了什么是 NoSQL，相较于关系型系统，数据是如何以不同方式被存储的，以及什么是一致性、可用性和分区容忍性 (CAP) 定律。

  • CAP 定律概述 介绍了所有数据库操作中必须权衡的一些基本限制。

  • 什么是 NoSQL 数据库？通过 Python 编写一个来学习 这篇详细的文章揭开了 NoSQL 数据库低层是如何运作的神秘面纱。

  • CAP 定律系列 讲解了与 NoSQL 相关的一些概念，如 ACID 与 CAP 的对比， CP 与 CA 的对比，以及大规模部署环境下的高可用性。

  • NoSQL 周刊 这份免费的电子邮件时讯聚合了有关非关系型数据存储的文章、教程和视频内容。

  • NoSQL 比较 列出了大量流行的、基于 BigTable的、特殊用途等的数据库系统，并对每个数据库的特性及其最佳用途做了说明。

  • MySQL 和 PostgreSQL 等关系型数据库在其最近的版本中都加入了一些特性来模仿 NoSQL 数据存储系统的一些功能。例如，可以查看这篇博客 将 MySQL 作为一个键值对存储系统使用 和这篇文章 在 PostgreSQL 中存储 JSON。

NoSQL 数据存储系统学习清单

  • 理解 NoSQL 数据存储系统为什么在某些情况下使用会比关系型数据库更适合。但是通常这些优势只能在大规模的情况下才能显现出来，因此可能不太适用于你的 Web 应用。

  • 将 Redis 整合入你的项目中，相比于较慢的持久化存储系统， 这能提升速度。将会话数据保存在内存中，相比于将数据保存在使用持久化存储器的传统关系型数据库中，通常来说运行会更快。值得注意的是当内存清空后，其中的数据会被删除，因此任何需要持久化保持的数据仍须定期备份到磁盘上。

  • 评估其它的用例，如将临时的日志存储到 MongoDB 等面向文档的数据存储系统中。

对象关系映射器 (ORM)

对象关系映射器 (ORM) 是一种代码库，它能自动将存储在关系型数据库表中的数据转化成在应用程序代码中更加常用的对象。

为什么 ORM 很有用？

ORM 为 关系型数据库 提供了高级的抽象，它使得开发人员不必写 SQL，只需写 Python 代码就能在数据库中创建、读取、更新和删除数据。开发人员能使用他们熟悉的编程语言来处理数据库，而无需编写 SQL 语句或存储过程。

例如，如果没有 ORM 的话，开发人员需要编写以下的 SQL 语句来读取 USERS 表中的 zip_code 列的值为 94107 的所有行：

  1. SELECT * FROM USERS WHERE zip_code=94107;

而其相应的 Django ORM 查询语句看起来会如下面的 Python 代码：

  1. # obtain everyone in the 94107 zip code and assign to users variable
  2. users = Users.objects.filter(zip_code=94107)

编写 Python 代码来代替编写 SQL，能提高 Web 应用的开发速度，特别是在项目前期的时候。开发速度的提升潜力源于无需从编写 Python 代码切换到编写声明式的 SQL 语句。虽然有些开发人员可能不太介意在两种语言间来回切换，但是使用一种编程语言对于捣鼓出一个原型或者开始创建一个 Web 应用通常更加容易。

从理论上来说，ORM 也使得应用程序在不同的关系型数据库之间切换使用变得可能。比如说，开发人员可以在本地开发中使用 SQLite，然后在生产环境中使用 MySQL。 只需进行少量的代码修改，生产环境中的应用就能实现从 MySQL 切换到 PostgreSQL。

但在实践中，本地开发环境和生产环境最好使用相同的数据库。不然的话，在本地开发环境从未碰到的一些始料未及的错误可能会出现在生产环境中。而且，对于一个项目来说，很少有需将生产环境中的数据库切换到另一个数据库的情况，除非有很紧急的原由。

学习 ORM 的时候，你也应该学习下 部署 和 应用依赖 章节。

我需要在我的 Web 应用使用 ORM 吗？

Python ORM 库对于存取关系型数据库来说不是必须的。实现上，低层的存取接口通常是由另一个叫 数据库连接器 的库来提供的，例如 psycopg (用于 PostgreSQL) 或 MySQL-python (用于 MySQL) 等。 下表列出了 ORM 与不同的 Web 框架、连接器及关系型 数据库一起使用的情况。

各种 Python ORM 如何能与不同的连接器及后端一起使用的例子。

从上面的表格中可以看出，例如，SQLAlchemy 能与不同的 Web 框架和数据库连接器一起使用。开发人员也可以撇开 Web 框架单独使用 ORM，比如在创建一个数据分析工具或者没有用户界面的批处理脚本时。

使用 ORM 有什么缺点？

ORM 有很多的缺点，包括：

  • 阻抗失配
  • 有可能降低性能
  • 将复杂性从数据库转移到了应用程序代码中

阻抗失配

“阻抗失配” 这个术语通常和 ORM 一起使用。阻抗失配这个术语，是对于数据在关系型数据表与应用程序对象之间变换时的所有难度的总称。其要点是：开发人员使用对象的方式与数据在关系型数据表中如何被存储和关联是有差异的。

这篇关于 ORM 阻抗失配的文章 对该概念进行了细致的综述，并提供图表以可视化方式解析了该问题发生的原因。

降低性能的潜在可能

使用任何一个高级抽象或框架，存在的其中一个顾虑是有存在降低性能的潜在可能性。使用 ORM 时，性能影响因素源自：应用代码会被转化成没有被合理调优过的 SQL 语句。

ORM 通常是上手容易但真正掌握很难。比如说，一个 Django 新手无需知道 select_related() function 及其如何能提升某些外键关联型查询的性能等知识，就能使用 ORM 了。每种 ORM 都有许多有关性能的提示和技巧。花时间学习这些技能比只学习 SQL 及如何编写存储过程可能有用的多。

这章里有许多显而易见的 “可能或可能不” 以及 ”潜在的“ 等字眼。在大型项目中，ORM 非常适用于大约 80-90% 的情况，而项目中剩下 10-20% 的数据库交互操作，可以由经验丰富的数据库管理员编写调优过的 SQL 语句来代码 ORM 生成的 SQL 代码，从而使其性能得到显著提高。

将复杂度从数据库转到应用程序代码

我们需要编写一些代码来处理应用的数据。在 ORM 之前，数据库存储过程被用于封装数据库逻辑。而在 ORM 中，操作数据的代码存在于应用的 Python 代码中。这些额外的数据操作逻辑，对于一个设计良好的应用来说，通常都不会成为一个问题，但因其没有在应用程序和数据库存储过程之间将代码进行拆分，从而提高了 Python 的总代码量。

Python ORM 的实现

存在很多个用 Python 编写的 ORM 实现，包括

还有其他一些 ORM, 例如 Canonical 的 Storm，但是其中大多数现在看来都已经停止开发了。让我们进一步了解以下几个主要的还活跃着的 ORM 吧。

Django ORM

Django Web 框架有自己内置的对象-关系映射模块，通常被称作 "the Django ORM" 或 "Django's ORM"。

Django 的 ORM 适用于简单或中等复杂度的数据库操作。但是，人们通常抱怨说：该 ORM 基于复杂的查询操作转化而成的 SQL 语句，相比于直接用 SQL 编写或者用 SQLAlchemy 产生的语句，更加的繁琐。

从技术上来说可以直接使用低层的 SQL，但是这种方式会将查询与某个特定的数据库绑定在一起。该 ORM 与 Django 是紧密捆绑的，因而要想用 SQLAlchemy 来代替默认的 ORM 当前还是一门技术活。考虑到一些 Django 核心贡献者都认为默认的 ORM 被 SQLAlchemy 替代只是时间问题。但要想实现该目标还有很多路要走，可能会在 Django 1.9 或之后 的版本才会实现。

因为大多数 Django 项目都使用默认的 ORM，因此我们最好多了解下一些高级的使用案例和工具，从而能更好地使用该框架。

SQLAlchemy

SQLAlchemy 是个广受好评的 Python ORM。它的抽象层做的 ”恰当好处“，并且在绝大多数情况下，相比 Django ORM，它能简化复杂数据库查询语句的编写工作。在 Flask 中，SQLAlchemy 通过 Flask-SQLAlchemy 扩展而被用作数据库 ORM。

Peewee

Peewee 这个 Python ORM 的目标是： 比 SQLAlchemy "更简单、更小及更加 hackable" 。Peewee 的核心作者使用的比喻为： Peewee 对于 SQLAlchemy，就像 SQLite 对于 PostgreSQL。一个 ORM 无需适用于所有的使用情况也能被认为是有用的。

Pony

Pony ORM 是另一种 Python ORM，它的许可模型有些许不同。该项目使用多种许可。Pony 用于开源项目是免费的，但是用于商业项目需要 商业许可。该许可只需要一次性费用，无需周期付费。

SQLObject

SQLObject 这个 ORM 自 2003 年前 就已处于活跃的开源开发了。

模式迁移

模式迁移，例如添加一个列到数据库的某个表格中等操作，从技术上来说都不属于 ORM 范畴。但是，由于 ORM 通常是间接地操作数据库（在多数情况下需开发人员自担风险），因此在应用程序项目中，执行模式迁移的库通常和 Python ORM 一起使用。

数据库模式迁移是一个复杂的主题，需要专门的一页来讲解。现在，我们粗略地将模式迁移相关资源列在 ORM 链接之后。

通用 ORM 相关资源

  • 还有一个网页就 什么是 ORM 进行了细致的概述。

  • 这个 GitHub 上的示例项目 将这个相同的 Flask 应用用多个不同的 ORM 进行了实现： SQLAlchemy、 Peewee、 MongoEngine、 stdnet 及 PonyORM。

  • Martin Fowler 在一篇文章中提到了 人们对 ORM 的厌恶，讲述了 ORM 是如何被误用的，及说明它们对开发人员其实是有帮助的。

  • 如果你被连接器之间的区别搞糊涂了，比如 MySQL-python 和一个像 SQLAlchemy 等的 ORM，那么看下针对这个主题的 StackOverflow 上的解答。

Django ORM 相关资源

SQLAlchemy 相关资源

Peewee 相关资源

Pony ORM 相关资源

SQLObject 相关资源

PostgreSQL

PostgreSQL， 通常写作 "Postgres"，发音为 "Poss-gres"， 是一款开源的 关系型数据库 实现，它常在 Python 应用中作为数据存取的后端使用。

PostgreSQL logo.

PostgreSQL 如何应用于 Python 开发？

PostgreSQL 是很多 Python 开发人员的默认数据库选项，包括 Django 团队在测试 Django ORM 时也选得它。 相比于 MySQL、SQLServer 和 Oracle，人们通常认为 PostgreSQL 具有更多功能且更加稳定。选择以上任何一款数据库都没有错。但是，由于 PostgreSQL 倾向于被较多的 Python 开发人员选用，因而针对该数据库的驱动器和示例代码也会有更好的文档，在典型使用场景中存在 BUG 的几率也会更小。如果你想在 Django 中使用 Oracle，你会发现有关 Oracle 的配置示例代码相比 PostgreSQL 后端的少得多。

PostgreSQL 是对 关系型数据库 概念的一种实现。在 数据 那一章学习更多相关知识，或者到 总目录页 了解所有主题。

为什么说 PostgreSQL 是一个不错的数据库选择？

PostgreSQL 的开源许可允许开发人员无需考虑许可费用问题就可操作一个或多个数据库。开源许可运营模式相较于 Oracle 或其它专有数据库，其花费更少，特别是在规模增加到需要复制和分片的时候。另外，由于从独立开发人员和跨国组织等的大量人员使用 PostgreSQL，因而相比于其它的关系型数据库，找到具有 PostgreSQL 经验的开发人员通常容易的多。

PostgreSQL 核心团队还经常发布更新，从而显著提高了数据库的能力。例如， PostgreSQL 9.4 版本 就增加了 jsonb 类型，用来增强对 JavaScript 对象表示 (JSON) 的存储能力，从而减少了在一个应用体系中另外再使用一个独立 NoSQL 数据库 的需求。

在 Python 中连接 PostgreSQL

在 Python 中使用关系型数据库，需要一个数据库驱动器，通常也叫作数据库连接器。连接 PostgreSQL 的最常用驱动库是 psycopg2。在 PostgreSQL 官网的 wiki 页上有一份有关所有驱动器的列表，其中包括了一些已经不再维护了的库。如果你使用 asyncio 这个 Python 标准库 的话，你还应该了解下 aiopg，它还封装了 psycopg2 的异步操作功能。

要想在数据表和对象间抽象出对应关系，许多 Python 开发人员会利用 对象-关系映射器 (ORM) 来将 PostgreSQL 中的关系型数据转化成可以在 Python 代码中使用的对象。例如，PostgreSQL 提供关系型数据库功能，而 psycopg 是常用的数据库连接器，但很多 ORM 能用于各种不同的 Web 框架，如下图所示。

各种不同的 Python ORM 如何与 PostgreSQL 和 psycopg2 连接器一起使用的例子。

到 关于 Python ORM 主题的特定页 了解更多知识。

PostgreSQL 数据安全性

如果你使用 Linux，那么使用包管理器就能很容易地安装 PostgreSQL。但是，一旦数据库安装运行后，你的责任才刚刚开始。在将其用于生产环境前，确保：

尽可以邀请有资质的人员进行一次 PostgreSQL 安全审计，以便找出数据库中的最大安全隐患。小型应用和初创公司刚开始通常负担不了一个全职审计员，但是随着应用程序的发展，它将越有可能成为攻击目标。

存储在数据库中的数据是应用的生命力所在。如果你曾经 不小心删除过一个生产环境中的数据库 或者是 SQL 注入攻击等恶意行为的受害者，你就会明白：只需事先进行诸如备份、复制和安全举措等额外一点儿工作，都能使数据恢复变得更加容易。

针对 Python 的 PostgreSQL 相关资源

有很多针对 Django、Flask 及其它 Web 框架的入门教程资料。以下列出的几篇是我读过的最好的。

通用 PostgreSQL 相关资源

不是专门针对 Python 的 PostgreSQL 教程对于正确处理数据也是相当有帮助的。

PostgreSQL 监测与性能

监测一个或多个 PostgreSQL 实例，然后对它们进行优化是一项罕见技能。如果你想在应用中处理这些问题，下面的一些资源能帮助你入门。

  • 这篇 PostgreSQL 监测指南 对于了解需要监测什么及如何监测十分便捷有用。

  • Craig Kerstiens 写了一篇有关 理解 PostgreSQL 性能 的详细文章。

  • PostgreSQL 优化实践指南 讲述了通过使用缓存大小、恢复配置和共享缓存来提高数据库性能。

  • 这篇关于 PostgreSQL 性能调优 的文章，其内容覆盖了如何查找慢速查询、调整索引及修改查询使其运行更快。

  • 从 PostgreSQL 中获取性能信息 讲解了如何收集常用的性能度量值，并提供了获取这些信息需要运行的查询语句。该文还讲述了性能监测及如何分析触发函数。

  • PostgreSQL 监测查询 是一个有关 SQL 查询的简单的 GitHub 项目，它可运行于一个 PostgreSQL 实例来对其用量、缓存和膨胀进行侦测。

MySQL

MySQL 是 关系型数据库 的一种开源实现，它用于存取数据。

MySQL logo.

MySQL 还是 PostgreSQL？

MySQL 是一款可运用于 Python Web 应用的开源数据库实现。MySQL 相比 PostgreSQL 更易入门。但是，Python Web 开发人员通常更偏爱 PostgreSQL 的设计，特别在随着应用程序的演进需要进行数据迁移的时候。

MySQL 是对 关系型数据库 概念的一种实现。 在 数据 那一章学习更多相关知识，或者到 总目录页 了解所有主题。

MySQL 的 Python 驱动器

在 Python 应用中访问 MySQL 需要一个数据库驱动器（也叫作 “连接器”）。当然驱动器可以作为应用的一部分进行编写，但是实践中多数开发人员会采用一个现成的开源驱动器。

随着 Python 3 的引入，MySQL 驱动器出现了一个大问题。 MySQLdb 是最流行的库之一，但是它现在无法与 Python 3 兼容，并且还没有更新计划。于是出现了 MySQLdb 的一个分支，叫 mysqlclient，它增加了对 Python 3 的兼容性。

mysqlclient 分支很不错，因此当前的 MySQLdb 用户在升级到 Python 3 后，在现有项目中只需用 mysqlclient 代替即可。但是，当查找该用哪个 Python 驱动器连接 MySQL 时，该分支经常会造成些许困惑。PostgreSQL 社区对 Python 驱动提供了更好的支持，因此很多开发者决定选用 PostgreSQL。

抛开驱动器的支持问题，当然完全可以在 Python 3 Web 应用中选用 MySQL 作为后端。这里是一份驱动器列表，并附有对 Python 2、3 或两者的支持度的说明。

  • mysqlclient 是一个 MySQLdb 分支，它支持 Python 2 和 3。

  • MySQL 连接器 是 Oracle 的 “官方” （Oracle 当前拥有 MySQL）Python连接器。该驱动器支持 Python 2 和 3，但是确保到 版本指南 上了解哪个发行版与哪个 Python 版本兼容。

  • MySQLdb 支持 Python 2，在大家还没有开始迁移到 Python 3 之前，经常运用于 Python Web 应用程序中。

  • PyMySQL 用纯 Python (没有 C 低层代码）实现，意在成为 MySQLdb 的直接替代品。但是，该驱动器还不支持一些 MySQL API，因此你的应用是否能用该连接器将取决于你使用了哪些接口。

哪些组织使用 MySQL？

该数据库已实际部署在了一些高流量的网站上，如 Twitter、 Facebook 和 许多其它大型机构。但是，因开发 MySQL 的公司 MySQL AB，已经被 Sun Microsystems (它后来又被 Oracle 收购）收购，像 Wikipedia 和 Google 等都开始不用该数据库了。MySQL 仍然是一个可行的数据库选项，但是我一直推荐还没有学过 MySQL 的 Python 开发人员学习 PostgreSQL。

针对 Python 的 MySQL 相关资源

通用 MySQL 相关资源

SQLite

SQLite 是一款开源的关系型数据库，它自 Python 2.5 开始就已包含于 Python 标准库中。pysqlite 这个数据库驱动器也已包含在了标准库中，因此在 Python 应用中访问一个 SQLite 数据库不再需要任何的外部依赖包。

SQLite logo.

SQLite 是对 关系型数据库 概念的一种实现。 在 数据 那一章学习更多相关知识，或者到 总目录页 了解所有主题。

SQLite 相关资源

应用程序编程接口

应用程序编程接口 (APIs) 使得应用程序间能进行数据转移和信号交换。

API 为什么重要？

HTML、 CSS 和 JavaScript 为人类创建网页。但是，这些页面难以被机器使用。

有很多的抓取工具或库可以用来提取 HTML 页面中的数据，但是通过 API 来获取数据会更加容易。例如，要想获取一篇新闻内容，通过 API 来获取比从 HTML 页面中提取会更加容易。

API 关键概念

API 的世界里有几个关键概念。在深入研究 API 之前最好把它们都弄明白先。

  • 表述性状态转移 (REST)

  • Webhooks

  • JavaScript 对象标记 (JSON) 及可扩展标记语言 (XML)

  • Endpoints

Webhooks

一个 Webhook 就是由用户定义的 一个 HTTP 回调 URL，它会在系统条件满足时被调用。回调会以 POST 或 GET 请求的方式进行，通常也进行传输数据，从而知会其它系统。

Webhooks 之所以重要是因为它们能为 API 开启双向通讯。Webhook 的便捷性，源自它是由 API 用户定义的，而非 API 本身定义。

例如，在 Twilio API 中，当一条短信发送到 Twilio 的手机号码后，Twilio 会向用户指定的某个 URL 发送一条 HTTP POST 请求。该 URL 通过 Twilio 号码页上的一个文本框进行定义，如下图所示。

在 Twilio APi 中定义的 Webhook。

API 开源项目

  • Swagger 是一个用 Scala 编写的开源项目，它为 RESTful API 定义了一个标准接口。

API 相关资源

  • Zapier 上有一份免费指南叫 APIs 101，讲述了什么是 API，为什么它们很有价值及如何正确使用。

  • GET PUT POST 是一份专注于 API 知识的时讯。已发行版中包含有对 Stripe、 Dropbox 和 Coinbase 开发人员的采访。

  • RESTful 到底是什么 用平实的语言对 REST 的原理进行了精彩的讲解，并讲述了它们进化到当前状态的相关历史背景。

  • 由 Nick Quinlan 写的 什么是 webhook？ 这篇文章，用平实的语言解释了什么是 Webhook，以及为什么它们在 API 世界中有必要存在。

  • 简单性和实用性，或者，为什么 SOAP 衰败了 就当前为何基于 JSON 的 Web 服务会比那个在 21 世纪早期曾盛极一时的 SOAP 更流行等问题提供了相关的背景知识。

  • 适合各种场合的 API 工具 列出了 10 个工具列出，它们在处理 API 时真得非常有用，并且都是 2015 年最新的。

API 学习清单

  • 学习 API 相关概念—使用 JSON、XML、Endpoint 和 Webhook 的机器间通信。

  • 将 API，比如 Twilio 或 Stripe，集成到你的 Web 应用中。阅读 API 集成 那一章来学习更多相关信息。

  • 使用框架为你自己的应用创建一份 API。到 API 创建 页学习关于 Web API 框架的相关知识。

  • 将你的 Web 应用 API 公布出来，从而使其它应用能获取你想共享的那些数据。

API 集成

大部分生产环境中的 Python Web 应用都依赖一些外部托管的应用程序编程接口 (API)。API 也通常被称作第三方服务或外部平台。 这样的例子包括提供信息和语音服务的 Twilio，提供支付处理的 Stripe 和提供嵌入网页的评论功能的 Disqus。

关于如何合理设计 API 的文章相对较多，然而有关 API 集成最佳实践的文章却很少。但是，因 API 为许多实现领域提供了关键功能，该主题的重要性正在持续提高。

托管的 API 测试服务

  • Runscope 是专门为 API 设计的一项服务，它能辅助开发人员进行自动化测试和流量监视。

  • Apiary 能为 API 的创建提供蓝图，从而使人们能更加容易地进行测试并创建出清晰的文档。

API 集成相关资源

API 集成学习清单

  • 挑选一个具有一流文档的 API。这里有一份 非常适合初学者的十种 API。

  • 查阅你所选 API 的相关文档。找到通过使用 API 能对你的应用有所改善的地方。

  • 在开始写代码前，先使用命令行中的 cURL 或者浏览器中的 Postman 对该 API 进行练习。通过练习有助于你更好地掌握 API 认证以及请求与返回所需数据的相关知识。

  • 评估是要用一个辅助库，还是用 Requests。辅助库通常更易使用，而 Requests 可使你对 HTTP 调用施加更多控制。

  • 将 API 调用移到 任务队列，从而使其不会阻塞 Web 应用的 请求-应答 流程。

API 的创建

创建和分布 API 能使你的 Web 应用可以通过机器间的通信与其它应用进行交互。

API 创建的相关框架

  • Django REST 框架 和 Tastypie 是 Django 中两个最常用的 API 框架。 当前 Django REST 框架的功能由乱轰轰的社区情绪决定。由于 Tom Christie 在 Kickstarter 上成功地募集到了资金，Django REST 框架在 3.0 版本后 还将有大的改进。

  • Flask-RESTful 是 Flask 中常用于创建 Web API 的框架。它最先由 Twilio 开源，并在一篇博客中进行了讲解，然后又移交给了 它自己的 GitHub 组织，从而使得公司外部的工程师也可以成为核心贡献者。

  • Flask API 是另一个能从 Flask Web 应用中导出 API 的通用库。

  • Sandman 是一款广泛使用的工具，它能从旧数据中自动生成 RESTful API 服务，无需编写一行代码（虽然它很容易通过代码扩展）。

  • Cornice 是 Pyramid 中的一个 REST 框架。

  • Restless 是一个轻量级的 API 框架，意在不关联任何框架。其基本理念是：只需很少的移植量，就能将相同的 API 代码用于 Django、 Flask、 Bottle、 Pyramid 或任何其它 WSGI 框架。

  • Eve 是一个用 Flask、MongoDB 和 Redis 构建的 Python REST 框架。该框架的主要作者 Nicola Iarocci 在 EuroPython 2014 作了一次精彩的演讲，并对该框架的主要功能特性进行了介绍。

  • Falcon 是一个快速的轻量级框架，非常适合用于创建 RESTful API。

  • Hug 基于 Falcon 和 Python3，它的目标是使开发 Python 驱动的 API 尽可能简单。它借助 Python3 的函数注释功能对进入和输出的 API 参数进行自动的验证和转换。

  • Pycnic 是一个以 REST 思想设计的纯 JSON-API 框架。

API 测试框架

创建、运行和维护 API 与创建、运行和维护一个 Web 应用需要花费相同的精力。API 测试框架等同于 Web 应用中的浏览器测试框架。

  • zato-apitest 能调用 HTTP API， 并提供能通过其它测试框架运行的回调挂勾。

托管的 API 测试服务

  • Runscope 是一款 API 测试 SaaS 应用，它对你自己的 API 和你的应用所依赖的外部 API 都能测试。

  • API Science 专注于尝试 API 测试，包括多步 API 调用和外部 API 监测。

  • SmartBear 中有几款 API 监测和测试工具。

API 创建相关资源

针对 Python 的 API 创建相关资源

Django REST 框架相关资源

API 创建的学习清单

  • 选择一款适合用于你的 Web 应用的 API 框架。Django 项目我推荐 Django REST 框架，Flask 项目我推荐 Flask-RESTful。

  • 首先为 API 构想出一个简单的使用案例。通常该使用案例要么是关于用户所需的机器可读格式的数据，要么是针对像 iOS 或 Android 移动应用等其它客户端的后端。

  • 通过 OAuth 或者一个令牌方案添加一个认证机制。

  • 为 API 增加使用限制，如何数据使用量会引起性能问题的话。还要加入基本的度量功能，从而能检测 API 的访问频度及其是否运行正常。

  • 提供丰富的文档及关于该 API 如何访问和使用的示例。

  • 想出其它的使用案例，并基于你从开始时的 API 使用案例中学到的知识进行扩展。

Twilio

Twilio 是一种 Web 应用编程接口 (API)，软件开发人员可以利用它来将 电话拨打, 短信发送, 视频 及 双因子认证 等通讯功能加入到他们的 Python 应用中。

Twilio logo.

为什么 Twilio 是一个好的 API 选择？

如果你不知道像会话初始化协议（SIP）等的专门通讯协议，不使用 Twilio 与标准电话网络进行交互，并发送和接收电话和短信是极其困难的。Twilio 的 API 对通讯部分进行了抽象，从而作为一个开发者，你只需在你的应用中使用你熟悉的编程语言和框架。例如，这里是如何发送短信 的例子，只用了几行 Python 代码：

  1. # 导入 Twilio 辅助库 (通过 pip install twilio 进行安装)
  2. from twilio.rest import TwilioRestClient
  3.  
  4. # 将下面代码行中的占位符替换成
  5. # 你的 Twilio 帐号 SID 及从 Twilio Console 中获取的 Auth Token
  6. client = TwilioRestClient("ACxxxxxxxxxxxxxx", "zzzzzzzzzzzzz")
  7.  
  8. # 将 "from_" 号码修改成你的 Twilio 号码并将 "to" 号码
  9. # 修改成你想发送短信的任意手机号码
  10. client.messages.create(to="+19732644152", from_="+12023358536", 
  11.                        body="Hello from Python!")

在 如果使用 Python 发送短信教程 中学习关于上面代码的更多知识。

Twilio 为 Python 开发人员编写的文档怎么样？

Twilio 是一家技术型公司，不是一个传统企业，因此它们的教程和 文档 都是由开发人员编写的。

关于 Twilio 的更多资源

免责声明

我 目前在 Twilio 工作, 是一位 开发者布道者。

部署

部署是一项涉及了为你的 web 应用打包，并且在生产环境下运行的技术。

为何部署是必要的？

你的 web 应用必须存在于除了你的台式机或者笔记本之外的设备上。生产环境是指正式版本，它包含了你当前的应用及其相关数据。

部署主题框图

Python web 应用部署由多个环节构成，并且每个环节都需要独立配置好。下面这幅图清晰地描述了部署的各个环节是如何相互联系的。点击这幅图片可以获得对应的 PDF 版本。

Full Stack Python site map.

部署托管方案

这里提供了四种部署并托管 web 应用的方案：

前三种方案是类似的。开发者首先需要准备一台或多台安装了 Linux 发行版的服务器。然后要在服务器上安装系统程序包、Web 服务器、WSGI 服务器、数据库以及 Python 运行环境。最后，将从源码生成的应用安装到配置好的环境中即可。

需要注意的是，可以通过系统特定的程序包管理系统来安装一个 Python web 应用。因为它们是比较高级的部署技术，所以我们没有包含进来。

部署有关的资源

  • 如果你需要一个渐进式的 Python web 应用部署指南， 我刚好写了 一本书 是专门针对应用部署的，它叫 全栈 Python 指南之部署， 会对你有很大的帮助。

  • 部署 Python web 应用 是著名的“和我讨论 Python” 播客系列中的一节，我在那儿讨论了在基于很传统的虚拟私有服务器、Nginx 以及“绿色独角兽（Green Unicorn）” 的栈上部署 web 应用。

  • Web 应用部署沉思录 讲解了应用部署的各个环节，包括源码控制，制定计划，持续部署以及监测结果等。

  • 部署软件 是理解如何恰当地部署软件的必读长文。

  • 持续部署实践 给出了交付与部署的定义，同时讲解了部署的流程图。

  • 在这个 Neal Ford 制作的免费视频 中， 他谈论了持续交付在工程上的实践。他解释了关于 持续集成、持续部署和持续交付间的区别。极力推荐这部视频作为部署概念的综述，同时也是对这个系列视频的介绍。

  • 在 Instagram 使用持续部署 讲述了他们在部署上的成长故事，即从单一的大结构脚本到持续部署的改进历程。在成长过程中，他们遭遇了在代码审查、测试失败、候选版本构建以及回滚这些方面的问题。这是一篇佳作，阐述了如何才能很好地部署大规模的 Python 应用。

  • Stack Overflow 上关于 他们如何部署 的指南是一篇很有深度的文章，它涵盖了从 git 分支到数据库整合的有关话题。

  • 如果你正在使用 Flask 的话，那么阅读这篇 在 Ubuntu 上部署 Flask 应用详解 是让你熟悉部署过程的良好途径。

部署学习清单

  • 如果你赶时间的话，看看这个 平台即服务（PaaS） 方案吧。你可以以免费或者较低的成本部署一款低流量的 web 应用。相比使用传统服务器的方案，你根本不用担心设置操作系统及 web 服务器这样的问题。理论上来说，使用 PasS 托管，你可以更快地在网上看到你的 web 应用在运行。

  • 传统服务器方案 是你学习完整的 Python 网络栈工作方式的最佳选择。随着你的应用规模逐渐扩大，相对使用 PaaS 方案，你会发现使用虚拟私有服务器通常会更省钱。

  • 阅读有关服务器、操作系统、 web 服务器 以及 WSGI 服务器 的内容，从而对运行一款 Python web 应用需要配置那些组件有更宽泛的了解。

服务器

服务器是运行所有软件层的物理设施，这样你的 web 应用才能够响应诸如 web 浏览器这样的客户端请求。

为何需要服务器？

你的 web 应用必须在除了你的台式机或者笔记本以外的设备上运行。 除了安排的关机计划外，理想的服务器应当保证每周 7 天，每天 24 小时能够正常访问。这台托管了针对真实用户（相对于测试用户）的 web 应用的主机就是所谓的生产服务器。 生产服务器保存了真实的数据（同样相对测试数据），并且必须安全，能够拒绝非授权的访问。

裸机服务器

裸机是指购买真实的硬件，然后通过商业级别的因特网服务供应商（ISP）或者是 连接服务器 到其它服务器上的方式连接到因特网。选择一个“商业级别”的 ISP 是有必要的，因为多数住宅因特网服务协议明文禁止在它们的网络上运行 web 服务器。如果网站的访问流量较低，那或许可以；但如果你的网站服务流量很大，那将会引起一个 ISP 的过滤警告。

采用裸机方案可以提供最多的服务器配置控制权限， 通常可以在相同价格下拥有最高的性能。但它同样也是在前期需要投入最多资金以及后期需要付出最多的服务器日常维护成本的方案。 使用裸机服务器，后期的操作成本包括服务器供电以及修复服务器损坏的部件。你需要承担人工劳动力来配置硬件以及剩余的软件栈的费用。

你可以从供应商购买组装好的服务器硬件，或者是各种组件集合回来自己组装。你也可以从 Dell 或者 HP 购买预先配置好的服务器。 这些服务器比较小巧紧凑（称为“刀片”服务器）， 但是相应地，和你使用现成的部件组装成普通的计算机相比，这种服务器更加昂贵。

虚拟化服务器

虚拟私有服务器（VPS） 就是在一个更大的裸机服务器上进行分割。 诸如 Xen 和 VMWare 这样的虚拟化软件，允许像 Linode 和 prgmr （以及许多其他的供应商） 这样的供应商把一个完整服务器的一部分能够像一个完全独立的服务器实例提供给用户。例如，一台拥有 8 核 Xeon 处理器和 16 GB 内存的服务器，可以分割成 8 片，每片都拥有等同的 1 核处理器和 2 GB 内存。

虚拟化服务器最大的缺点在于虚拟进程有一定的资源开销。此外，一些物理限制，如某个虚拟化实例对持久化存储设备繁重的 I/O 操作会给共享服务器上其它虚拟化实例带来性能上的瓶颈。应当根据你对服务请求的紧迫性以及后期维护的频率需求，如持久化存储设备的备份，来决定是否选择虚拟化服务器托管方案。

与虚拟化服务器有关的资源

基础设施即服务（IaaS）

基础设施即服务（IaaS）与虚拟化服务器有重叠的部分，因为它们通常是用一种方式来呈现资源的。虚拟化服务器和 IaaS 之间的区别在于结算周期的颗粒度。IaaS 通常使用基于服务器使用的分钟数或者小时数这样更细的粒度进行结算，而不是按月结算的方式。

IaaS 可以和虚拟化服务器结合在一起为大流量访问实现动态倍增的功能。当访问流量较低时，就可以单独使用虚拟化服务器。这种资源组合的方式减少了在更加复杂的具备动态伸缩功能的基础设施上的成本。

最常见的 IaaS 平台有 Amazon Web 服务 和 Rackspace 云服务.

IaaS 平台的缺点在于它的封闭性，如果你必须编写用于部署的自定义代码，动态调整以及想要全面地了解你的基础设施的话，那这将称为一个问题。 每个平台都有怪异的地方。例如， Amazon 标准的基础存储设备 弹性块存储 的 I/O 吞吐量在最糟糕的情况下会与你本地存储设备相差一个数量级。你的应用程序在本地进行数据库查询时可能会工作地很好，但当你把它部署后会发现它的性能并没有充分发挥出来。 Amazon 还有 高吞吐量的 EBS 实例， 但如果要使用的话，相应地也要支付更高的价格。 EBS 吞吐量只是众多怪异的特点之一，在你正式部署到一个 IaaS 平台之前，你需要了解它们。

与 IaaS 有关的资源

服务器学习清单

  • 注册一个托管服务供应商。我推荐获取一个 Linode VPS 进行初始化设置， 然后在上面部署你的 web 应用。 Digital Ocean 和 prgrmr 是其它的 VPS 候选供应商。在实现部署过程自动化后，你能在以后更换托管供应商。

  • 准备好你的第一个服务器。 它将处于就绪状态，但在等待你的指令时，会处于关机状态。

  • 转到 操作系统 部分去学习如何加载 Ubuntu 14.04 LTS 作为部署 Python web 应用的基础系统。

平台即服务（PaaS）

平台即服务（PaaS）提供了硬件基础设施和软件层，这样可以在它上面部署 web 应用。使用 PaaS 方案部署你的 web 应用，就意味着你不必了解更多关于服务器基础、操作系统、web 服务器、以及常提到的 WSGI 服务器的相关知识。

注意：如果你对使用 PaaS 方案部署 web 应用没什么兴趣的话，可以去阅读 WSGI 服务器 一节的内容。

PaaS 层定义了应用程序应该如何访问诸如计算时间、文件以及外部服务这样的资源。相对于在一台服务器或者在 IaaS 上部署应用的方案，PaaS 为使用计算资源提供了更高层次的抽象。

使用 PaaS 方案使得部署和操作变得更加简单，因为它会强迫开发者让应用程序符合 PaaS 架构。例如，在部署应用期间，Heroku 会在仓库的基目录查找 Python requirements.txt 文件，因为基目录就是那个文件的实际社区标准位置。

传统 LAMP 服务栈对比基础设施即服务（PaaS）栈

如果你走的是使用 PaaS 的路线，那你就可以跳过配置操作系统和 web 服务器的步骤，它们都由 PaaS 预先配置并提供了。 PaaS 提供的服务通常起始于 WSGI 服务层。

平台即服务（PaaS）的职责所在

虽说 PaaS 提供的服务会简化服务器、操作系统和 web 服务器的设置和维护，但开发者们仍然需要对他们的 web 栈中其他各层负责。

虽然了解一些用于支撑你的 PaaS 的操作系统知识是有好处的，例如 Heroku 使用的是 Ubuntu 10.04，但是你不必学习很多关于操作系统和服务器层面的安全知识。然而，部署到 PaaS 的 web 应用在在作为 LAMP 堆栈上的应用层依然会因为安全漏洞而易受攻击。这依旧是你的职责去保证你的 web 应用框架和应用能够及时更新并且保证它们的安全。阅读 安全部分 获取更多信息。

支持 Python 的平台即服务（PaaS）

与平台即服务（PaaS）有关的资源

平台即服务（PaaS）学习清单

  • 回顾上述列出的一些潜在的 Python 平台即服务（PaaS）选项。

  • 找一个最适合你的应用需求的 PaaS 供应商，并在那儿注册一个账户。Heroku 是推荐给初学者的 PaaS 选择，因为它提供了详细的文档，并且在网上有很多不错的教程。当然，其他的选择也是可行的，因为他们的目的就是让应用部署尽可能地简单。

  • 在 PaaS 上部署应用后，检查一下是否有任何需要的 PaaS 相关的详细配置文件，从而让你的应用以适当的方式运行。

  • 在 PaaS 上部署应用。

  • 将你的应用配置与数据库同步。

  • 为你应用的 静态内容 设置内容分发网络（CDN） ，除非你的 PaaS 供应商已经帮你完成了这个部署步骤。

  • 检查你的应用是否正常工作，并在必要时进行调整。

操作系统

操作系统运行在服务器主机或者虚拟服务器主机上，并且控制计算资源的使用。操作系统当然也包括一种安装必要程序的途径，好让你的 Python web 应用能够运行。

为何操作系统是必要的？

操作系统使得我们觉得理所当然的许多计算任务变得简单。例如，操作系统能够写入文件、进行网络通信以及同时运行多个程序。否则的话，你需要自己完成底层的实现来控制 CPU、内存、网卡以及许多其它的硬件。

如果不使用现有的诸如 Linux、Mac OS X 或者 Windows 操作系统的话，那你就不得不为你的 web 应用编写一个新的操作系统。 如此一来，你就不可能再为你的 Python web 应用增加新功能了，因为你会忙于在你的汇编代码中追踪内存泄露问题，前提是你能够走到这一步。

幸运的是，开源社区为 Python 世界提供了坚若磐石的免费操作系统 Linux 来运行我们的应用程序。

操作系统推荐

唯一推荐用于在生产环境中部署 Python web 堆栈的操作系统是 Linux。有好几种常见的 Linux 发行版可以运行在生产服务器上。Ubuntu 长期支持版（LTS）、Red Hat Linux 企业版以及 CentOS 都是可行的选择。

Mac OS X 适合用于开发。 Windows 和 Mac OS X 都不适合在生产环境下部署，除非你有必须要替代 Linux 的充足理由。

Ubuntu

Ubuntu 是由 Canonical 公司推出的 Linux 发行版。 Ubuntu 软件包基于 Debian 发行版，包括这个 aptitude 包管理器。桌面版 Ubuntu 绑定了 GNOME（直到 11.04）或者 Unity（11.10 到现在）来提供用户界面。

Ubuntu 长期支持 (LTS) 发行版是推荐用于部署的发行版本。Canonical 会为 LTS 版本提供长达 5 年的后期更新支持。Canonical 每两年就会推出新的 LTS 发行版，这就为升级提供了非常方便的途径，同时灵活地允许在必要的情况下跳过其他的 LTS 发行版进行升级。截至 2016 年 4 月， 16.04 Xenial Xerus 是最新的 Ubuntu LTS 发行版。 Xenial Xerus 包括了 Python 3.5 作为其默认的 Python 版本，与 Ubuntu 14.04 LTS 上的 2.7 版本相比，这是一个主要的更新。

Ubuntu Python 软件包

在 Linux 服务器上有好几种 Aptitude 软件包来运行 Python 栈。这些包是：

Red Hat 和 CentOS

Red Hat Linux 企业版 (RHEL) 以及 社区企业版操作系统 (CentOS) 都是同一个发行版。这两个版本的主要区别是 CentOS 是开源的操作系统，它继承自 RHEL，并且是自由授权，免费使用的。

RHEL 和 CentOS 与基于 Debian 的 Linux 发行版相比，使用了不同的包管理器和命令行界面： RPM 包管理器（RPM）以及 Yellowdog 更新，修改（YUM）。RPM 使用特殊的 .rpm 格式的文件来管理库以及应用程序的打包和安装。YUM 提供了命令行界面用于和 RPM 系统交互。

操作系统相关的资源

操作系统学习清单

  • 选择一款 Linux 操作系统，可以是基于 Debian 的发行版如 Ubuntu，或者是基于 Fedora 的发行版如 CentOS。

  • 通过一些基础的步骤加强系统的安全性。 安装一些基本的安全软件包，如 fail2ban 和 unattended-upgrades。 创建一个拥有 sudo 特权的新用户，并且禁用 root 登录。禁止仅使用密码登录选项，并且使用一个公私钥对来替换。 阅读下面列出的更多关于增强系统安全的资源。

  • 安装特定的 Python 软件包为 Python 应用准备好运行环境。根据你选择的发行版来安装所需要的软件包。

  • 仔细阅读 web 服务器，因为部署环节中的下一个就是安装一个 web 服务器。

Web 服务器

Web 服务器响应来自客户端的 超文本传输协议 （HTTP）请求，然后给客户端发送回应，包括一个状态码，通常还有诸如 HTML、XML、或 JSON 格式的响应内容。

为何 Web 服务器是必要的？

Web 服务器和 web 客户端如同阴和阳。服务器和客户端使用万维网（World Wide Web, WWW）的标准语言沟通。 正式因为有了标准语言，老旧的 Mozilla Netscape 浏览器才依旧能够和一个现代的 web 服务器沟通，例如 Aache 或者 Nginx，即使它不能像现代浏览器那样较好地渲染页面样式。

采用从客户端到服务器，再从服务器回到客户端的请求和响应模型的 Web 基础语言仍然和 1989 年由 Tim Berners-Lee在 CERN 发明的 Web 基础语言保持一致。现代浏览器和 web 服务器只是简单地扩展了该语言，从而使它符合现代标准。

Web 服务器实现

Web 服务器的思想概念可以通过不同的方式来实现。以下列出的几种 web 服务器实现都有着不同的特性、扩展和配置。

  • Apache HTTP 服务器 在 20 多年里一直是因特网中最常部署的 web 服务器。

  • Nginx 是前 100 000 个网站中第二常用的 web 服务器，并且它通常作为 Python WSGI 服务器 的反向代理。

  • Caddy 是 web 服务器中的新星，专注服务启用了 HTTPS 的 HTTP/2 协议。

客户端请求

给 web 服务器发送请求的客户端通常是浏览器，例如 IE、Firefox、Chrome，但是它也可以是：

  • 无头浏览器，通常用于测试，例如 phantomjs；
  • 命令行实用工具，比如 wget 和 cURL；
  • 文本浏览器，如 Lynx；
  • web 爬虫。

Web 服务器处理来自上述列出的客户端发出的请求。Web 服务器处理结果是 响应码，通常还有响应内容。但有些状态码，例如 204（无内容）和 403（禁止访问），就没有响应内容。

在一个简单的例子中，客户端会请求静态资源，如一幅图片或者 JavaScript 文件。请求的文件存放在 web 服务器文件系统中的一个位置，并且已被授权访问；然后，web 服务器会给客户端发送这个文件，同时发送一个值为 200 的状态码。如果客户端已经请求过这个文件了，并且文件并没有发生变动，那么 web 服务器将会传递回一个值为 304（未修改）的响应来标记客户端已经获取了最新版本的文件了。

Web server and web browser request-response cycle

Web 服务器会根据浏览器的请求给它发送文件。在第一次请求中，浏览器会访问 "www.fullstackpython.com" 地址，然后服务器作为响应会发送 HTML 格式的 index.html 文件。这个 HTML 文件包含了其他文件的引用，比如 style.css 和 script.js，然后浏览器会向服务器请求那些文件。

发送静态资源（如 CSS 和 JavaScript 文件）时会占用大量的网络带宽，这就是在可能的情况下使用内容分发网络（CDN）来为 静态资源提供服务 非常重要的原因。

Web 服务器相关的资源

  • HTTP/1.1 规格说明

  • 由 W3C 提供的完整的 HTTP 状态码 列表资料。

  • 4 个你应当一直使用的 HTTP 安全标头

  • 如果你正想通过构建一个 web 服务器来学习它的话，这里列出的 第一部分, 第二部分 和 第三部分 就是教你如何使用 Python 编写 web 服务器的优秀教程。

  • rwasa 是一款新发布的 web 服务器，它采用汇编语言编写，没有额外的依赖，并被证明比 Nginx 还要快。值得看看这个基准，来看看这款服务器是否符合你的需求；当然，得要在最快的性能和未经测试的 web 服务器之间做权衡。

Web 服务器学习清单

  • 选择一个 web 服务器。通常推荐 Nginx，当然 Apache 也是一个不错的选择。

  • 创建一个 SSL 证书。对于测试来说，使用一个自签名的证书即可；而对于产品应用，就到 Digicert 上购买一个证书。配置 web 服务器以启用 SSL。你需要 SSL，从而仅提供 HTTPS 的流量服务，这样便可以阻止用户输入未加密的安全问题发生。

  • 配置 web 服务器，从而提供静态文件，如 CSS、JavaScript 和图片的访问服务。

  • 一旦你设置了 WSGI 服务器，你就需要配置 web 服务器来传送动态内容。

WSGI 服务器

Web 服务器网关接口 (WSGI) 服务器通过实现 web 服务器一侧的 WSGI 接口来运行 Python web 应用。

为何 WSGI 是必要的？

传统的 web 服务器并不懂得或者没有任何方法来运行 Python 应用。 在 1990 年代晚期，一位名叫 Grisha Trubetskoy 的人 开发了一个叫做 mod_python 的 Apache 模块 来运行任意的 Python 代码。在 1990 年代晚期的几年以及 2000 年代早期，配置了 mod_python 模块的 Apache 服务器运行着大多数的 Python web 应用。

然而，mod_python 并非标准规范。它仅仅是一个允许在服务器上运行 Python 代码的实现而已。随着 mod_python 开发渐缓并且有不少安全漏洞被发现，社区开始意识到，需要一种运行 Python web 应用的一致性方法。

因此，Python 社区提出了将 WSGI 作为一个标准接口规范，来实现各种模块和容器。如今，WSGI 已经是用来运行 Python web 应用的公认方法了。

WSGI server invoking a WSGI application.

如上图所示，正如 PEP 3333 标准所定义的那样，WSGI 服务器只是简单地调用一个 WSGI 应用的可调用对象。

WSGI 的目的

为什么要使用 WSGI？而不仅仅是在应用中直接指定一个 web 服务器？

  • WSGI 为你提供了灵活性。应用开发者们可以使用其它组件来替换 web 堆栈中相应组件。例如，开发者可以轻易地从 Green Unicorn 切换到 uWSGI，而不用修改实现了 PEP 3333 标准定义的 WSGI 的应用或框架：

在 Python 的 web 服务器中广泛使用这种 API […] 可以将框架的选择和 web 服务器的选择分开，可以让用户自由地选择适合他们的一对框架和 web 服务器，同时也让框架开发者和服务器开发者们自由地分别聚焦在他们所擅长的特殊领域中。

  • WSGI 服务器增强了扩展性。同时提供上千次针对动态内容的请求服务是 WSGI 服务器的责任，而非框架的责任。WSGI 服务器处理来自 web 服务器的请求，并决定如何让这些请求和应用框架进程通信。责任的分离对于有效地扩展 web 流量是非常重要的。

WSGI Server - Web server - Browser

WSGI 的设计宗旨就是为运行 Python 代码提供简单的标准接口。作为一名 web 开发者，你没有必要了解更多下面列出的知识：

  • WSGI 代表什么（Web 服务器网关接口）

  • WSGI 容器是一个分离运行的进程，并且运行在一个不同于你的 web 服务器的端口上

  • 需要配置你的 web 服务器来给运行着你的 web 应用的 WSGI 容器传递请求，然后再将（HTML 形式）的响应传递回请求方

如果你正在使用一个标准的 web 框架，如 Django、Flask、或者 Bottle，亦或是任何当前存在的 Python 框架，你都不用担心框架是如何实现应用层一侧的 WSGI 标准的。类似地，如果你正在使用一个标准的 WSGI 容器，如 Green Unicorn、uWSGI、mod_wsgi 或 gevent，你可以直接让它们运行，而不用担心它们是如何实现 WSGI 标准的。

然而，当你成为一名更加富有经验的 Python web 开发者后，你应当把了解 WSGI 标准以及那些框架和容器如何实现 WSGI 的知识加入到你的学习清单中。

官方 WSGI 规格说明

1.0 版本的 WSGI 标准在 PEP 0333 中规定。到了 2010 年 9 月， WSGI 1.0 版本被 PEP 3333 定义的 WSGI 1.0.1 版本替代。如果你正在使用 Python 2.x 并且适应了 PEP 0333，那么你也会适应 PEP 3333。新的版本只是简单地为了支持 Python 3 而做的更新，并且还有如何处理 unicode 的说明。

Python 2.x WSGI 资料 and Python 3.x WSGI 资料 是内置在 Python 标准库中的 WSGI 规范实现的参考资料，从而来帮助你构建 WSGI 服务器和应用。

Web 服务器配置样例

Web 服务器配置规定了什么样的请求应该交给 WSGI 服务器处理。一旦 WSGI 服务器产生并处理完请求后，响应就会被 web 服务器传送回浏览器。

例如，这个 Nginx web 服务器配置规定了 Nginx 应当处理在 /static 目录下的静态资源（如图片、JavaScript、和 CSS 文件）访问请求，并且将所有其他的请求传递给运行在 8000 端口上的 WSGI 服务器:

  1. # 这个配置表明有一个运行在 8000 端口上的 WSGI 服务器
  2. upstream app_server_djangoapp {
  3.     server localhost:8000 fail_timeout=0;
  4. }
  5.  
  6. # Nginx 配置为运行在标准HTTP端口上，并监听请求
  7. server {
  8.   listen 80;
  9.  
  10.   # Nginx 应当为静态资源提供服务，并且永远不要把它交给 WSGI 服务器处理
  11.   location /static {
  12.     autoindex on;
  13.     alias /srv/www/assets;
  14.   }
  15.  
  16.   # 所有非针对 /static 目录的请求都会交给 WSGI
  17.   # 服务器，即上面配置的运行在 8000 端口上服务器
  18.   location / {
  19.     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  20.     proxy_set_header Host $http_host;
  21.     proxy_redirect off;
  22.  
  23.     if (!-f $request_filename) {
  24.       proxy_pass http://app_server_djangoapp;
  25.       break;
  26.     }
  27.   }
  28. }

需要注意的是，上面的Nginx 配置代码仅仅是准产品级的简化配置版本。对于真实使用了 SSL 和非 SSL 的模板，请参见 Github 上的 Underwear web server templates。

WSGI 服务器

在 WSGI 阅读文档 页面中有一个完整的 WSGI 服务器列表。 以下是社区推荐的 WSGI 服务器：

  • Green Unicorn 是一个采用了工作者模型的 WSGI 服务器，脱胎于 Ruby 的 Unicorn 项目。

  • uWSGI 正在掀起浪潮，因为它是一款高性能的 WSGI 服务器实现。

  • mod_wsgi 是一个实现了 WSGI 规格的 Apache 模块。

  • CherryPy 是一个纯粹的 Python web 服务器，并且也可以作为一个 WSGI 服务器。

WSGI 资源

WSGI 服务器学习清单

  • 理解 WSGI 是一个需要应用和服务器实现的 Python 标准规范。

  • 根据可用的文档和教程选择一个 WSGI 服务器。Green Unicorn 就是非常好的起点，因为它已经出现有段时间了。

  • 在你的服务器部署中添加 WSGI 服务器。

  • 配置 web 服务器给 WSGI 服务器传递符合适当 URL 模式的请求。

  • 测试你的 WSGI 服务器响应本地的请求，而不是来自你的设备以外的直接请求。Web 服务器应当能够向 WSGI 服务器传递请求并从那儿获得响应。

源码控制

源码控制，也叫做版本控制，用于保存软件代码文件以及针对这些文件的每次变动的详细历史。

为何源码控制是有必要的？

版本控制系统允许开发者们修改代码，而不用担心某些情况下把事情彻底搞砸。不想要的变动可以轻松地回滚到之前的代码版本。

版本控制也使得团队软件开发更加轻松。一个开发者可以通过 diff 命令按行查看代码的变更，然后将合适的代码合并到主代码分支中，这样就可以将他的代码修改和其他开发者的代码合并了。

版本控制对于所有的软件项目来说都是必要的，不管开发时间、代码库大小或者使用的编程语言。每个项目都应当立即使用一个版本控制系统，例如 Git 或者 Mercurial。

开发期间使用源码控制

在开发期间拉取代码是源码控制系统适应开发进度的一种潜在方法。

App deployment uses a server to pull from the source control system.

需要留意的是，一些开发者推荐在部署流水线中给源码打包并部署，并且永远不要让生产环境和源码控制系统直接接触。然而，对于小规模的软件开发，通常最简单的做法就是在你开始的时候直接从源码中拉取，而不用纠结如何将 Python 代码打包到系统安装包中。

源码控制项目

在过去的几十年里，人们创造了无数款源码控制系统。过去，专有的源码控制软件提供的功能都是为大型开发团队和特定项目流程定制的。然而，如今开源的源码控制系统正用在现存的最大并且最复杂的软件项目中。在今天的 Python 开发世界，没有理由去使用任何除了开源的源码版本控制系统了。两个主要的选择是：

  • Git 是免费并且开源的分布式版本控制系统。

  • Mercurial 和 Git 类似，也是一款免费开源的分布式版本控制系统。

源码控制托管服务

你可以在你的服务器上下载并运行 Git 和 Mercurial。 然而，开始使用一个托管的版本控制服务也是非常简单又便宜的。如果以后你的需求改变了，你可以通过移动你的仓库来从服务商那儿转移走。几个值得推荐的版本控制托管服务商有：

  • GitLab 同时提供了针对个人的开源软件托管服务，以及需要额外托管支持的 付费 商业服务。

  • GitHub 为 Git 提供了免费的开源仓库以及付费的私有仓库。

  • BitBucket 也有支持 Git 和 Mercurial 的免费开源项目仓库，但是还支持最多 5 个用户的私有仓库。超过 5 个用户时，如果需要私有仓库托管服务就需要支付一定的费用了。

源码控制资料

Git 相关资料

  • Pro Git 是一本开源的书籍，介绍了使用版本控制系统所有方面的知识。

  • 600 字介绍 Git 是一篇解释 Git 基础概念的清晰又简明的文章。

  • Git 黑客指南 包含了基础和高级的 Git 命令，同时解释了每一步的操作含义。

  • 像 Git 一样思考 是另外一篇介绍文章，它更多聚焦在图论和 Git 背后的概念性的思想，从而帮助读者理解在他们使用 Git 命令时究竟发生了什么。

  • Git 实践介绍 内容正如标题所描述的那样。这是一篇非常好的指南，提供了大量的代码片段来让你快速上手 Git。

  • Git 由内到外 通过一些 Git 命令样例展示了基于图的数据结构是如何产生某些行为的。在你已经掌握了 Git 的基础知识后，并且希望能深入 Git 的话，强烈推荐阅读这篇文章。

  • git 就绪 有一个非常不错的针对初级学者、中级学者和高级 Git 用例的博客合集。

  • git 流程 详细描述了针对小团队的 Git 分支模型。

  • GitHub 流程 基于“git 流程”构建，重温了一些使用 GitHub 的问题，并且给出了一些针对那些问题的解决方案。

  • Git可行的工作流程 是一篇非常有帮助并且带有图表的文章，它说明了团队如何才能创建一个对他们开发进度有帮助的 Git 流程。

  • "我们的 Git 工作流程" 是 Braintree 编写的，回顾了这家会计公司如何使用 Git 进行开发并合并源码的。

  • 借助 Git 进行代码审查 说明了当开发出现问题后，该如何审查过去的变更，从而找出问题。

源码控制学习清单

  • 选择一个版本控制系统。在这里推荐使用 Git 的原因在于网上有大量帮助新用户和高级用户的教程。

  • 学习一些基本的版本控制用法，比如提交变更、回滚到之前的文件版本以及搜索在开发过程中何时变动了代码行数。

  • 确保你的源码备份到了一个中心仓库。中心仓库是非常重要的，不仅是为了防止你本地的开发版本受损，而且也是为了开发进度。

  • 需要三步来集成源码控制到开发过程中。首先，在开发期间，从版本控制系统中拉取项目源码。第二，使用 webhooks 或者轮询仓库的方式在代码修改时启动部署。第三，当开发出现问题时，确保你能够回滚到之前的版本。

应用程序依赖

应用程序依赖是指除了你的项目代码外，其它用于创建和运行你的应用所必须的库。

为何应用程序依赖很重要？

Python web 应用程序是建立在由无数开源程序员已经完成的工作基础上的。应用程序依赖包括但不限于 web 框架，还有很多用于抓取、解析、处理、分析、可视化以及其它库。Python 的生态环境对于发现、检索和安装依赖库很有帮助，从而使得开发者可以更加轻松地创建应用。

查找库

Python 的包都被存储在为人熟知的 Python 包索引（PyPI）上。PyPI 包含了搜索的功能，它可以根据关键词条目返回根据使用频度和相关性排序的结果。

除了 PyPI，还有无数的资源中列出了常用的或者“必备”的库。当然，最终使用什么样的应用程序依赖库还是取决于你自己以及你想要构建的功能。然而，浏览一下这些库的列表还是非常有帮助的，万一你会发现一个可以用于解决问题的库呢。这样你就可以复用别人的代码而不是自己完全重写。一些最好的 Python 库合集如下：

隔离依赖

将依赖与系统级别的包分开安装的，可以防止库版本冲突的问题发生。最常见的隔离手段是采用虚拟环境 virtualenv。每个虚拟环境（virtualenv）都有一个独立的 Python 解释器以及来自 site-packages 目录的依赖库的副本。为了使用虚拟环境（virtualenv），你必须首先使用 virtualenv 命令创建并激活虚拟环境。

Virtualenv 会在隔离的环境下存储依赖库。然后，web 应用就会依靠创建的那个含有独立的 Python 解释器副本和来自 site-packages 目录拷贝的虚拟环境来运行。下面的这幅图片可以从更高层次看一个配有 virtualenv 的服务器是怎样工作的。

How the virtualenv separates dependencies on the server.

安装 Python 依赖

当一个虚拟环境（virtualenv）激活后，安装 Python 库依赖的推荐方法就是使用 pip 命令。

Pip 和 virtualenv 工作在一起，并且责任互补。Pip 负责从 PyPi 中心仓库下载并安装应用依赖。

requirements.txt

Pip 的使用惯例是，可以使用一个requirements.txt文件指定应用程序依赖。当你构建一个 web 应用时，你应当在项目的主目录下包含一个requirements.txt文件。

Python web 应用的项目依赖库应当指定相应的版本号，如下：

  1. django==1.6
  2. bpython==0.12
  3. django-braces==0.2.1
  4. django-model-utils==1.1.0
  5. logutils==0.3.3
  6. South==0.7.6
  7. requests==1.2.0
  8. stripe==1.9.1
  9. dj-database-url==0.2.1
  10. django-oauth2-provider==0.2.4
  11. djangorestframework==2.3.1

带有精确版本号或者 Git 标签的依赖是非常重要的，因为如果不那样的话，将会使用最新版本的依赖库。虽说保持更新听起来不错，但是实际上，你没法保证你的应用可以在所有的依赖都使用最新版本后还能继续工作。开发者们对升级应当慎重，并且要通过测试确保新版的依赖库没有向后兼容方面的修改。

setup.py

还有一种指定 Python 库和依赖的方式，就是使用 setup.py 。 Setup.py 是发布并安装 Python 库的标准方法。如果你正在构建一个 Python 库，如 requests 或者 underwear，你就必须要包含一个 setup.py 脚本，这样依赖管理器就可以正确地安装应用库及其依赖。在 Python 社区，仍然有一些关于 requirements.txt 和 setup.py 的区别的疑惑，所以请阅读这篇 不错的文章 来了解更多内容。

应用程序依赖相关的资源

开源应用依赖项目

  • Autoenv 是一个小工具，用激活位于你的项目主目录下的 .env 文件中存储的环境变量。virtualenv 并不会管理环境变量，虽然 virtualenvwrapper 提供了处理它们的钩子函数，但通常在开发环境中设置它们的最简单方法就是使用 shell 脚本或者 .env 文件。

  • Pipreqs 会根据导入自动在一个项目中搜索依赖。然后，它会基于运行这些依赖所必须的库生成一个 requirements.txt 文件。需要注意的是，虽然在一个遗留项目使用它很方便，但是它并不会在输出中生成那些库的具体版本号。

应用程序依赖学习清单

  • 确保你的 web 应用所需要的依赖库都包含在一个 requirement.txt 文件中，并且指定了版本号。

  • 获取最近安装的依赖库最简单的方法就是使用 pip freeze 命令。

  • 创建一个新的虚拟环境（virtualenv），然后使用命令 pip install -r requirements.txt 从你的 requirements.txt 文件中安装依赖。

  • 检查你的应用程序在新的虚拟环境（virtualenv）中能否正常工作，并且是否只是安装了来自 requirements.txt 文件中列出的依赖。

静态内容

网站中有些内容是不会改变的，所以应当直接通过 web 服务器或者内容分发网路（CDN）来为这些内容提供服务。例如 JavaScript，图片，CSS 文件等。

静态内容类型

静态内容可以是你开发过程中创建的一部分资源，例如登录页面的图片；也可以是用户生成的内容。Django 框架把这些分类为 资源 和 媒体 。

内容分发网络（CDN）

内容分发网络（CDN）是一个第三方的服务提供商，它会存储并为静态文件提供服务。例如， Amazon CloudFront，Akamai 和 Rackspace Cloud Files 都是 CDN 服务提供商。CDN 的目的是移除正在处理动态内容请求的 web 服务器的静态文件请求负载。例如，假如你有一台 512 MB 内存的虚拟私有服务器，并在上面运行着一个 nginx 服务器，它负责处理静态文件，同时又作为 Green Unicorn WSGI 服务器的前端，那么当访问流量很大时，nginx 服务器将会出现资源受限的情况。使用 CDN 可以让 nginx 服务器无需处理静态资源请求，那样的话，nginx 就可以全身心地负责给 Green Unicorn WSGI 服务器传递请求了。CDN 将会返回来自最接近请求者的数据中心的响应内容。

静态内容相关的资源

静态内容学习清单

  • 找一个内容分发网络，从而移除你的本地 web 服务器中静态内容的请求负载。我推荐使用带有 Amazon S3 CloudFont，因为它很容易设置，并且可以根据高带宽请求自动调整。

  • 更新你的 web 应用开发进度，从而将更新的静态文件上传到 CDN。

  • 将静态内容服务从 www 的子域名移动到一个静态（或者类似名称）的子域名上，这样浏览器将会在进行 www HTTP 请求时并行地加载静态内容。

任务队列

任务队列负责管理后台工作，后台工作必须要在常规的 HTTP 请求-响应周期外执行。

任务队列为何是必要的？

任务需要异步执行的原因有两点：第一，它们并非由 HTTP 请求引发；第二，它们都是需要长时间运行并且会严重削弱 HTTP 响应性能的任务。

例如，某个 web 应用可以每 10 分钟去调用 GitHub API 来收集最受关注的 100 个仓库的名称。任务队列可以触发调用 GitHub API 的代码，然后处理返回的结果并存放在一个固定的数据库中，以便后期使用。

另外一个例子就是，在 HTTP 请求-响应周期中，当数据库查询需要花费太长时间时，就可以将查询任务放在后台执行，让它每隔一个固定时间就执行一次查询，并将结果存储在数据库中。当一个 HTTP 请求到来时，如果需要那些结果，只需要进行一次查询即可轻松地获取预先计算好的结果来，而不是再次执行长时间的查询任务。这种预先计算的情景就是一种在任务队列中启用 缓存 的例子。

其他需要任务队列的情形包括：

  • 将大量独立的数据库插入操作分开在一段时间内插入完成，而不是一次全部插入；

  • 在一个固定的时间间隔后收集一次数据值，例如每 15 分钟；

  • 安排周期性的工作，例如批处理。

任务队列的项目

Celery 是 Python 任务队列事实上的标准。其它任务队列项目的诞生往往是因为 Celery 在一些简单的案例中使用显得过于复杂。我的建议是将精力花费在 Celery 的合理学习曲线上，因为花费这些时间是值得的，它可以帮助理解如何使用这个项目。

  • 分布式任务队列 Celery 是最常使用的 Python 库，它用于执行异步任务和周期性任务。

  • RQ (Redis Queue) 是一个简单的 Python 库，用于给工作排队，并在后台处理它们。RQ 由 Redis 提供支持，并且学习门槛较低。 这篇 介绍文章 包含了 RQ 的设计决策以及如何使用它的相关信息。

  • Taskmaster 是一个简单的轻量级分布式任务队列，用于处理大量的一次性执行任务。

  • Huey 是一个简单的任务队列，由 Redis 提供后台支持，但除此之外并不依赖于其它库。这个项目是曾经知名的 Invoker，但是后来作者改名为 Huey 了。

  • Huey 是一个基于 Redis 的任务队列，旨在提供一个用于执行任务的简单灵活的框架。Huey 支持任务调度、类 crontab 的重复性任务执行、结果存储和在失败时自动重试等功能。

托管消息和任务队列服务

第三方任务队列服务旨在解决当扩展部署大量分布式任务队列时产生的问题。

  • Iron.io 是一个分布式消息服务平台，它可以和很多类型的任务队列配合工作，例如 Celery。它同样也是可以和其它 IaaS 和 PaaS 环境配合工作的，例如 Amazon Web 服务 和 Heroku。

  • Amazon 简单队列服务 (SQS) 是五种 API 的集合，分别用于创建、发送、接收、修改和删除消息。

  • CloudAMQP 是在它的核心管理服务器上安装并配置了 RabbitMQ。如果你正在使用 RabbitMQ，并且不想在你自己的服务器上维护 RabbitMQ 的安装，你可以选择这个服务。

使用任务队列的开源案例

  • 看看这个开放源码的 Flask 应用 和 这个 Django 应用 例子，它们说明了如何使用并部署使用 Redis 作为代理中间件的 Celery 应用，从而使用这些框架发送消息。

  • flask-celery 例子 是一个简单的 Flask 应用，并且使用 Celery 作为任务队列，Redis 作为代理中间件。

任务队列相关资源

任务队列学习清单

  • 从你的项目中选择一个在 HTTP 请求期间执行缓慢的函数。

  • 确定你能否在一个固定的时间间隔中预先计算出结果，而不是在 HTTP 请求发生时再计算。如果可以的话，再在别处创建一个可以调用的函数，再将预先计算好的值存储到数据库中。

  • 阅读 Celery 的文档以及相关资源一节列出的链接文章来理解这个项目是如何工作的。

  • 安装一个消息代理中间件，如 RabbitMQ 或者 Redis，然后将 Celery 添加到你的项目中。配置 Celery 从而让它可以和安装的消息代理中间件一起工作。

  • 使用 Celery 周期性地调用来自步骤一中的函数。

  • 让 HTTP 请求函数使用预先计算好的值，而不是像它之前那样依赖运行缓慢的代码获得结果。

配置管理

配置管理涉及的内容包括如何将服务器从一个现有状态修改为期望的状态以及如何自动化部署应用。

配置管理工具

很多现有的工具都能以可控的方式修改服务器状态，包括 Puppet, Chef、 SaltStack、和 Ansible。其中Puppet 和 Chef 是用 Ruby 编写的，而 SaltStack 和Ansible 则是用 Python 编写的。

特别任务

诸如 Chef、Puppet、Ansible 和 SaltStack 等一些配置工具对于执行需要交互响应的特别任务并不是很有用。 Fabric 和 Invoke 则适用于交互式操作，比如使用 Django manage.py 脚本查询数据库。

配置管理工具对比

Ansible

Ansible 一款使用 Python 构建的开源配置管理工具和应用部署工具。

Ansible 相关资源

配置管理学习清单

  • 学习有关配置管理在部署自动化和“基础设施即代码”部分的内容。

  • 选择一款配置管理工具并坚持使用它。我推荐使用 Ansible，因为它是到目前为止最容易学习使用的工具。

  • 阅读你的配置管理工具的文档，并且在有必要时阅读它的源代码。

  • 为你的项目实现配置管理和部署自动化。注意这是你在整个学习清单中最耗时的步骤，但是当你每次部署项目时，你都会得到相应的汇报。

  • 将自动化部署工具添加到你现有的部署进程中。

持续集成

持续集成可以让构建、测试和部署应用自动完成。不管是由个人还是整个团队创建的软件项目，通常都会以持续集成为中心，来确保重要的步骤（如单元测试）都自动化完成了，而不是用手工处理。

持续集成为何重要？

当把持续继承（CI）作为软件项目开发过程中的一个步骤后，就可以大大减少部署时间，因为持续集成将那些需要人工干预的步骤次数最小化了。使用 CI 的小缺点有两处：第一，开发者需要花费一定的时间进行初始化设置；第二，如果一个项目被拆分成了多个部分，比如从单一架构到 微服务 架构，就会有一些不间断的维护工作。

自动化测试

使用 CI 的另外一个主要的优势是测试可以在部署过程中自动完成。 当开发者们检查源码库中的代码时，可以通过运行一个综合的测试套件 unit 和 集成测试 来防止部署受损的问题发生。在检查期间，任何由测试套件捕获的偶然出现的 bug 都会报告出来，从而阻止部署过程继续。

源码审查中的自动化测试就像是保龄球保险杠，可以防止代码质量偏离正规。整合了单元和集成测试的 CI 可以保证任何代码修改都不会破坏现有的测试，从而确保软件能够按照预期工作。

持续集成的例子

下面的这幅图片从更高的层面说明了持续集成和部署是如何工作的。

One potential way for continuous integration to work with source control and a deployment environment.

如上图所示，当新的代码合并到源码库后，就会触发一个钩子来通知持续集成服务器有新的代码需要构建（如果通知功能不可用，持续集成服务器也可以采用轮询代码库的方式）。

持续集成服务器会获取到代码然后构建并测试。如果所有的测试都通过了，持续集成服务器就开始部署过程。新的代码会被同步到正在进行部署操作的服务器上。最后，通过重启服务以及相关的部署活动后，便完成了部署过程。

持续集成服务器和部署还有其它的结构图，以上仅是一种设置相对简单的例子。

开源持续集成（CI）项目

有很多种可以根据需要进行配置的免费开源持续集成服务器。

需要注意的是，其中有很多服务器都不是用 Python 实现的，但是可以很好地与 Python 应用配合使用。Polyglot 组织（使用超过一种语言和生态系统的组织）经常为他们的项目使用单一的集成服务器，而不管这些项目是用什么语言实现的。

Jenkins CI 相关的资源

通用持续继承相关资源

日志

日志将诸如错误、警告以及事件信息保存到永久存储器中，以便后期调试。

日志为何很重要？

将中断代码运行的异常信息通过日志输出是非常重要的，它可以用来观察并修复源码问题。 此外，信息日志和调试日志也可以帮助理解应用程序是如何执行的，即使代码能够正常工作。

日志等级

日志通常分为四类：

  • 信息
  • 调试
  • 警告
  • 错误

当 web 框架在运行时通过日志输出出错信息，对于理解你的应用是如何执行的是至关重要的。

日志聚合器

当你的应用运行在多个服务器上时，拥有一款叫做“日志聚合器”的工具是非常有帮助的。你可以配置你的应用程序将系统和应用日志重定向到一个地点，在那儿有很多工具用于查看、搜索以及监控你的集群服务器上的日志事件。

使用日志聚合器工具的另外一个优势是，它们允许你自定义设置警报，这样当错误率超出某个阈值时就能获得警报通知。

开源日志聚合器

  • Sentry 起初只提供 Django 异常处理服务，但现在拥有几乎所有主要编程语言和框架的对应日志客户端。它仍然可以和 Python 驱动的 web 应用工作的很好，并且通常用于和其它监控工具连接。Raven 是用于 Sentry 的开源 Python 客户端。

  • Graylog2 提供了一个用于日志聚合的中央服务器，以及一个用于浏览和搜索日志事件的图形化工具。它拥有针对大多数主要语言的库，包括 Python。它把数据保存在 Elasticache。

  • Logstash 与 Graylog2 类似，它提供一些通过编程控制日志数据流的特性。

  • Scribe 是一个由 Facebook 实现的日志聚合器项目。它旨在运行于多个服务器上，并能够根据你剩余的集群进行扩展。它使用 Thrift 消息格式，所以可以用于任何语言。

托管的日志服务

  • Loggly 是一个第三方基于云的日志聚合器应用。它们提供了针对每种主要语言的说明，包括 Python。它还在自定义搜索中提供了邮件警报的功能。

  • Splunk 用于事件聚集，提供了第三方云以及自定义托管的方案。它擅长于搜索以及对任何基于文本数据的数据挖掘。

  • Papertrail 和 Loggly 和 Splunk 都很像，它提供了集成到 S3 的功能，用于长期存储日志。

  • Raygun 用于输出错误日志，并且当问题发生时会及时报告。

  • Scalyr 在标准日志层面上添加了用户界面，提供了日志聚集、面板操作、警报以及搜索等功能。

  • 若是你没时间设置开源版本的 Sentry 的话，这儿有一个 托管版本的 Sentry。

日志相关资源

日志学习清单

  • 阅读材料学习如何在你的 web 应用框架中集成日志输出的功能。

  • 确保错误和异常都被日志输出了。虽说这些日志可以采用 监视器 方案存储，但最好还是能拥有你自己的日志存储位置，这样便于在问题发生时调试，并且也能作为其它监视器系统的补充。

  • 为你可能需要使用的系统事件集成日志输出功能以便后期调试。例如，当函数超出某个阈值时，你可能想知道它们的返回值。

监控

监控工具用于收集、分析并展现来自 web 应用执行时的信息。每个应用程序在所有等级的 web 堆栈都会发生问题。 监控工具为开发者和运维团队提供了透明度，使他们能（及时）响应并修复问题。

监控为何是必要的？

收集并分析你的生产环境数据是非常重要的，它能帮助积极地解决 web 应用的稳定性、性能和错误等问题。

监控与日志的区别

监控和日志的目的是非常类似的，它们能够帮助诊断应用程序的问题并为调试过程提供帮助。 关于它们的区别的一种看法是，日志是在特定的事件发生时产生，而监控则在后台被动地收集数据。

例如，当一个错误发生时，代码中的异常处理函数会将特定的事件通过日志输出。与此同时，监控代理会测量代码并收集数据，这些数据不仅含有异常日志，而且还有函数的运行性能。

日志和监控的这点区别是模糊的，这也并不是区分它们的唯一一种方式。事实上，它们对于维护一个生产环境的 web 应用都是非常有帮助的。

监控层

操作系统和 web 堆栈网络级中有好几种重要的资源需要监控。

  • CPU 利用率
  • Memory 利用率
  • 永久性存储器使用占比
  • 网络带宽和延迟

应用级的监控包含多个方面。每个方面对应的时间量和资源量都是不同的，这些取决于应用程序是否有大量的读操作、大量的写操作或者是流量快速波动等特性。

  • 应用程序警告和错误（HTTP 500 错误）
  • 应用程序代码性能
  • 模板渲染时间
  • 应用程序的浏览器渲染时间
  • 数据库查询性能

开源监控项目

  • statsd 是一个 node.js 的网络后台服务，它能够监听测量数据并收集它们，用于传送到其它服务中，如 Graphite。

  • Graphite 存储基于时间序列的数据并将它们在一个 Django web 应用的图表中显示出来。

  • Bucky 测量 web 应用在终端用户浏览器中的运行性能，并把测量数据发送回服务器收集起来。

  • Sensu 是一款使用 Ruby 编写的开源监控框架，但它兼容其它任何语言编写的 web 应用。

  • Graph Explorer ，由 Vimeo 编写，它是基于 Graphite 的操作面板，含有一些新增的特性并且设计巧妙。

  • PacketBeat 用于嗅探协议包。后来 Elasticsearch 允许开发者们使用 Kibana 用户界面搜索收集的数据并呈现出 web 应用内部正在发生什么。

  • Munin 是一个基于插件的监控系统客户端，它用于将监控数据发送到用于分析并可视化的 Munin 节点。注意这个项目是用 Perl 完成的，所以收集数据的节点上必须要安装 Perl 5。

托管的监控服务

  • New Relic，用于监控应用程序和数据库，同时它含有用于收集并分析你的堆栈工具的其它数据的插件。

  • CopperEgg 是运行在服务器和基础设施上的更低层的监控服务。它在 DevOps 商店非常流行，他们正在改变生产环境并且希望能够立即获得这些修改的反馈信息。

  • Status.io 专注于 web 应用的启动时间和响应指标透明度。

  • StatusPage.io （没错，Status 和 StatusPage.io 都有）提供了简单设置状态页以监控程序启动时间的功能。

  • PagerDuty 在应用程序出现稳定性、性能或启动时间等问题发生时会给特定的人员或小组发出警告。

  • App Enlight 提供了性能、异常和错误监控功能，并且目前是专门针对 Python web 应用的。

  • Opbeat 为 Django 构建的。Opbeat 把性能指标、版本跟踪和错误日志集成到单个简易的服务中了。

监控相关资源

监控学习清单

  • 回顾“软件即服务”和以上列出的开源监控工具。第三方服务为你提供了更加简易的设置过程以及数据托管服务。开源项目则会给你更多的控制权，但是你需要拥有用于监控的额外就绪的服务器。

  • 我推荐的方案是安装试用版 New Relic 来学习它是如何与你的应用一同工作的。它能让你领略到应用程序级别的监控工具的能力。

  • 当你的应用扩展时，就去看看如何设置一款开源监控项目，例如带有 Graphite 的 StatsD。集成这两个项目将能为你收集和用于可视化的系统测量数据提供更细粒度的控制。

Web 分析

Web 分析涉及的内容有收集、处理和可视化 web 数据，从而以批判性思维看待用户是如何与 web 应用交互的。

Web 分析为何重要？

用户客户端，特别是 web 浏览器，会在用户读取以及与 web 页面交互时产生非常重要的数据。 利用相关数据可以分析出用户是如何使用网站的以及他们停驻或离开的原因。 分析的关键概念是从你的用户那儿学习，以便于你能改进 web 应用从而更好地符合他们的需求。

Web 分析概念

很容易会对大量的分析服务和收集到的无数类型的数据点感到不知所措。当你刚开始时，仅专注于少量的指标即可。 随着你的应用规模逐渐扩展，你会更加理解你的用户，然后就可以使用高级的可视化工具，如热图，和行为漏斗（action funnels），来增加额外的分析服务，从而获取更多分析用户行为的数据。

用户漏斗

如果你的应用程序是用来出售产品或服务的，你最终可以构建一个 用户漏斗（通常称为“营销漏斗”，即之前的用户变成后来的消费者）来更好地理解为何人们会购买或者不买你正在出售的东西。使用一个漏斗，你可以明显地看到访客在采取行动前，比如购买你的服务，就离开你的应用程序的急剧下降点在何处。

开源 web 分析项目

  • Piwik 是一个你可以自己托管的 web 分析平台。如果你不能使用 Google 分析器或者想要自定义你的 web 分析平台，Piwik 即是不二之选。

  • 开源 Web 分析 是另外一款自托管的平台，它通过集成了一个 JavaScript 片段代码来追踪用户与页面的交互行为。

托管的 web 分析服务

  • Google 分析器 是一款广泛用于网站流量分析的免费工具。

  • Clicky 与 Google 分析器的实时操作面板相比，提供了实时分析功能。

  • MixPanel 的分析平台侧重于移动端和营销漏斗指标。开发者可以将收集数据点的代码构建到服务器端或者客户端。MixPanel 会收集数据，然后根据依据数据产生指标并可视化数据。

  • KISSmetrics 分析会提供谁正在访问网站以及他们正在网站做什么的信息。

  • Heap 是最近成立的分析服务平台，提供了免费的入门级别服务。

  • CrazyEgg 是一款基于鼠标动作生成的热图来理解用户在使用网站时的焦点所在的工具。

针对 Python 的 web 分析资源

通用 web 分析资源

Web 分析学习清单

  • 在你的应用中添加 Googel 分析器或者 Piwik。二者都是免费的，但相对来说 Piwik 不如 Google 分析器强大，你可以自托管应用，这在许多环境中是唯一的选项。

  • 批判性地对待各种因素会使你的应用变成功。这些因素的不同之处取决于它是否是一款 企业 内部应用、一个电子商务网站或者是一款以信息为基础的应用。

  • 添加那些基于驱动你应用成功的因素而产生的 web 流量指标。你可以使用一些自定义的代码或者一个托管 web 分析器服务来添加这些指标。

  • 持续不断地评估你挑选的那些还是不是仍然能够定义你的应用成功的合适指标。如有必要，就改善使用 web 分析工具产生的指标。

Docker

Docker 是一个 开源 的基础设施管理平台，用于运行和部署软件。由于 Docker 平台总在不断地演进，所以确切的定义也会不断地变化。

Docker 为何很重要？

Docker 能够将应用及其必要的操作系统依赖打包，从而可以轻易地部署在各种环境中。 从长远来看，Docker 具有成为轻松管理运行在各种类型服务器上的容器抽象层的潜力，不管服务器是否位于 Amazon Web 服务中、Google 计算引擎上、Linode 上、Rackspace 上或者其它地方。

Docker 映像中的 Python 项目

Docker 相关资源

针对 Python 的 Docker 资源

缓存

缓存通过存储预先计算常用操的作结果并将预计算的答案发送给客户端的方式来降低服务器负载。

例如，相对于从数据库表中获取不怎么变化的数据，你可以将那些值存在在内存中。从内存中获取值要远比从数据库（它将数据存储在永久存储器中，例如一块硬盘）中获取它们快得多。当缓存的值发生变化后，系统就会让缓存失效，并重新获取更新后的值以便后期请求。

堆栈中多个层都可以创建缓存。

缓存后端

  • memcached 是一种常见的内存缓存系统。

  • Redis 是一种基于键值的内存数据存储区，它可以轻易地与诸如 django-redis-cache 之类的库一起配置用于缓存。

缓存相关资源

  • "缓存：Varnish 或者 Nginx？" 回顾了当选择反向代理 Niginx 或者 Varnish 时，需要考虑的一些诸如 SSL 和 SPDY 支持的问题。

  • 缓存难懂，给我画幅图片 有一些图说明了 web 请求缓存层是如何工作的。这篇文章还是值得一读的，尽管作者在描述他的微软代码是他写作的动力。

  • 虽然缓存在很多情况下都是非常有用的，但非常值得关注的是， 缓存也是有缺点的，所以很多开发者才没有考虑使用它。

缓存学习清单

  • 分析你的 web 应用中运行最缓慢的部分。可能情况是，有些复杂的数据库查询可以预先计算并存储在内存中。

  • 确保让你的内存数据存储区已经用于会话数据，从而缓存那些复杂数据库查询的结果。一个 任务队列 通常可以用于定期计算结果，并将它们存放到数据存储区。

  • 采用一种缓存失效机制，从而使得给用户发送的预先计算的结果保持准确。

微服务

微服务是一种应用程序架构风格，它让拥有单独功能的自包含程序通过网络和其它程序通信。典型地，这些微服务可以分开部署，因为它们通过一个定义良好的规格说明和有效的后向兼容性使得它们职责分明，从而可以避免突如其来的依赖破坏问题。

为何微服务变得如此流行？

微服务遵循长久以来软件架构模式风行的趋势。从前，CORBA 和（多数基于 XML的）面向服务的架构（SOA）成为 架构象牙塔 中的流行词。

然而，微服务更实在，因为它们通常基于 RESTful API，这对于实际的软件开发者而言，要比之前由各种企业软件公司发布的基于复杂的 XML 结构的架构容易得多！此外，成功的应用程序开始时都首先采用一种整体为先的方法，它使用一个单独的、共享的应用代码库和部署。只有在应用程序证明了它的有用性后，才会将它打破成微服务组件，从而让今后的开发和部署更轻松。这种方法叫做“整体为先”或者 “整体为先”模式。

微服务相关资源

  • Martin Fowler 写的 微服务 是最佳的深入剖析什么是微服务以及为何将它们当做一种架构模式的文章之一。

  • 为什么是微服务？ 给出了一个很好的微服务架构能够在正确的情形下提供的一些优点，例如，大幅度增加每日部署的次数。

  • 关于整体和微服务 给出了一些在软件项目早期使用微服务的建议。

  • 用 Python 开发一个 RESTful 微服务 是一个讲述了如何使用 Python 和 Flask 替换一个老旧的 Java 项目的故事。

  • 微服务：基本实践 首先回顾了一个整体应用程序是什么样的，然后深入讲解了你需要做点什么来支持潜在的微服务。例如，你真的需要将持续集成和部署设置好。这是有关该话题非常好的高级综述，很多开发者在着手将整体架构转换为微服务架构时都没有注意这个话题。

  • 使用 Nginx 实现微服务负载均衡 说明了一个 Nginx 实例如何能够使用来自 etcd 的配置值，当值发生变动时会通过 confd 更新。当安装或去除后端服务时，这个设置对于微服务负载均衡非常有用。

  • 微服务是如何改变的以及为何它们很重要 是有关该话题的高级综述，它引用了一些来自该行业开发者的话。

  • 当前的微服务状况 提供了一些一般趋势和广泛数据显示出 2016 年以来微服务的流行度在不断增加。

  • 唧唧歪歪微服务 是一个关于微服务的杀手级演讲的文稿，它打破了分布式系统重要的第一原则，包括异步通信、隔离、自动化、单一职责、独立状态以及移动性。这个带有文本的幻灯片深入说明了现实如何变得一团糟，以及如何拥抱分布式系统固有的约束。

DevOps

DevOps 是应用开发与运维的组合，它让构建应用的软件开发者们和保证基础设施运行的系统管理员们更多或者完全地连接在一起。

DevOps 为何很重要？

当 Agile 方法学广泛应用于软件开发领域时，一个新的瓶颈经常在 部署 和运维环节出现。 在每一次冲刺时产生的新的更新和修复是如此之快，以至于运维团队对部署完全不知所措，并且会减慢分发的步伐。 为了缓和这些问题，就要求应用开发者们和运维人员的步调尽量一致，从而能够从开发到产品实现自动分发。

一般的 DevOps 相关资源

  • DevOps 对比平台工程 认为 DevOps 是一种用于软件开发的特别方法，而构建平台则是一个严格的合同。我认为这是说“DevOps 是一个进程”，而“平台即代码”。运行代码要比任何有组织的进程更好。

  • DevOps: 初步了解的 Python 工具 是一个幻灯片，它说明了虽然 DevOps 是一种文化，但它可以通过诸如 Fabric, Jenkins, BuildBot 和 Git 之类的工具提供支持，合理地使用它们可以做到持续软件分发。

  • 为何我们要和 DevOps 赛跑？ 是对在 IT 组织中使用 DevOps 优点的高度总结。虽然它不是针对 Python 的，也没有深入讲解细节，但它是一个非常好的开始，可以理解为何 IT 组织将 DevOps 作为接收 Agile 开发方法学后的一个新的热门话题。

Nginx

Nginx 是 前 10 万个网站中第二常用的 web 服务器。Nginx 也可以作为 Python WSGI 服务器 或者甚至是其它 web 服务器（例如 Apache）的反向代理，用于处理请求并回传响应。

Python web application deployments rely on Nginx either as a web server or reverse proxy for WSGI servers.

Nginx 是 web 服务器 概念的一种实现。在部署 章节学习这些部分是如何组合在一起的或者查看所有主题的目录

我该使用 Nginx 还是 Apache HTTP 服务器？

让我们认清这两款“竞争”的服务器：它们都是非常棒的开源项目，并且都能够很好地为你的 web 应用部署提供服务。事实上，许多全球顶级的 web 应用在它们许多部署步骤中都同时使用这两款服务器，通过完整的 HTTP 请求—响应周期。

相对于 Apache，我个人使用 Nginx 更为频繁，因为它的配置文件感觉写起来更容易，并且有更少的可选模板。

这也有点懒惰的成分：Nginx 工作得很好，它从不会给我带来问题。所以，我坚持使用我久经沙场的 Ansible 配置管理 文件来设置 Nginx 使用 HTTPS 和 SSL/TLS 证书。

Nginx 安全防护

通过系统包管理器或者源码编译进行标准安装后的默认 Nginx 配置是一个很好的安全基础。 然而，最开始几次尝试设置密码和重定向会让人很疑惑。一个非常好的办法是阅读相关教程来确保你在被 HTTP(S) 配置折磨时避免最常见的安全错误

常见 Nginx 资源

  • 在 开源应用架构一书 中的 Nginx 章节 详细说明了为何 Nginx 以某种方式扩展构建，并且拥有很棒的部署之旅课程。

  • Nginx 内部：我们如何针对性能和扩展性进行设计 是一篇来自 Nginx 开发者的博客，说明了他们为何相信他们的架构模型要比其它构建 web 服务器的方法更加高效，更具扩展性。

  • 测试驱动 web 服务器配置 是一个非常好的故事，说明了如何反复应用配置变动，例如路由流量到 Piwik 进行web 分析、作为应用后端进行反向代理、以切当的方式终止 TLS 连接。 阅读一个写得很好的软件部署文章可以让人映像深刻，就像这篇来自政府机关的文章，虽然 UK 政府数字服务，还有美国 18F 以及美国数字服务形成了比最典型的机关更为可靠的文化。

  • 针对开发者的 Nginx 介绍 给出了最初几步来配置 Nginx 并运行它。

  • 一个更快的 Web 服务器：用 Nginx 替代 Apache 说明了在某些情况下为了提升性能可以使用 Nginx 替换 Apache。

  • Nginx 对比 Apache：我们的看法 由 Nginx 背后的开发者以第一方视角说明 web 服务器之间的差别。

  • 使用 Nginx 速度限制 说明了如何缓解使用 Nginx 速度限制进行密码暴力猜测尝试的问题。

  • Nginx 使用动态上游 是一篇非常重要的笔记，说明了如果你正在使用 Nginx 作为反向代理，如何使用变化的主机名设置你的上游 WSGI 服务器。

  • Nginx 缓存 说明了如何设置 Nginx 用于缓存 HTTP 请求，这通常可以使用 Varnish 完成，但是也可以使用 proxy_cache 和相关指令交给 Nginx 处理。

  • Nginx web 服务器教程 是最旧但也最好的教程，它说明了如何设置之前版本的 Nginx。

  • Nginx 中使用动态日志格式 说明了在 Nginx 中如何使用 HttpSetMiscModule 模块转换变量，并将输入映射到日志的可控制输出中。作者使用这种技术进行像素追踪，这种方法也可以用于其它目的，例如高级调试。

Apache HTTP 服务器

Apache HTTP 服务器 是一个广泛部署的 web 服务器，它能够组合使用一个 WSGI 模块，如 mod_wsgi 或者一个单独的 WSGI 服务器，来运行 Python web 应用。

Apache HTTP 服务器为何很重要？

Apache 仍然是最长部署的 web 服务器，并且占据统治地位 20 余年。由于它使用广泛，所以有大量的教程和开发者开发的开源模块可供任何人使用。

Apache 开发起源于 1994 年中期，当时它是 NCSA HTTP Server 项目的一个分支。 到了 1996 年早期，Apache 占据了统治地位，但是由于开发关注大大减少导致 NCSA 进度停滞，进而导致 NCSA 服务器开发停滞。

Apache HTTP 服务器web 服务器 概念的一种实现。在部署 章节学习如何将这些组合在一起，或者查看所有主题的目录

Apache HTTP 服务器相关资源

Caddy

Caddy 是一个相对较新的 HTTP 服务器，它于 2015 年创建并使用 Go 语言编写。 这个服务器的哲学和设计强调使用 HTTP/2 协议的随处可见的 HTTPS。

如何在 Python 部署中使用 Caddy？

Caddy 可以用作本地部署测试，或者作为一个 HTTP 服务器成为生成部署中的一部分，或者可以使用 代理指令 作为反向代理。

Caddy 是web 服务器 概念的一种实现。在 Learn how these pieces fit together in the 部署章节学习如何将这些部分组合在一起或者查看所有主题的目录

常见的 Caddy 资源

Green Unicorn (Gunicorn)

Green Unicorn，通过常简称“Gunicorn”，它是 Web 服务器网关接口（WSGI）服务器的一种实现，通常用于运行 Python web 应用。

Official Green Unicorn (Gunicorn) logo.

Gunicorn 为何很重更要？

Gunicorn 是众多 WSGI 服务器实现之一，但它特别重要，因为它稳定，是web 应用部署 中常用组成部分，它驱动着一些世界上最大的基于 Python 的 web 应用，例如 Instagram。

Gunicorn 实现了 PEP3333 WSGI 服务器标准规范 接口，这样它就可以运行那些实现了应用接口的 Python web 应用。例如，假设你使用了诸如 Django、Flask、或 Bottle 这样的 web 框架 编写了一个 web 应用，那么你的应用就实现了 WSGI 规范。

Gunicorn 是WSGI 服务器 概念的一种实现。在部署 章节学习如何将这些部分组合在一起，或者查看所有主题的目录。

Gunicorn 如何知道怎样运行我的 web 应用？

Gunicorn 根据在 WSGI 服务器和 WSGI 兼容的 web 应用之间的钩子知道如何运行 web 应用。

这儿有个例子，它说明了如何通过 Gunicorn 运行一个典型的 Django web 应用。 我们将以 dango_defaults 为例。在 django_defaults 项目目录中，有一个短的 wsgi.py 文件含有下面的内容：

  1. """
  2. WSGI config for django_defaults project.
  3.  
  4. It exposes the WSGI callable as a module-level variable named ``application``.
  5.  
  6. For more information on this file, see
  7. https://docs.djangoproject.com/en/1.8/howto/deployment/wsgi/
  8. """
  9.  
  10. import os
  11.  
  12. from django.core.wsgi import get_wsgi_application
  13.  
  14. os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django_defaults.settings")
  15.  
  16. application = get_wsgi_application()

wsgi.py 文件是在 Django 项目首次创建时通过 django-admin.py startproject 命令生成的。 Django 通过 wsgi.py 文件暴露了一个 application 变量，这样 WSGI 服务器就可以使用 application 作为一个钩子来运行 web 应用。 下图是对这个情况的直观展示：

Gunicorn WSGI server invoking a Django WSGI application.

什么叫做“预分叉”工作者模型？

相对一个工作者模型结构，Gunicorn 是基于预分叉工作模型的。预分叉工作模型是指主线程使工作者自旋处理请求，却不控制这些工作者如何执行请求处理任务。每个工作者都独立于控制者。

Gunicorn 相关资源

  • 在 Full Stack Python 博客 中有三篇针对框架的文章说明了如何在 Ubuntu 上配置 Gunicorn 用于开发：

Ubuntu

Ubuntu 是一个基于 Debian Linux 的操作系统发行版，通常用于 Python 开发和应用部署。

为何 Ubuntu 对 Python 很重要？

Ubuntu 是用于本地开发和服务器部署的最常用的 Linux 发行版之一。 一些 平台即服务 如 Heroku 就将 Ubuntu 作为基础操作系统，因此，作为一个 Python 开发者，你会经常使用 Ubuntu 或者类似的基于 Debian Linux 的操作系统进行工作。

Ubuntu 是操作系统 概念的一种实现。在部署 章节学习更多的知识，或者查看所有主题的目录。

Ubuntu 的 LTS 是什么意思？

每两年，Ubuntu 都会发布一个长期支持（LTS）版本，它能够接收长达五年的更新，而非 LTS 发行版则只有两年更新支持。 然而，当前的 LTS 模型中存在一些问题，那就是你 必须只使用来自主仓库的软件包，除非你打算手动解决非主仓库系统包的安全更新问题。

其它 Ubuntu 资源

Pelican

Pelican is a static site generator implemented in Python that combines Jinja templates with content written in Markdown or reStructuredText to produce websites.

Pelican's source code is available on GitHub under the GPL 3 license.

Pelican static website generator logo.

Pelican is an implementation of the static site generators concept. Learn how the parts fit together in the web development chapter or view all topics.

Why is Pelican a useful tool?

Static websites are easier to deploy than full web applications built with a web framework that rely on a persistent database backend. In addition, static sites are typically much faster to load because there are no database queries or middleware code to execute during the HTTP request-response cycle.

A web server that hosts a static website simply responds to inbound HTTP requests with the file being requests - no dynamic data is populated on the server during the response.

Pelican resources

Lektor

Lektor is a static website generator with content management system (CMS) and web framework features for creating websites.

Lektor's source code is available on GitHub under the BSD 3-clause license.

Lektor static website generator logo.

How is Lektor different from other static site generators?

Most static site generators such as Pelican are built with programmers as the primary user. Lektor tries to be more accessible to non-programmers by providing an admin panel for creating and updating site content similar to Django or Wordpress.

Lektor is an implementation of the static site generators concept. Learn how the parts fit together in the web development chapter or view all topics.

Lektor resources

Lektor is a young project and therefore has a nascent community compared with Pelican and Jekyll (the most popular Ruby-based static site generator). However, the official documentation and initial quickstarts for the project are wonderful so getting a basic site up and running is painless.

  • Introducing Lektor is the background story for what motivated Armin Ronacher to start hacking on his own static site generator project after jumping around from Django to Wordpress for hosting content. The post also includes details on the differences in the project compared to other static site generators.

  • Hello, Lektor is a wonderful getting started and overview post. The post walks through the files Lektor generates, the admin content management system and pulling data into pages from the Meetup API.

  • The official Lektor quickstart contains the first commands to use to generate a new project scaffold. There is also a getting started screencast that walks through installing and initial steps for getting set up with the project.

  • Converting to Lektor provides a quick hack for converting exported content in XML from Silvrback to a format that Lektor can use to generate a new site.

  • Lektor Static CMS, put the fun back into Content Management is a short overview as the first part in what aims to be a continuing series on how to use Lektor as a content management system.

  • In Experiences Migrating to Lektor the author gives his impression of Lektor after moving his 400+ articles over from a home-grown blogging engine. He talks a bit about how he went from deploying on GitHub Pages to surge.sh and finally over to Netlify.

MkDocs

MkDocs is a Python-based static site generator that combines Markdown content with Jinja2 templates to produce websites. MkDocs can be pronounced "McDocs" or "M-K Docs", although the core committers do not have a strong preference one way or the other on the name's pronunciation.

MkDocs' source code is available on GitHub under the BSD 2-clause license.

MkDocs static site and documentation generator logo.

What's great about MkDocs?

MkDocs uses a YAML configuration file and can optionally use themes to easy change the look-and-feel of the documentation output.

In addition to the easy configuration via a YAML file and the drop-in themes, MkDocs also has a wonderful search feature. Search is often not possible out of the box in other static site generators. With MkDocs search can easily be added without plugins or code changes to the static site generator.

MkDocs is an implementation of the static site generators concept. Learn how the parts fit together in the web development chapter or view all topics.

MkDocs resources

  • The official Getting Started with MkDocs is likely the best place to go when you are just getting set up with your first site that uses this project.

  • Building Markdown-based Sites with MkDocs provides an initial perspective on using MkDocs to build a static website along with some of the advantages and disadvantages that come with using this static site generator.

  • Mkdocs documentation is a quick tutorial to get MkDocs installed and modify the initial mkdocs.yml file.

  • MkDocs making strides is a post from one of the project's core commiters on some changes that greatly improved the project such as site regeneration during development when a file is modified, search, the command-line client and packageable theming.

测试

测试是一种基于特定的输入来判断软件能否正确地运行的方法，并且可以找到需要修复的软件漏洞。

测试缘何重要？

因为软件是使用代码库来衡量大小的， 所以，无论是个人还是大型团队，都不可能及时跟进软件所有的变动以及变动之间的交互。事实表明， 一旦软件变得比最初简单原型更加复杂后，自动化测试就是唯一一种可以用来构建健壮的软件的方法了。很多重要软件项目开发失败的原因都可追朔为测试不充分或者完全没有测试。

对于我们而言，软件只有通过测试后方可知道它能否正常工作。虽然测试工作可以由用户手动点击按钮或者输入来完成，但是更佳的办法是编写专门的测试工具，从而让软件测试能够自动化完成。

测试有很多种形式，我们应当将它们一同使用起来。当程序中的某个函数被隔离测试时，叫做 单元测试。而当同时测试程序中的多个函数时，就叫所谓的 集成测试。 用户界面测试 确保了用户能与软件进行正确交互 。大型程序还需要更多形式的测试，比如 负载测试，数据库测试以及 浏览器测试 (针对 web 应用)。

在 Python 中测试

Python 软件开发文化就是非常重视软件测试。 相对于静态类型语言而言，Python 是一种动态类型的语言。 为了确保软件的正确性，测试在 Python 开发中占据了至关重要的地位。

测试相关的资源

  • 最小的可行测试套件 使用一个 Flask 例子来为我们展示如何进行单元测试和集成测试。

  • 好的测试，坏的测试 讲解了 “好的” 测试和无用的测试之间的差别。 这篇文章打破了一些关于常见测试主题的误区，例如代码覆盖率、断言和mocking测试。

  • Python 测试 是一个（我想你猜到了）专注于 Python 编程语言测试的网站。

  • 测试驱动开发案例 由 Michael DeHaan 发表，它为我们解释了为何自动化测试是构建大规模软件的唯一方法。

  • 谷歌有一个测试博客 ，他们提供了关于大规模软件测试的各方面信息。

  • 依然对单元、功能和集成测试的区别感到糊涂吗？ 来看看关于这个问题的回答吧： Stack Overflow 上排名最前的回答 。

  • Django 中使用 pytest 展示了如何在 Django 项目设置一个基本的pytest 测试，并且说明了为何作者更喜欢 pytest，而不是标准的 unittest 测试。

单元测试

单元测试是一种用于判断从更大的代码库分离出来的单个函数正确性的方法。 单元测试的思想是，如果一个应用程序中所有分离出来的原子单元都能按照预期工作， 那么当把它们集成到一起后，能按照预期工作将会更加容易。

单元测试缘何重要？

单元测试只是一种 测试 形式，它会和其他测试方法配合在一起，用于查找正在开发的软件中存在的 bug。当把多个函数和类放在一块后，通常来说，如果多个 bug 同时出现的话，将很难定位问题的根源。单元测试能帮助消除尽可能多的独立 bug，从而当一个程序作为一个整体运行时，其各组成部分将越有可能正确运行。那么，一旦出现了问题， 它们通常都可以被追溯为：是因不同的组成部分未能正确衔接而产生的非预期结果。

单元测试工具

Python 中有许多用于创建测试的工具。有一些测试工具，例如 pytest，是用来替代内置的 unittest 框架的。 其他的一些测试工具，如 nose 等都是用于简化测试的创建工作的扩展程序。需要注意的是，通过编写测试案例来对代码中的多个部分同时进行测试，这些工具也有许多可被用于 集成测试。

  • unittest 是专门用于测试 Python 代码的内置标准库工具。

  • pytest 是一个完整的测试工具，它强调后向兼容性及最少化样板代码量。

  • nose 是一个 unittest 的扩展工具，它使得编写和执行测试案列更加简单。

  • Hypothesis 是一个单元测试生成工具，它会帮助开发人员创建用于检查代码块边边界条件的测试案例。 学习使用 Hypothesis 的最好途径就是去认真阅读这篇写得非常好的 快速入门。

  • testify 是一个旨在替代 unittest+nose 组合的测试框架。 遗憾的是，testify 背后的开发团队正在转向 pytest，所以并不推荐你在新的项目中使用 testify。

单元测试相关的资源

集成测试

集成测试通过一次性地检测程序的两个或者更多个单元，包括单元之间的接口交互，来判断它们能否按照预期工作。当代码库中不同的单元间相互调用并且互传数据时，利用这种类型的 测试 就可以发现接口中存在的漏洞。

集成测试和单元之间测试有何区别？

与 单元测试 用于在单独的函数中寻找 bug 不同，集成测试则是将系统作为一个整体进行测试的。 这两种类型的测试应当结合起来使用，而不能只用一种测试而忽略了另一种。当系统进行了全面地单元测试后，集成测试将变得更加容易，因为很多存在于独立组件中的 bug 都已被找到被修复了。

随着代码库逐渐变大，单元测试和集成测试能使开发人员能快速地识别出代码中的破坏性变更。很多时候，这些破坏性的变更都是意料之外的，并且会一起存在到开发后期才会被发现，甚至还可能是最终的用户在使用软件时才发现这个问题。自动化的单元和集成测试将会大大提高在开发期间尽快找出 bug 的可能性，从而使它们能立即被处理掉。

集成测试相关的资源

代码度量

代码度量信息由静态代码分析工具生成，它能用于判定代码的复杂性及非标准做法。

代码度量缘何重要？

利用代码度量，开发人员可以找到那些可能需要返工的问题代码区域。此外，一些度量概念，例如“技术债务”，有助于开发者就系统为何会出错等问题与非技术人员进行沟通。

开源的代码度量项目

  • Radon 这个工具用于获取代码行数、圈复杂度、Halstead 指标以及可维护性指数这些原始的代码度量值。

  • Pylint 包含了用于检查代码是否符合 PEP8 风格、设计、例外等检查工具，以及许多其它的源码分析工具。

  • PyFlakes 通过解析源文件来查找其中的错误，并为它们生成相应的报告。

  • Pyntch 是一个试图检测运行时错误的静态代码分析器。但它并不检查代码的风格。

托管的代码度量服务

  • Coveralls 可以通过测试套件获得代码覆盖率，并且结合其它的度量值来帮助开发人员改善代码质量。

代码度量相关的资源

调试

开发人员经常会陷入这样的处境，就是他们编写的代码并没有按照预期工作。当出现那样的情况时，开发者就要通过检查、运行并且深入分析代码，来断定应用中的哪个状态值与代码正确运行时的预期值不匹配。

调试缘何重要？

每个中型或大型应用中都会有 bug 存在。每个开发者都应该学会如何调试代码，以便能在时间和预算允许的情况下尽可以写出能正确运行的程序。

调试相关的资源

  • 调试你的 Python 代码 演示了如何利用 pdb 来查找 Python 代码块中的漏洞。

  • pdb — 交互式调试器 是“本周 Python 模块（The Python Module of the Week）”博客上的一篇精选文章，它详细介绍了如何高效地使用 pdb 调试器。

  • Python 调试工具 列出了一些调试工具，例如 pdb 及其衍生工具如 ipdb、 pudb 和 pdb++，同时文章也讲解了如何利用它们来查找漏洞。

  • 在 Python 中调试 阐述了 pdb 可以用来做什么以及如何使用它。

What "full stack" means

The terms "full stack" and "Full Stack Python" are ambiguous but I am using a specific definition here on this site. These term can be defined for a web stack either to mean

  • Every layer, from the machine code up to the browser, are written in Python

  • Python code interacts with code written in other languages such as C and JavaScript to provide a complete web stack

I named this site specifically for the second definition: Python is one programming language among many that are used to build your application stack.

Some folks took the title of the site to mean Python runs everything from the web browser on down. That's simply not practical or possible. While Python is an amazing programming language, there are many tasks it does not do well.

Python is just one language among many that allows our computers to execute software and communicate with each other.

For beginners, learning the syntax and libraries in Python necessary to build a web application or web API is a major undertaking. Even intermediate and advanced Python software developers need to constantly program and learn to keep up with our ever evolving ecosystem. I created Full Stack Python to be just one of many resources that help Python developers build and maintain their programming skills.

Bots

Bots are software programs that combine requests, which are typically provided as text, with contextual data, such as geolocation and payment information, to appropriately handle the request and respond. Bots are often also called "chatbots", "assistants" or "agents."

Open source Slack bot examples

  • Limbo is an awesome Slack chatbot that provides a base for Python code that otherwise would require boilerplate to handle the Slack API events firehose.

  • python-rtmbot is the bot framework for building Slack bots with the Real Time Messaging (RTM) API over WebSockets.

Python-specific Bots resources

Additional Bots resources

  • Slack bot token leakage exposing business critical information is a detailed look at a search on GitHub for Slack tokens that are used mostly for bots but must be kept secret. Otherwise those tokens expose the entire Slack team's messaging to outside parties.

  • The Economist wrote a general piece on why bots look like they'll gain adoption in various market segments. The piece doesn't have much technical depth but it's a good overview of how some businesses are looking at the opportunity.

  • Bots won't replace apps is a fantastic piece by WeChat's product manager on how text-based bots alone typically do not provide a good user experience. Instead, chat apps with automated responses, user data and basic web browser functionality are what has allowed bot concepts to bloom in Asian markets. There's a lot of good information in this post to unpack.

Change Log

This is a running list of the major changes to Full Stack Python since its inception in December 2012. Another way to view the modifications is through the source repository's commit log on GitHub.

2016

September

  • Updated the Slack bot tutorial with a new bit on how to solve a common issue when the bot does not seem to be responding to @ mentions due to a missing colon in the input.
  • New resources on the static site generators page focusing on deploying a static site.

August

July

June

May

April

  • Updated the Nginx page with a security section.
  • Added new Channels section to Django page.
  • Clean up on some existing pages to remove broken links.
  • Added new subnav under the logo and title so readers can more easily access the table of contents.

March

  • Added new DevOps resources.
  • Removed unfortunate dead links from the Django page.
  • Made a huge improvement to the layout of the full-sized table of contents that appears on pages that are above 768px wide (the collapsed table of contents for mobile stays the same).
  • Began work on an Apache HTTP Server page.
  • Added some new awesome deployment resources.

February

January

  • Added initial page for SQLite that will be built out over the next few weeks.
  • Added a couple of new resources to the ORMs page.
  • More resources on the PostgreSQL page and now grouped into Python-specific and general sections.
  • Major update to relational databases page with new sections and resources.
  • Updated the Jinja2 page with new sections and resources. Also added a new tutorial link on the Bottle page.
  • Added new summaries and links to the Docker and Best Python Resources pages.
  • Expanding the PostgreSQL page with more detail and additional resources.
  • Split the relational databases page sections on PostgreSQL and MySQL out into their own pages so there is more room to write about the three topics without making the databases page a behemoth.
  • Updated the template engines page with a new image to show the spectrum between arbitrary code execution and no logic in templates.
  • Added a new Jinja2 page specifically for that template engine.
  • Happy New Year! Finished 2015 with over 455,000 users according to Google Analytics. Thanks everyone! Can't wait to write more pages and improve the existing ones in 2016.

2015

December

November

October

September

August

July

June

  • New API Creation and Django resources added.
  • Added new Peewee resources on the ORMs page.
  • Nice little update to the ORMs page with a diagram showing that different ORMs can work with varying web frameworks and backends.
  • Added a new section just for Nginx resources and Removed broken links on the web servers page.
  • Added a new page on Python object-relational mappers, which helped condense that information on a single page and lighten the loads on the Django and relational databases pages.
  • Added new page with a little advice on learning programming.
  • Proofread and tweaked the web frameworks page.
  • Added a new section entitled "Do I have to use a web framework?" to the web frameworks page.
  • Reviewed and updated the introduction with slight modifications.
  • Added new Docker resources.
  • Made some changes to what is contained in the Markdown files versus the HTML Jinja2 templates. Behind the scenes work that needed to be done to move the project forward.
  • Work continues on the Full Stack Python Guide to Deployments book.

May

  • Got a whole lot of work done on my upcoming Full Stack Python Guide to Deployments book. Very close to releasing it (looking at mid-June).
  • Added new Django resources, especially around migrations in Django 1.7+.
  • Worked on making Why Use Python? page specific to that topic now that the Enterprise Python page contains enterprise-y info.
  • New page on the super broad topic of Data with Python. Eventually it'll link to all sorts of data topics such as analysis, visualization and processing.
  • New page on Enterprise Python. A bit op-ed-ish perhaps, but I think it captures some of the spirit of the open source ecosystem with regards to Python for enterprise software development.
  • Added additional Django resources, specifically related to testing.

April

  • Added more NoSQL resources, especially ones involving Redis.
  • New Pyramid resource where the primary author is interviewed about the web framework.
  • New Vim resources.
  • Updated the Django page with new resources. The page is getting unwieldy at its current size so I'll likely pare it down with better categorizes sometime soon.
  • Added new resources on the Flask page.

March

  • Added new source control resources.
  • Major site performance improvements. I removed font awesome and replaced icons with SVG elements that mimic the font awesome icons.
  • Pushed the 1000th commit to Full Stack Python! Screenshot of 1000th commit to Full Stack Python.
  • Major update to Vim page to add screenshots, a better example .vimrc configuration and many more resources.
  • Updated the web analytics page with a new Python-specific section for walkthroughs that are specific to building or using analytics with Python applications.
  • Adding a slew of new Django resources.
  • Working on including Crossbar.io and Autobahn to the websockets page.
  • Added the Muffin framework to the other web frameworks page.
  • Added new Emacs page based on pull request #49 base information. Thank you!
  • Added a new page on best Python videos that breaks out all the videos I had scattered around the site and puts the best ones in a single place.
  • Beefing up the Django resources and will soon break them further down into subcategories so they are easier to find by topic.

February

  • Cleaned up the sidebar and email subscribe messaging.
  • Added new monitoring, websockets and continuous integration resources.
  • New Django resources.
  • Updated the Vim page with a Vimrc configuration file explanation along with Vimrc resources.
  • Added a generators page that's mostly a stub that I will be building out to explain this core language feature.
  • Updated table of contents with new layout that'll allow me to expand on core Python language topics.
  • Updated several out of date resources and added a new logging resource.
  • New Pyramid resources. I definitely need to flesh that page out further.
  • Added a Vim page and resources for learning Vim as a Python code editor.
  • Reorganized content pages to make for better logical groupings as I add new content.
  • Major improvements to Websockets page after suggestions from issue #47 on GitHub repository.

January

  • Rewrote the Mailchimp sign up form for the email list so it doesn't have the external JQuery libraries as dependencies. Site should be even faster now.
  • Stripped a significant portion of unused Bootstrap boilerplate from the CSS file and minified it. The resulting CSS file is over 100KB less (about 25KB down from 130KB) so the site should load faster now.
  • Major update to WebSockets page with new diagrams and better explanations for why server push is useful.
  • New task queue resources.
  • Major update with the beginning of a page on Docker, split out static file handling resources on the Django page and a new section on Python programming language popularity on the "Why Use Python?" page.
  • Working on a Why Use Python? page with my own assessment of the strengths and weaknesses of Python along with links to resources where other folks discuss their own experiences.
  • Continuing to add WebSockets resources, especially Python-specific ones.
  • Added a new separate page for the Morepath framework.
  • Updated the future directions page for 2015.
  • Added new WebSockets resources.
  • Added WebSockets page and some initial resources.

2014

December

  • Added new security resources and splitting HTTPS resources into their own section.
  • Split out Djangular resources into a separate section.
  • New NoSQL Python client resources.
  • Added new API resources for integration and creation.

November

  • Added a nice new continuous integration diagram.
  • More Django and database resources.
  • Revising development environments page and adding new resources.
  • Adding my new Flask blog post on choose your own adventure presentations along with the open source repository.
  • More resources under Best Python Resources.
  • Removing broken links from Best Python Resources and Django pages.
  • New monitoring and development environments resources.

October

  • Added the first new page in awhile! All about development environments.
  • Always adding new links to the best resources. More resources for deployments, web analytics and Flask.
  • More API creation and consumption resources.
  • Merged a bunch of pull requests that cleaned up spelling and grammar errors. Thank you contributors!
  • Adding new Django 1.7-specific resources section on the Django page.
  • New web frameworks, Bottle and Flask resources.

September

  • New resources for Flask, Django and task queues sections.
  • A few new resources for NoSQL data stores.

August

  • New interesting link for web framework code complexity visualizations.
  • Merged pull request that fixed some issues on WSGI page.
  • Updated table of contents so it's easier to read and broken down by sections.
  • Added new Web Design page to cleanly separate CSS from design topics and resources.
  • New resources for code metrics and NoSQL databases.
  • Added another Flask open source example app.
  • Added new Code Metrics page.
  • Updated CI page with more services and open source projects.
  • Added Continuous Integration page.
  • Splitting out deployment from automation so I can add chapters on continuous integration, configuration management (which will be moved from the existing deployment chapter) and related topics.
  • Small tweaks to NoSQL, introduction and a few other pages.
  • Moved topics map from introduction page to deployment page.

July

  • Merged pull request for Django page and updated Django page with project template section.
  • New Django example project resources.
  • Rewrote parts of source control and CSS pages for clarity.
  • Merged typo fixes PR #32.
  • Added my Full Stack Python video from the EuroPython 2014 conference.
  • Updated map with further details.
  • Added a map to the front page. May move that elsewhere later though based on feedback.
  • Merged a pull request for new REST frameworks.
  • Lots of new Django, Flask and task queue resources.
  • Added two new Python libraries lists to the Best Python Resources page.
  • Thanks Hacker News for doubling my traffic so far in 2014! 65k uniques and counting…

June

  • Added more monitoring and logging resources.
  • New resources for Flask and NoSQL projects.
  • Updated NoSQL data store page with specific open source projects.
  • Added diagram to source control page.
  • Split version control resources from Git resources. Added new version control resources.
  • Updated logging page with better explanations and content ordering.
  • Added learning checklists for all sections. The remaining sections that now also have checklists are logging, web analytics and web application security.

May

  • Added link to my O'Reilly Programming blog post on demand for full stack developer capabilities.
  • Updated APIs page with basic information on webhooks.
  • Added learning checklists for source control, application dependencies, configuration management, NoSQL data stores, APIs, API integration, API creation, static content and caching sections.
  • Moving learning checklists to the bottom of the pages since they are specific advice for steps to take after reading a section.
  • Added a stub section for APIs.
  • Cleaned up and polished the task queues and web analytics pages.
  • Added learning checklist to operating systems, web servers, task queues, monitoring pages and WSGI servers.
  • Adding more logging resources.
  • Continuing to add learning checklists to sections such as servers.
  • Moving navigation options into meta tags on markdown pages.

April

  • Adding the concept of "learning checklists" to web frameworks, Django, CSS and JavaScript pages to give readers some guidance for how to learn each topic. Will expand these checklists out into other pages over the next couple of weeks.
  • Added an email sign up form to determine how many people are interested in a full book since I've had a lot of requests in person to write one.
  • Added new resources to the other web frameworks section.
  • Updated the way choices to go from one page to another are generated. It's now done off metadata instead of duplicated HTML content.
  • Huge site update to reorganize the way content is presented and navigated. Kinda has that "choose your own adventure" thing going for it, doesn't it?

  • New logo! This one's way more Python software stack, way less boring folder-thingy. Here's how the old one looked in comparison: Old Full Stack Python logo

  • Added a future direction section to explain current priorities for further developments on the site.

  • More resources for web frameworks and configuration management sections.

  • Added small JavaScript section. Updating witih basic resources.
  • Updated application dependencies with new links to Python library collections.
  • Merged a couple of awesome pull requests that fixed typos and added additional Bottle resources.

March

  • Updated logging page with new resources.
  • Added new CSS page.
  • New intermediate learning links on the best resources page.
  • Updated task queues page with better explanations and many more curated resources.
  • Added why is this piece necessary for databases, WSGI servers, web frameworks and application dependencies.
  • Updating best resources page with newsletters and a few additional beyond the basics resources.
  • Adding 'why is this necessary' sections to servers, operating systems, and web servers pages.
  • Extracting best Python resources from the introduction into a separate page.
  • Cleaned up links on the first ten chapters and added new resources for web frameworks.
  • Updated application dependencies section with new resources and initial content description.
  • Updated the change log (how meta!) to have a cleaner layout.

February

  • Added Bottle as a web framework next to Django and Flask.
  • Added new Django resources.
  • New sitemap.xml.
  • Rewriting all sections to fix first draft typos and grammar mistakes as well as add new content.
  • Added task queues section due to reader feedback.
  • Rewrote intro section.
  • Merged several pull requests (see closed GitHub repo pull requests).
  • New resources for platform-as-a-service section.
  • Added new sections specified by the community as missing.
  • Reorganized ordering of content.
  • Broke out subsections for Django and Flask.
  • Added signficant content to the WSGI section.
  • Converted from RST to Markdown (some of the downstream tools I want to use work better with Markdown than RST).
  • Reorganized content into rough outline of "final" chapters.

January

  • Added configuration management, application dependencies, and source control sections.
  • Updated about section.
  • Fully responsive web design.

2013

December

  • Changed CDN section to static content section.
  • Transitioned diagrams from Paper app drawings to Balsamiq mockups exported to PNG files.
  • Added Python database connectors to database section.

November

  • Modified color scheme.
  • Updated caching and introduction section.
  • Added NoSQL data stores section.

October

  • Created separate monitoring section.

August

  • Added more resources for web servers and other categories.

June

  • Updated styling.
  • Switching around several sections.

January

  • Fleshed out web server, OS, and server sections, particularly IaaS and PaaS topics.
  • Added initial "hand drawn" diagram placeholders for better diagrams later.

2012

December

  • Initial incomplete release on fullstackpython.com, created introduction, CDN, web frameworks, and database sections with stubs for other areas.

Future Directions

Full Stack Python has completely blown away my expectations for what I could accomplish with a side project. I really appreciate all the in-person feedback, emails and pull requests I've received from the community. Keep them coming!

For 2016 I'm building out the scope of the site beyond web development into core Python concepts, data analysis and visualization and (hopefully) some hardware hacking such as with the Raspberry Pi and Arduino Yun.

A huge update was released in the form of the The Full Stack Python Guide to Deployments, a step-by-step tutorial book for learning how to deploy Python web applications.

Note that these plans can change based on pull requests from the community. I work to integrate PRs within a day or two so please submit one when you see a fix or improvement that needs to be made!

About the Author

This website was coded and written by Matt Makai (@mattmakai), currently a Developer Evangelist at Twilio in San Francisco, California.

Other projects by Matt include The Full Stack Python Guide to Deployments book, Coding Across America, Underwear and Choose Your Own Adventure Presentations. You can reach him by email at matthew.makai@gmail.com, Twitter @mattmakai or on GitHub at mattmakai.

Read my thoughts on the "full stack" trend in a post I wrote for O'Reilly Radar.

Typos, inaccurate statements or general areas for improvement can be handled through an issue ticket or pull request on GitHub.

SQLAlchemy

SQLAlchemy (source code) is a well-regarded database toolkit and object-relational mapper (ORM) implementation written in Python. SQLAlchemy provides a generalized interface for creating and executing database-agnostic code without needing to write SQL statements.

SQLAlchemy logo.

Why is SQLAlchemy a good ORM choice?

SQLAlchemy isn't just an ORM- it also provides SQLAlchemy Core for performing database work that is abstracted from the implementation differences between PostgreSQL, SQLite, etc. In some ways, the ORM is a bonus to Core that automates commonly-required create, read, update and delete operations.

SQLAlchemy can be used with or without the ORM features. Any given project can choose to just use SQLAlchemy Core or both Core and the ORM. The following diagram shows a few example configurations with various application software stacks and backend databases. Any of these configurations can be a valid option depending on what type of application you are coding.

Example SQLAlchemy configurations with different web frameworks.

A benefit many developers enjoy with SQLAlchemy is that it allows them to write Python code in their project to map from the database schema to the applications' Python objects. No SQL is required to create, maintain and query the database. The mapping allows SQLAlchemy to handle the underlying database so developers can work with their Python objects instead of writing bridge code to get data in and out of relational tables.

SQLAlchemy is an implementation of the object-relational mapping (ORM) concept. Learn more in the data chapter or view all topics.

How does SQLAlchemy code compare to raw SQL?

Below is an example of a SQLAlchemy model definition from the open source compare-python-web-frameworks project that uses SQLAlchemy with Flask and Flask-SQLAlchemy.

  1. class Contact(db.Model):
  2.     __tablename__ = 'contacts'
  3.     id = db.Column(db.Integer, primary_key=True)
  4.     first_name = db.Column(db.String(100))
  5.     last_name = db.Column(db.String(100))
  6.     phone_number = db.Column(db.String(32))
  7.  
  8.     def __repr__(self):
  9.         return '<Contact {0} {1}: {2}>'.format(self.first_name,
  10.                                                self.last_name,
  11.                                                self.phone_number)

SQLAlchemy handles the table creation that otherwise we would have had to write a create table statement like this one to do the work:

  1. CREATE TABLE CONTACTS(
  2.    ID INT PRIMARY KEY        NOT NULL,
  3.    FIRST_NAME     CHAR(100)  NOT NULL,
  4.    LAST_NAME      CHAR(100)  NOT NULL,
  5.    PHONE_NUMBER   CHAR(32)   NOT NULL,
  6. );

By using SQLAlchemy in our Python code, all records can be obtained with a line like contacts = Contact.query.all() instead of a plain SQL such as SELECT * FROM contacts. That may not look like much of a difference in syntax but writing the queries in Python is often faster and easier for many Python developers once multiple tables and specific filtering on fields for queries have to be written. In addition, SQLAlchemy abstracts away idiosyncratic differences between database implementations in SQLite, MySQL and PostgreSQL.

Using SQLAlchemy with Web Frameworks

There is no reason why you cannot use the SQLAlchemy library in any application that requires a database backend. However, if you are building a web app with Flask, Bottle or another web framework then take a look at the following extensions. They provide some glue code along with helper functions that can reduce the boilerplate code needed to connect your application's code with the SQLAlchemy library.

SQLAlchemy resources

The best way to get comfortable with SQLAlchemy is to dig in and write a database-driven application. The following resources can be helpful if you are having trouble getting started or are starting to run into some edge cases.

  • There is an entire chapter in the Architecture of Open Source Applications book on SQLAlchemy. The content is detailed and well worth reading to understand what is executing under the covers.

  • The SQLAlchemy cheatsheet has many examples for querying, generating database metadata and many other common (and not so common) operations when working with Core and the ORM.

  • 10 reasons to love SQLAlchemy is a bit of a non-critical lovefest for the code library. However, the post makes some good points about the quality of SQLAlchemy's documentation and what a pleasure it can be to use it in a Python project.

  • Large web apps in Python: A good architecture goes into issues that expanding codebases face, such as where to put business logic and how to automate database testing. Each of the topics in the article are discussed in the context of a recent project the author worked on that heavily relied on SQLAlchemy.

  • SQLAlchemy and Django explains how one development team uses the Django ORM for most of their standard queries but relies on SQLAlchemy for really advanced queries.

  • SQLAlchemy and data access in Python is a podcast interview with the creator of SQLAlchemy that covers the project's history and how it has evolved over the past decade.

  • Most Flask developers use SQLAlchemy as an ORM to relational databases. If you're unfamiliar with SQLAlchemy questions will often come up such as what's the difference between flush and commit? that are important to understand as you build out your app.

  • SQLAlchemy in batches shows the code that a popular iOS application runs in background batch scripts which uses SQLAlchemy to generate playlists. They provide some context and advice for using SQLAlchemy in batch scripts.

SQLAlchemy compared to other ORMs

SQLAlchemy is one of many Python object-relational mapper (ORM) implementations. Several open source projects and articles are listed here to make it a bit easier to understand the differences between these implementations.

  • SQLAlchemy vs Other ORMs provides a detailed comparison of SQLAlchemy against alternatives.

  • If you're interested in the differences between SQLAlchemy and the Django ORM I recommend reading SQLAlchemy and You by Armin Ronacher.

  • This GitHub project named PythonORMSleepy implements the same Flask application with several different ORMs: SQLAlchemy, Peewee, MongoEngine, stdnet and PonyORM. Looking through the code is helpful for understanding the varying approaches each library takes to accomplish a similar objective.

  • Quora has several answers to the question of which is better and why: Django ORM or SQLALchemy based on various developers' experiences.

Peewee

Peewee (source code) is a object-relational mapper (ORM) implementation for bridging data stored in relational database tables with Python objects.

Peewee logo.

What makes Peewee a useful ORM?

Peewee can be an easier library to wrap your head around than SQLAlchemy and other ORMs. It is designed to be easier to hack on and understand, similar to how Bottle is a smaller, one-file web framework compared to the comprehensive Django framework. If you are just getting started with web development, it may be worth using Peewee for your database mapping and operations, especially if you use a microframework such as Flask or Bottle.

Peewee can be used with pretty much any web framework (although using it with Django would currently be complicated due to its tight built-in ORM coupling) or without a web framework. In the latter case Peewee is good for pulling data out of a relational database in a script or Jupyter notebook.

Any of the common relational database backends such as PostgreSQL, MySQL or SQLite are supported, although a database driver is still required. The chart below shows a few example configurations that could use Peewee as an ORM.

Example SQLAlchemy configurations with different web frameworks.

Peewee is an implementation of the object-relational mapping (ORM) concept. Learn more in the data chapter or view all topics.

How does Peewee compare to other Python ORMs?

The analogy used by the core Peewee author is that Peewee is to SQLAlchemy as SQLite is to PostgreSQL. An ORM does not have to work for every exhaustive use case in order to be useful.

Peewee resources

Peewee is a much newer library than several other Python ORMs. For example, Peewee's first public commit was in 2010, compared to 2005 for SQLAlchemy. The project is still over five years old though and matured substantially in development during that time. However, there are typically less resources and examples available to demonstrate how to use Peewee in your projects than some other ORMs that have been around for a longer period of time.

Many of the best resources come from the project's author, Charles Leifer, on his blog and on the official site. There are also hundreds of questions answered on the Stack Overflow peewee tag, so as usual that can be a rich source of examples for your Peewee-powered Python applications.

Full Stack Python

如果你要查找一个特定主题请查看本 目录。

重要的更新内容会通过 Twitter 账号@fullstackpython发布。

需要更加详细的教程吗？请看 《The Full Stack Python Guide to Deployments》。

Full Stack Python 是一本开源图书，它用朴实的语言阐释概念并提供相关主题的最有用资源。

This site is based on Matt Makai's project Full Stack Python, thanks for his excellent work!

此网站由 @haiiiiiyun 和 开源爱好者们 共同维护。 若发现错误或想贡献，请访问： Github fullstackpython.cn 项目