Tornado 4.5.2官方文档：异步网络与Web开发全面指南

4星 · 超过85%的资源需积分: 9 32 浏览量更新于2024-07-19 收藏 830KB PDF 举报

Tornado文档是关于Tornado，一个强大的Python Web框架和异步网络库，最初由FriendFeed开发。该版本为4.5.2，可通过PyPI下载，同时提供了详细的安装指南、用户手册、API参考以及各种实用功能的介绍。Tornado的核心优势在于其非阻塞网络I/O技术，这使得它能够支持数千个并发连接，特别适合于长轮询、WebSocket应用和其他需要保持与每个用户持久连接的应用场景。第1章“Quicklinks”列出了文档的快速链接，包括当前版本（4.5.2）的下载地址、GitHub源代码仓库、官方邮件列表（讨论和公告）、Stack Overflow上的问题解答以及项目的维基页面，为开发者提供了全方位的支持资源。第2章“Hello, world”可能是教程的开始，引导读者如何用Tornado创建一个简单的“Hello, world”示例，以便熟悉框架的基本结构和工作原理。第3章“Installation”详细介绍了Tornado的安装过程，包括依赖管理、环境配置和不同平台的部署指南，确保开发者可以顺利地在自己的项目中集成Tornado。第4章“Documentation”是文档的主体部分，分为多个小节： - **用户指南**：这部分可能涵盖了Tornado的基本概念、设计理念、如何构建Web应用、路由系统、模板引擎、请求和响应处理等内容。 - **HTTP servers and clients**：涉及Tornado的HTTP服务器和客户端实现，可能包括如何创建自定义HTTP服务器、处理HTTP请求、以及如何使用HTTP客户端进行网络请求等。 - **Asynchronous networking**：这部分深入探讨了Tornado的异步编程模型，如异步I/O、协程和事件循环，有助于开发者理解和利用Tornado的并发能力。 - **Coroutines and concurrency**：专门讲解了如何使用协程进行并发编程，以及Tornado提供的工具和机制来管理和协调多任务。 - **Integration with other services**：介绍如何与其他服务集成，如数据库、缓存、身份验证和授权等，帮助开发者构建更完整的应用程序。 - **Utilities**：列出了一系列实用工具，如定时任务、文件上传处理、URL路径匹配器等，提高开发效率。 - **Frequently Asked Questions**：汇总了一些常见问题及解答，帮助开发者解决遇到的问题。 - **Release notes**：包含了每个版本的更改记录，供开发者查阅新特性、修复的bug或兼容性更新。第5章“Discussion and support”提供了进一步的讨论平台，包括社区论坛、开发者问答等，鼓励开发者分享经验、寻求帮助或参与开源项目的发展。最后，“Python Module Index”为开发者提供了Tornado模块的索引，便于查找特定功能或类的文档。 Tornado 4.5.2文档是开发者深入了解和使用Tornado框架的权威指南，无论你是初学者还是经验丰富的开发者，都能从中找到所需的信息来构建高效、可扩展的网络应用。

Tornado Documentation, Release 4.5.2

# instead.

return response.body

Python 3.5: async and await

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

tines”). Starting in Tornado 4.3, you can use them in place of most yield-based coroutines (see the following

paragraphs for limitations). Simply use async def foo() in place of a function deﬁnition with the @gen.

coroutine decorator, and await in place of yield. The rest of this document still uses the yield style for

compatibility with older versions of Python, but async and await will run faster when they are available:

async def fetch_coroutine(url):

http_client = AsyncHTTPClient()

response = await http_client.fetch(url)

return response.body

The await keyword is less versatile than the yield keyword. For example, in a yield-based coroutine you can

yield a list of Futures, while in a native coroutine you must wrap the list in tornado.gen.multi. This also

eliminates the integration with concurrent.futures. You can use tornado.gen.convert_yielded to

convert anything that would work with yield into a form that will work with await:

async def f():

executor = concurrent.futures.ThreadPoolExecutor()

await tornado.gen.convert_yielded(executor.submit(g))

While native coroutines are not visibly tied to a particular framework (i.e. they do not use a decorator like tornado.

gen.coroutine or asyncio.coroutine), not all coroutines are compatible with each other. There is a corou-

tine runner which is selected by the ﬁrst coroutine to be called, and then shared by all coroutines which are called

directly with await. The Tornado coroutine runner is designed to be versatile and accept awaitable objects from any

framework; other coroutine runners may be more limited (for example, the asyncio coroutine runner does not accept

coroutines from other frameworks). For this reason, it is recommended to use the Tornado coroutine runner for any

application which combines multiple frameworks. To call a coroutine using the Tornado runner from within a corou-

tine that is already using the asyncio runner, use the tornado.platform.asyncio.to_asyncio_future

adapter.

How it works

A function containing yield is a generator. All generators are asynchronous; when called they return a generator

object instead of running to completion. The @gen.coroutine decorator communicates with the generator via the

yield expressions, and with the coroutine’s caller by returning a Future.

Here is a simpliﬁed version of the coroutine decorator’s inner loop:

# Simplified inner loop of tornado.gen.Runner

def run(self):

# send(x) makes the current yield return x.

# It returns when the next yield is reached

future = self.gen.send(self.next)

def callback(f):

self.next = f.result()

self.run()

future.add_done_callback(callback)

12 Chapter 4. Documentation

Tornado Documentation, Release 4.5.2

The decorator receives a Future from the generator, waits (without blocking) for that Future to complete, then

“unwraps” the Future and sends the result back into the generator as the result of the yield expression. Most

asynchronous code never touches the Future class directly except to immediately pass the Future returned by an

asynchronous function to a yield expression.

How to call a coroutine

Coroutines do not raise exceptions in the normal way: any exception they raise will be trapped in the Future until it

is yielded. This means it is important to call coroutines in the right way, or you may have errors that go unnoticed:

@gen.coroutine

def divide(x, y):

return x / y

def bad_call():

# This should raise a ZeroDivisionError, but it won't because

# the coroutine is called incorrectly.

divide(1, 0)

In nearly all cases, any function that calls a coroutine must be a coroutine itself, and use the yield keyword in the

call. When you are overriding a method deﬁned in a superclass, consult the documentation to see if coroutines are

allowed (the documentation should say that the method “may be a coroutine” or “may return a Future”):

@gen.coroutine

def good_call():

# yield will unwrap the Future returned by divide() and raise

# the exception.

yield divide(1, 0)

Sometimes you may want to “ﬁre and forget” a coroutine without waiting for its result. In this case it is recommended

to use IOLoop.spawn_callback, which makes the IOLoop responsible for the call. If it fails, the IOLoop will

log a stack trace:

# The IOLoop will catch the exception and print a stack trace in

# the logs. Note that this doesn't look like a normal call, since

# we pass the function object to be called by the IOLoop.

IOLoop.current().spawn_callback(divide, 1, 0)

Using IOLoop.spawn_callback in this way is recommended for functions using @gen.coroutine, but it is

required for functions using async def (otherwise the coroutine runner will not start).

Finally, at the top level of a program, if the IOLoop is not yet running, you can start the IOLoop, run the coroutine,

and then stop the IOLoop with the IOLoop.run_sync method. This is often used to start the main function of a

batch-oriented program:

# run_sync() doesn't take arguments, so we must wrap the

# call in a lambda.

IOLoop.current().run_sync(lambda: divide(1, 0))

Coroutine patterns

Interaction with callbacks

To interact with asynchronous code that uses callbacks instead of Future, wrap the call in a Task. This will add the

callback argument for you and return a Future which you can yield:

4.1. User’s guide 13

剩余221页未读，继续阅读

lgo9528

粉丝: 1
资源: 5

Tornado 4.5.2官方文档：异步网络与Web开发全面指南

tornado官方翻译文档

tornado中文文档

PyPI 官网下载 | tornado-1.0.tar.gz

tornado 中文官方文档

关于python tornado 框架的说明文档

tornado 更新

tornado编译器下载

No matching distribution found for tornado

jupter和tornado对应版本

win10 tornado2.2替换

最新资源