Tornado框架教程：异步网络编程与Python Web开发

需积分: 9 26 浏览量更新于2024-07-09 收藏 955KB PDF 举报

Tornado文档是关于Python Web框架和异步网络库的官方教程，适用于6.2.dev1版本。该框架由FriendFeed开发，核心优势在于其非阻塞网络I/O技术，能够支持成千上万的并发连接，特别适合长轮询、WebSocket等需要持久用户连接的应用场景。以下是该文档的主要章节概览： 1. 快速链接：提供了当前版本（6.2.dev1）下载地址（PyPI）以及相关的最新发布说明。此外，还有GitHub源码仓库链接和邮件列表，用于讨论和公告。 2. **Hello, World**：章节介绍了Tornado的基本概念和安装方法，通过一个简单的示例展示如何创建和运行一个基础的Web服务器。 3. **线程与WSGI**：这部分讲解了Tornado如何在多线程环境中工作，并介绍了它与WSGI（Web Server Gateway Interface）规范的集成，使得框架可以与其他WSGI兼容的服务器无缝配合。 4. **异步IO集成**：这一部分深入探讨了Tornado如何利用Python的asyncio库进行异步编程，包括事件循环、协程和异步网络处理，帮助开发者充分利用并发性能。 5. **安装**：详细介绍了如何在Python环境中安装和配置Tornado，包括依赖管理和不同操作系统下的安装步骤。 6. **文档**： - 用户指南：提供全面的Tornado使用教程，涵盖了从基础设置到高级特性的各个层面。 - Web框架：解释了如何构建和管理Web应用，包括路由、模板引擎、请求处理和响应生成等内容。 - HTTP服务器和客户端：探讨了Tornado内置的HTTP服务器功能，以及如何创建自定义HTTP客户端。 - 异步网络编程：深入剖析Tornado如何利用异步I/O处理网络通信，如长连接和短连接策略。 - 协程和并发：讲解了Tornado如何利用协程实现高效的并发处理，包括Gevent和Twisted等其他库的对比。 - 与其他服务集成：展示了Tornado如何与数据库、缓存和其他服务集成，以构建完整的应用生态。 - 实用工具：介绍了一些实用的辅助工具和模块，如模板引擎、静态文件处理和中间件管理。 - 常见问题解答：汇总了一些用户在使用过程中可能会遇到的问题及其解决方案。 7. **讨论和支持**：文档最后提供了讨论区域，用户可以在其中寻求帮助、分享经验，以及报告问题或提出新功能的建议。总结来说，Tornado官方教程覆盖了从入门到进阶的方方面面，无论是初次接触Tornado的开发者，还是希望深入了解其异步架构和高效网络处理的专家，都能从中找到所需的信息。阅读此文档可以帮助开发者充分利用Tornado的特性，构建高性能的网络应用。

Tornado Documentation, Release 6.2.dev1

12 Chapter 5. Installation

CHAPTER

SIX

DOCUMENTATION

This documentation is also available in PDF and Epub formats.

6.1 User’s guide

6.1.1 Introduction

Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed. By

using non-blocking network I/O, Tornado can scale to tens of thousands of open connections, making it ideal for long

polling, WebSockets, and other applications that require a long-lived connection to each user.

Tornado can be roughly divided into four major components:

• A web framework (including RequestHandler which is subclassed to create web applications, and various

supporting classes).

• Client- and server-side implementions of HTTP (HTTPServer and AsyncHTTPClient).

• An asynchronous networking library including the classes IOLoop and IOStream, which serve as the building

blocks for the HTTP components and can also be used to implement other protocols.

• A coroutine library (tornado.gen) which allows asynchronous code to be written in a more straightforward

way than chaining callbacks. This is similar to the native coroutine feature introduced in Python 3.5 (async

def). Native coroutines are recommended in place of the tornado.gen module when available.

The Tornado web framework and HTTP server together offer a full-stack alternative to WSGI. While it is possible to

use the Tornado HTTP server as a container for other WSGI frameworks (WSGIContainer), this combination has

limitations and to take full advantage of Tornado you will need to use Tornado’s web framework and HTTP server

together.

6.1.2 Asynchronous and non-Blocking I/O

Real-time web features require a long-lived mostly-idle connection per user. In a traditional synchronous web server,

this implies devoting one thread to each user, which can be very expensive.

To minimize the cost of concurrent connections, Tornado uses a single-threaded event loop. This means that all

application code should aim to be asynchronous and non-blocking because only one operation can be active at a time.

The terms asynchronous and non-blocking are closely related and are often used interchangeably, but they are not

quite the same thing.

Tornado Documentation, Release 6.2.dev1

Blocking

A function blocks when it waits for something to happen before returning. A function may block for many reasons:

network I/O, disk I/O, mutexes, etc. In fact, every function blocks, at least a little bit, while it is running and using

the CPU (for an extreme example that demonstrates why CPU blocking must be taken as seriously as other kinds of

blocking, consider password hashing functions like bcrypt, which by design use hundreds of milliseconds of CPU

time, far more than a typical network or disk access).

A function can be blocking in some respects and non-blocking in others. In the context of Tornado we generally talk

about blocking in the context of network I/O, although all kinds of blocking are to be minimized.

Asynchronous

An asynchronous function returns before it is ﬁnished, and generally causes some work to happen in the background

before triggering some future action in the application (as opposed to normal synchronous functions, which do every-

thing they are going to do before returning). There are many styles of asynchronous interfaces:

• Callback argument

• Return a placeholder (Future, Promise, Deferred)

• Deliver to a queue

• Callback registry (e.g. POSIX signals)

Regardless of which type of interface is used, asynchronous functions by deﬁnition interact differently with their

callers; there is no free way to make a synchronous function asynchronous in a way that is transparent to its callers

(systems like gevent use lightweight threads to offer performance comparable to asynchronous systems, but they do

not actually make things asynchronous).

Asynchronous operations in Tornado generally return placeholder objects (Futures), with the exception of some

low-level components like the IOLoop that use callbacks. Futures are usually transformed into their result with

the await or yield keywords.

Examples

Here is a sample synchronous function:

from tornado.httpclient import HTTPClient

def synchronous_fetch(url):

http_client = HTTPClient()

response = http_client.fetch(url)

return response.body

And here is the same function rewritten asynchronously as a native coroutine:

from tornado.httpclient import AsyncHTTPClient

async def asynchronous_fetch(url):

http_client = AsyncHTTPClient()

response = await http_client.fetch(url)

return response.body

Or for compatibility with older versions of Python, using the tornado.gen module:

14 Chapter 6. Documentation

Tornado Documentation, Release 6.2.dev1

Native vs decorated coroutines

Python 3.5 introduced the async and await keywords (functions using these keywords are also called “native

coroutines”). For compatibility with older versions of Python, you can use “decorated” or “yield-based” coroutines

using the tornado.gen.coroutine decorator.

Native coroutines are the recommended form whenever possible. Only use decorated coroutines when compatibility

with older versions of Python is required. Examples in the Tornado documentation will generally use the native form.

Translation between the two forms is generally straightforward:

# Decorated: # Native:

# Normal function declaration

# with decorator # "async def" keywords

@gen.coroutine

def a(): async def a():

# "yield" all async funcs # "await" all async funcs

b = yield c() b = await c()

# "return" and "yield"

# cannot be mixed in

# Python 2, so raise a

# special exception. # Return normally

raise gen.Return(b) return b

Other differences between the two forms of coroutine are outlined below.

• Native coroutines:

– are generally faster.

– can use async for and async with statements which make some patterns much simpler.

– do not run at all unless you await or yield them. Decorated coroutines can start running “in the

background” as soon as they are called. Note that for both kinds of coroutines it is important to use

await or yield so that any exceptions have somewhere to go.

• Decorated coroutines:

– have additional integration with the concurrent.futures package, allowing the result of

executor.submit to be yielded directly. For native coroutines, use IOLoop.run_in_executor

instead.

– support some shorthand for waiting on multiple objects by yielding a list or dict. Use tornado.gen.

multi to do this in native coroutines.

– can support integration with other packages including Twisted via a registry of conversion functions. To

access this functionality in native coroutines, use tornado.gen.convert_yielded.

– always return a Future object. Native coroutines return an awaitable object that is not a Future. In

Tornado the two are mostly interchangeable.

16 Chapter 6. Documentation

剩余253页未读，继续阅读

极客-杀生丸

粉丝: 1873
资源: 191

Tornado框架教程：异步网络编程与Python Web开发

tornado实战之一

[Introduction.to.Tornado(2012.3)].Michael.Dory.文字版.pdf

Tornado之TrueFFS编程者指南.pdf

嵌入式实时操作系统VxWorks及其开发环境Tornado.pdf

tornado docs.pdf

Tornado教程.pdf

嵌入式实时操作系统VxWorks及其开发环境Tornado all.pdf

实时嵌入式操作系统vxworks及其开发环境Tornado浅析.pdf

tornado_tutorial.pdf

Tornado使用指南.pdf

最新资源