标签归档:twisted

干净,轻巧的替代Python的替代品吗?[关闭]

问题:干净,轻巧的替代Python的替代品吗?[关闭]

一个(很久以前),我写了一个网络蜘蛛,对它进行了多线程处理,以使并发请求能够同时发生。那是我的Python青年时代,在我了解GIL及其为多线程代码造成的相关麻烦之前(IE,大多数情况下,这些东西最终都被序列化了!)…

我想对这段代码进行重做,以使其更健壮并性能更好。基本上有两种方法可以执行此操作:我可以使用2.6+中的新多处理模块,也可以使用某种基于反应堆/事件的模型。我宁愿稍后再做,因为它更加简单且不易出错。

因此,问题与哪种框架最适合我的需求有关。以下是到目前为止我所知道的选项列表:

  • Twisted:Python反应器框架的祖父:看起来很复杂,但是有点a肿。陡峭的学习曲线,可完成一项小任务。
  • Eventlet:从在家伙lindenlab。基于Greenlet的框架,适用于此类任务。我看了一下代码,但看起来不是很漂亮:不符合pep8,散布着印刷品(为什么人们要在框架中这样做!?),API似乎有点不一致。
  • PyEv:不成熟,尽管它基于libevent,所以现在似乎还没有人在使用它,因此它有一个可靠的后端。
  • asyncore:来自stdlib:über低级,似乎涉及很多工作,只是为了使事情起步。
  • 龙卷风:尽管这是一种面向服务器的产品,旨在为动态网站提供服务器,但它确实具有异步HTTP客户端和简单的ioloop。看起来可以完成工作,但不能达到预期目的。[编辑:不幸的是,它不能在Windows上运行,这对我来说算是它了-这是我支持这个la脚平台的要求]

我有什么想念的吗?当然,必须有一个适合简化异步网络库的最佳选择的库!

[编辑:非常感谢intgr指向此页面。如果滚动到底部,您将看到一个非常不错的项目列表,旨在以一种或多种方式解决此任务。实际上,自Twisted诞生以来,事情确实已经发生了变化:人们现在似乎更喜欢基于协同例程的解决方案,而不是传统的面向反应器/回调的解决方案。这种方法的好处是更直接的代码:我过去确实发现过,特别是在使用boost.asio时。在C ++中,基于回调的代码可能导致难以遵循的设计,并且对于未经训练的人来说是相对模糊的。使用协同例程可使您编写看起来至少同步一些的代码。我想现在我的任务是找出我喜欢的众多库中的哪一个,并尝试一下!很高兴我现在问…]

[编辑:可能是关注或偶然发现此问题或在某种意义上关心此主题的任何人所感兴趣的:我发现了该工作可用工具的当前状态非常出色的文章]

A (long) while ago I wrote a web-spider that I multithreaded to enable concurrent requests to occur at the same time. That was in my Python youth, in the days before I knew about the GIL and the associated woes it creates for multithreaded code (IE, most of the time stuff just ends up serialized!)…

I’d like to rework this code to make it more robust and perform better. There are basically two ways I could do this: I could use the new multiprocessing module in 2.6+ or I could go for a reactor / event-based model of some sort. I would rather do the later since it’s far simpler and less error-prone.

So the question relates to what framework would be best suited to my needs. The following is a list of the options I know about so far:

  • Twisted: The granddaddy of Python reactor frameworks: seems complex and a bit bloated however. Steep learning curve for a small task.
  • Eventlet: From the guys at lindenlab. Greenlet based framework that’s geared towards these kinds of tasks. I had a look at the code though and it’s not too pretty: non-pep8 compliant, scattered with prints (why do people do this in a framework!?), API seems a little inconsistent.
  • PyEv: Immature, doesn’t seem to be anyone using it right now though it is based on libevent so it’s got a solid backend.
  • asyncore: From the stdlib: über low-level, seems like a lot of legwork involved just to get something off the ground.
  • tornado: Though this is a server oriented product designed to server dynamic websites it does feature an async HTTP client and a simple ioloop. Looks like it could get the job done but not what it was intended for. [edit: doesn’t run on Windows unfortunately, which counts it out for me – its a requirement for me to support this lame platform]

Is there anything I have missed at all? Surely there must be a library out there that fits the sweet-spot of a simplified async networking library!

[edit: big thanks to intgr for his pointer to this page. If you scroll to the bottom you will see there is a really nice list of projects that aim to tackle this task in one way or another. It seems actually that things have indeed moved on since the inception of Twisted: people now seem to favour a co-routine based solution rather than a traditional reactor / callback oriented one. The benefits of this approach are clearer more direct code: I’ve certainly found in the past, especially when working with boost.asio in C++ that callback based code can lead to designs that can be hard-to-follow and are relatively obscure to the untrained eye. Using co-routines allows you to write code that looks a little more synchronous at least. I guess now my task is to work out which one of these many libraries I like the look of and give it a go! Glad I asked now…]

[edit: perhaps of interest to anyone who followed or stumbled on this this question or cares about this topic in any sense: I found a really great writeup of the current state of the available tools for this job]


回答 0

我喜欢并发 Python模块,该模块依赖轻量级线程的Stackless Python微线程或Greenlets。所有阻塞网络I / O通过一个libevent循环透明地实现异步,因此它的效率应与真正的异步服务器差不多。

我想它在这种方式上类似于Eventlet。

缺点是其API与Python的sockets/ threading模块完全不同;您需要重写您的应用程序的一部分(或编写一个兼容性填充层)

编辑:似乎也有cogen,这是相似的,但是使用Python 2.5的增强型生成器为其协程而不是Greenlets。这使得它比并发和其他替代方法更可移植。网络I / O直接通过epoll / kqueue / iocp完成。

I liked the concurrence Python module which relies on either Stackless Python microthreads or Greenlets for light-weight threading. All blocking network I/O is transparently made asynchronous through a single libevent loop, so it should be nearly as efficient as an real asynchronous server.

I suppose it’s similar to Eventlet in this way.

The downside is that its API is quite different from Python’s sockets/threading modules; you need to rewrite a fair bit of your application (or write a compatibility shim layer)

Edit: It seems that there’s also cogen, which is similar, but uses Python 2.5’s enhanced generators for its coroutines, instead of Greenlets. This makes it more portable than concurrence and other alternatives. Network I/O is done directly with epoll/kqueue/iocp.


回答 1

扭曲是复杂的,您是正确的。扭曲肿。

如果您在此处查看:http : //twistedmatrix.com/trac/browser/trunk/twisted,您将找到一个组织良好,全面且经过良好测试的,包含许多 Internet协议的套件,以及编写的辅助代码并部署非常复杂的网络应用程序。我不会将膨胀与全面性混为一谈。

众所周知,Twisted文档乍一看并不是最用户友好的,并且我相信这会避免不幸的人们。但是如果您花时间的话,Twisted太棒了(IMHO)。我做到了,事实证明这是值得的,我建议其他人也可以尝试。

Twisted is complex, you’re right about that. Twisted is not bloated.

If you take a look here: http://twistedmatrix.com/trac/browser/trunk/twisted you’ll find an organized, comprehensive, and very well tested suite of many protocols of the internet, as well as helper code to write and deploy very sophisticated network applications. I wouldn’t confuse bloat with comprehensiveness.

It’s well known that the Twisted documentation isn’t the most user-friendly from first glance, and I believe this turns away an unfortunate number of people. But Twisted is amazing (IMHO) if you put in the time. I did and it proved to be worth it, and I’d recommend to others to try the same.


回答 2

gevent清除eventlet

在API方面,它遵循与标准库(尤其是线程和多处理模块)相同的约定(在这里有意义)。因此,您可以使用诸如QueueEvent之类的熟悉的东西。

它仅支持libevent从1.0开始更新: libev)作为反应堆实现,但充分利用了它的优点,它具有基于libevent-http的快速WSGI服务器,并通过libevent-dns解决DNS查询,而不是像其他大多数库一样使用线程池做。(更新:由于使用1.0 c-ares进行异步DNS查询;线程池也是一种选择。)

与eventlet一样,它通过使用greenlets使得不需要回调和Deferreds 。

查看示例:并发下载多个URL长时间轮询webchat

gevent is eventlet cleaned up.

API-wise it follows the same conventions as the standard library (in particular, threading and multiprocessing modules) where it makes sense. So you have familiar things like Queue and Event to work with.

It only supports libevent (update: libev since 1.0) as reactor implementation but takes full advantage of it, featuring a fast WSGI server based on libevent-http and resolving DNS queries through libevent-dns as opposed to using a thread pool like most other libraries do. (update: since 1.0 c-ares is used to make async DNS queries; threadpool is also an option.)

Like eventlet, it makes the callbacks and Deferreds unnecessary by using greenlets.

Check out the examples: concurrent download of multiple urls, long polling webchat.


回答 3

NicholasPiël在他的博客上对这些框架进行了非常有趣的比较:值得一读!

A really interesting comparison of such frameworks was compiled by Nicholas Piël on his blog: it’s well worth a read!


回答 4

这些解决方案都无法避免GIL阻止CPU并行的事实-它们只是获得线程已经具有的IO并行的更好方法。如果您认为可以做得更好的IO,则可以采取以下任何一种方法,但是如果瓶颈是处理结果,那么除了多处理模块之外,这里没有任何帮助。

None of these solutions will avoid that fact that the GIL prevents CPU parallelism – they are just better ways of getting IO parallelism that you already have with threads. If you think you can do better IO, by all means pursue one of these, but if your bottleneck is in processing the results nothing here will help except for the multiprocessing module.


回答 5

我不会说Twisted blo肿,但很难缠住你的头。我一直避免真正地学会学习,因为我一直希望对“小任务”更轻松一些。

但是,既然我已经使用了它,我不得不说所有的电池都非常好。

我使用过的所有其他异步库最终都没有看起来那么成熟。Twisted的事件循环很稳定。

我不太确定如何解决陡峭的Twisted学习曲线。如果有人将其分叉并清理一些东西,例如删除所有向后兼容的废纸and和无效项目,那可能会有所帮助。但这就是成熟软件的本质。

I wouldn’t go as far as to call Twisted bloated, but it is difficult to wrap your head around. I avoided really settling in an learn for quite a while as I always wanted something a little easier for ‘small tasks’.

However, now that I have worked with it some more I have to say having all the batteries included is VERY nice.

All the other async libraries I’ve worked with end being way less mature than they even appear. Twisted’s event loop is solid.

I’m not quite sure how to solve the steep Twisted learning curve. It might help if someone would fork it and clean a few things up, like removing all the backwards compatability cruft and the dead projects. But that’s the nature of mature software I guess.


回答 6

尚未提及Kamaelia。它的并发模型基于将组件连接在一起,并在收件箱和发件箱之间传递消息。是一个简短的概述。

Kamaelia hasn’t been mentioned yet. Its concurrency model is based on wiring together components with message passing between inboxes and outboxes. Here‘s a brief overview.


回答 7

我开始在某些事情上使用扭曲。它的美丽几乎是因为它“ blo肿”。那里有几乎所有主要协议的连接器。您可以拥有一个jabber机器人,该机器人将接收命令并将其发布到irc服务器,将其通过电子邮件发送给某人,运行命令,从NNTP服务器读取以及监视网页中的更改。坏消息是它可以完成所有这些操作,并且会使诸如OP所述的简单任务变得过于复杂。python的优点是您只包含需要的内容。因此,尽管下载量可能是20mb,但您可能只包含2mb的库(仍然很多)。我最大的困惑是,尽管它们包含示例,但您只能依靠基本的tcp服务器。

虽然不是python解决方案,但最近我已经看到node.js获得了更多的吸引力。实际上,我已经考虑过将其用于较小的项目,但是当我听到javascript时我只是畏缩:)

I’ve started to use twisted for some things. The beauty of it almost is because it’s “bloated.” There are connectors for just about any of the main protocols out there. You can have a jabber bot that will take commands and post to an irc server, email them to someone, run a command, read from an NNTP server, and monitor a web page for changes. The bad news is it can do all of that and can make things overly complex for simple tasks like the OP explained. The advantage of python though is you only include what you need. So while the download may be 20mb, you may only include 2mb of libraries (which is still a lot). My biggest complaint with twisted is although they include examples, anything beyond a basic tcp server you’re on your own.

While not a python solution, I’ve seen node.js gain a lot more traction as of late. In fact I’ve considered looking into it for smaller projects but I just cringe when I hear javascript :)


回答 8

关于这一主题的一本好书是:Abe Fettig撰写的“ Twisted Network Programming Essentials”。这些示例说明了如何编写非常Pythonic的代码,对我个人而言,不要以strike肿的框架为基础。看书中的解决方案,如果它们不是干净的,那么我不知道干净意味着什么。

我唯一的困惑与其他框架(如Ruby)相同。我担心,它会扩大规模吗?我不愿意将客户端委托给将存在可伸缩性问题的框架。

There is a good book on the subject: “Twisted Network Programming Essentials”, by Abe Fettig. The examples show how to write very Pythonic code, and to me personally, do not strike me as based on a bloated framework. Look at the solutions in the book, if they aren’t clean, then I don’t know what clean means.

My only enigma is the same I have with other frameworks, like Ruby. I worry, does it scale up? I would hate to commit a client to a framework that is going to have scalability problems.


回答 9

Whizzer是一个使用pyev的微型异步套接字框架。它的速度非常快,主要是因为pyev。它试图提供类似的界面,但略有改动。

Whizzer is a tiny asynchronous socket framework that uses pyev. Its very fast, primarily because of pyev. It attempts to provide a similiar interface as twisted with some slight changes.


回答 10

也可以尝试Syncless。它基于协程(因此类似于Concurrence,Eventlet和gevent)。它实现了socket.socket,socket.gethostbyname(等),ssl.SSLSocket,time.sleep和select.select的插入式非阻塞替换。它很快。它需要Stackless Python和libevent。它包含一个用C编写的强制性Python扩展(Pyrex / Cython)。

Also try Syncless. It’s coroutine-based (so it’s similar to Concurrence, Eventlet and gevent). It implements drop-in non-blocking replacements for socket.socket, socket.gethostbyname (etc.), ssl.SSLSocket, time.sleep and select.select. It’s fast. It needs Stackless Python and libevent. It contains a mandatory Python extension written in C (Pyrex/Cython).


回答 11

我确认不同步的好处。它可以使用libev(libevent的更新,更干净,性能更好的版本)。有时它没有libevent所提供的支持,但是现在开发过程更进一步,非常有用。

I Confirm the goodness of syncless. It can use libev (the newer, cleaner and better performance version of libevent). A while ago it didn’t have as much support as libevent, but now the development process is more advanced and syncless very useful.


回答 12

如果您只想要一个简化的,轻量级的HTTP请求库,那么我觉得Unirest真的很好

If you just want a Simplified, lightweight HTTP Request Library then I find Unirest really good


回答 13

欢迎您来看看PyWorks,它采用了完全不同的方法。它使对象实例在其自己的线程中运行,并对该对象进行异步函数调用。

只需让一个类从Task继承而不是从Object继承,它就异步了,所有方法调用都是Proxies。返回值(如果需要)是将来的代理。

res = obj.method( args )
# code continues here without waiting for method to finish
do_something_else( )
print "Result = %d" % res # Code will block here, if res not calculated yet

可以在http://bitbucket.org/raindog/pyworks上找到PyWorks。

You are welcome to have a look at PyWorks, which takes a quite different approach. It lets object instances run in their own thread and makes function call’s to that object async.

Just let a class inherit from Task instead of object and it is async, all methods calls are Proxies. Return values (if you need them) are Future proxies.

res = obj.method( args )
# code continues here without waiting for method to finish
do_something_else( )
print "Result = %d" % res # Code will block here, if res not calculated yet

PyWorks can be found on http://bitbucket.org/raindog/pyworks


何时使用龙卷风,何时使用Twisted / Cyclone / GEvent /其他[关闭]

问题:何时使用龙卷风,何时使用Twisted / Cyclone / GEvent /其他[关闭]

以下哪个框架/库是构建现代多用户Web应用程序的最佳选择?我很想拥有一个异步Web服务器,这将使我可以轻松扩展。哪种解决方案将提供最佳的性能 / 可伸缩性 / 最有用的框架(就易于使用和易于开发而言)?

如果它将提供良好的功能(websockets,rpc,流式传输等),那就太好了。

每个解决方案的优缺点是什么?

Which of these frameworks / libraries would be the best choise for building modern multiuser web application? I would love to have an asynchronous webserver which will allow me to scale easly. What solution will give the best performance / scalability / most useful framework (in terms of easy of use and easy of developing)?

It would be great if it will provide good functionality (websockets, rpc, streaming, etc).

What are the pros and cons of each solution?


回答 0

Django是一个高级Python Web框架,它鼓励快速开发和简洁实用的设计”。如果您要构建类似于电子商务站点的内容,则可能应该使用Django。它将使您的工作迅速完成。您不必担心太多的技术选择。它提供了从模板引擎到ORM所需的一切。对于您构建应用程序的方式,我们会有些怀疑,如果您问我,这很好。它具有所有其他图书馆中最强大的社区,这意味着可以轻松获得帮助。

Flask是基于Werkzeug,Jinja 2和良好意图的Python微框架”。当心-“微框架”可能会产生误导。这并不意味着Flask是一个半熟的库。这意味着烧瓶的核心非常非常简单。与Django不同,它将不会为您做出任何技术决策。您可以自由选择任何令您满意的模板引擎或ORM。即使默认情况下它带有Jinja模板引擎,您仍然可以自由选择我们自己的。据我所知,Flask可用于编写API端点(RESTful服务)。

Twisted是一个用python编写的事件驱动的网络引擎”。这是高性能的引擎。其速度的主要原因是所谓的延迟。Twisted建立在延期之上。对于那些不了解延迟的人来说,这是通过异步体系结构实现的机制。扭曲非常快。但是不适合编写常规的Webapp。如果您想做一些底层的网络工作,那么twisted是您的朋友。

Tornado是一个Python Web框架和异步网络库,最初是由FriendFeed开发的。通过使用非阻塞网络I / O,Tornado可以扩展到成千上万的开放连接,使其非常适合长时间轮询,WebSocket和其他应用程序需要与每个用户建立长期连接”。龙卷风位于Django和Flask之间。如果您想用Django或Flask编写东西,但是如果您需要更好的性能,则可以选择Tornado。如果架构正确,它可以很好地处理C10k问题。

Cyclone是用于Python的Web服务器框架,它实现了Tornado API作为Twisted协议的实现”。现在,如果您想要具有与Twisted差不多的性能但易于编写的常规Web应用程序,该怎么办?向飓风打个招呼。我更喜欢飓风而不是龙卷风。它具有与Tornado非常相似的API。实际上,这是龙卷风的叉子。但是问题是它的社区相对较小。Alexandre Fiori是回购协议的唯一主要提交者。

Pyramid是一个通用的开源Python Web应用程序开发框架。其主要目标是使Python开发人员更轻松地创建Web应用程序。” 我并没有真正使用过金字塔,但是我浏览了文档。据我了解,金字塔与Flask非常相似,我认为您可以在任何地方使用金字塔 Flask合适的,反之亦然。

编辑:欢迎要求审查任何其他框架!

资料来源:http : //dhilipsiva.com/2013/05/19/python-libraries-django-twisted-tornado-flask-cyclone-and-pyramid.html

Django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design”. If you are building something that is similar to a e-commerce site, then you should probably go with Django. It will get your work done quick. You dont have to worry about too many technology choices. It provides everything thing you need from template engine to ORM. It will be slightly opinionated about the way you structure your app, which is good If you ask me. And it has the strongest community of all the other libraries, which means easy help is available.

Flask is a microframework for Python based on Werkzeug, Jinja 2 and good intentions”. Beware – “microframework” may be misleading. This does not mean that Flask is a half-baked library. This mean the core of flask is very, very simple. Unlike Django, It will not make any Technology decisions for you. You are free to choose any template engine or ORM that pleases you. Even though it comes with Jinja template engine by default, you are always free to choose our own. As far as I know Flask comes in handy for writing APIs endpoints (RESTful services).

Twisted is an event-driven networking engine written in python”. This is a high-performance engine. The main reason for its speed is something called as deferred. Twisted is built on top of deferreds. For those of you who dont know about defereds, it is the mechanism through with asynchronous architecture is achieved. Twisted is very fast. But is not suitable for writing conventional webapps. If you want to do something low-level networking stuff, twisted is your friend.

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 stands some where between Django and Flask. If you want to write something with Django or Flask, but if you need a better performance, you can opt for Tornado. it can handle C10k problem very well if it is architected right.

Cyclone is a web server framework for Python that implements the Tornado API as a Twisted protocol”. Now, what if you want something that is nearly as performant as Twisted but easy to write conventional webapps? Say hello to cyclone. I would prefer Cyclone over Tornado. It has an API that is very similar to Tornado. As a matter of fact, this is a fork of Tornado. But the problem is it has relativly small community. Alexandre Fiori is the only main commiter to the repo.

Pyramid is a general, open source, Python web application development framework. Its primary goal is to make it easier for a Python developer to create web applications.” I haven’t really used Pyramid, but I went through the documentation. From what I understand, Pyramid is very similar to Flask and I think you can use Pyramid wherever Flask seems appropriate and vice-versa.

EDIT: Request to review any other frameworks are welcomed!

Source: http://dhilipsiva.com/2013/05/19/python-libraries-django-twisted-tornado-flask-cyclone-and-pyramid.html


回答 1

这显然是一个有偏见的答案,但这与错误的答案不同。您应该始终使用Twisted。我之前也回答过类似的问题,但是由于您的问题并不完全相同,因此有一些原因:

“最棒的表演”

Twisted在speed.twistedmatrix.com网站上持续监控我们的表现。我们也是PyPy的类似网站监控的首批项目之一,从而确保Twisted在运行时的良好性能,这是任何关注Python中高性能应用程序的人的。

“可伸缩性”

据我所知,列出的框架都没有内置的自动缩放支持。它们都是通信框架,因此您必须进行工作以在扩展节点之间进行通信。但是,Twisted在其对本地多处理的内置支持方面具有优势。公平地说,Tornado一个第三方加载项,使您可以执行相同的操作。在最新发行版中,Twisted添加了功能,这些功能增加了内核之间共享工作的方式数量,并且该领域的工作正在进行中。扭曲的也有一对夫妇的良好整合“本土” RPC它提供了一个建筑套件,无论缩放成语你想追求的协议。

“最有用”

很多人似乎发现Twisted 非常有用如此之多,以至于其中许多人都对其进行了扩展,并向您提供了其扩展名。

“功能”

开箱即用,Twisted包括:

至少在最后一个部门中,Twisted似乎是内置功能的明显赢家。而这一切,仅需2兆字节即可!

This is obviously a somewhat biased answer, but that is not the same thing as a wrong answer; you should always use Twisted. I’ve answered similar questions before, but since your question is not quite the same, here are some reasons:

“Best Performance”

Twisted continuously monitors our performance at the speed.twistedmatrix.com website. We were also one of the first projects to be monitored by PyPy’s similar site, thereby assuring the good performance of Twisted on the runtime that anyone concerned with high-performance applications in Python.

“Scalability”

To my knowledge, none of the listed frameworks have any built-in support for automatic scaling; they’re all communication frameworks, so you have to do the work to communicate between your scaling nodes. However, Twisted has an advantage in its built-in support for local multi-processing. In fairness, there is a third-party add-on for Tornado that allows you to do the same thing. In recent releases, Twisted has added features that increase the number of ways you can share work between cores, and work is ongoing in that area. Twisted also has a couple of well-integrated, “native” RPC protocols which offer a construction-kit for whatever scaling idiom you want to pursue.

“Most Useful”

Lots of people seem to find Twisted very useful. So much so that many of them have extended it and made their extensions available to you.

“Functionality”

Out of the box, Twisted includes:

In this last department, at least, Twisted seems a clear winner for built-in functionality. And all this, in a package just over 2 megabytes!


回答 2

我喜欢@Glyph回复。Twisted非常全面,丰富的python框架。Twisted和Tornado具有非常相似的设计。我非常喜欢这种设计:

  • 它很快
  • 容易理解
  • 易于扩展
  • 不需要 c扩展名
  • 在PyPy上工作。

但是,我想强调Tornado,我更喜欢它,最近又变得流行。与Twisted类似,Tornado使用回调样式编程,但是可以使用tornado.gen.enginetwisted.internet.inlineCallbacks在Twisted中)。

程式库

最佳评论来自http://cyclone.io网站。气旋试图混合扭曲和龙卷风,因为:

Twisted是最公开的非阻塞I / O库之一。Tornado是FriendFeed的Web服务器的开源版本,它是Python最受欢迎,最快速的Web服务器之一,并具有用于构建Web应用程序的非常不错的API。

这个想法是将Tornado优雅而直接的API桥接到Twisted的Event-Loop,从而实现大量受支持的协议。

但是在2011年 tornado.platform.twisted年问世,它带来了类似的功能。

性能

龙卷风有更好的表现。它还可以与PyPy无缝协作,并获得巨大收益。

可扩展性

像扭曲一样。龙卷风有tornado.process在其上实现了许多rpc服务。

功能性

有71种基于Tornado的软件包,而148种Twisted和48 Gevent的软件包。但是,如果仔细查看并计算软件包上载时间的中位数,您会发现Twisted最早,而Gevent和Tornado最新鲜。此外,还有一个tornado.platform.twisted模块,允许您运行为Twisted on Tornado编写的代码

摘要

使用Tornado,您可以使用Twisted中的代码。无需使用只会扭曲的旋风分离器您的代码的(您的代码会变得更加混乱)。

至于2014年,Tornado被认为是广泛接受的默认异步框架,可同时在python2和python3上使用。另外,最新版本4.x带来了https://docs.python.org/dev/library/asyncio.html中的许多功能。

我写了一篇文章,解释了为什么我认为Tornado是最好的Python Web框架,在那里我写了很多有关Tornado功能的信息。

I like @Glyph response. Twisted is very comprehensive, rich python framework. Twisted and Tornado have a very similar design. And I like this design very much:

  • it’s fast
  • easy to understand
  • easy to extend
  • doesn’t require c-extensions
  • works on PyPy.

But I want to highlight Tornado, which I prefer and recently gain popularity. Tornado, like Twisted, uses callback style programming, but it can be inlined using tornado.gen.engine (twisted.internet.inlineCallbacks in Twisted).

Codebase

The best comment is from http://cyclone.io site. cyclone tries to mix Twisted and Tornado because:

Twisted is one of the most mature libraries for non-blocking I/O available to the public. Tornado is the open source version of FriendFeed’s web server, one of the most popular and fast web servers for Python, with a very decent API for building web applications.

The idea is to bridge Tornado’s elegant and straightforward API to Twisted’s Event-Loop, enabling a vast number of supported protocols.

But in 2011 tornado.platform.twisted was out which brings similar functionality.

Performance

Tornado has much better performance. It also works seamlessly with PyPy, and get huge gain.

Scalability

The same like Twisted. Tornado has tornado.process and a lot of rpc services implemented on top of it.

Functionality

There are 71 Tornado based package, compared to 148 Twisted’s and 48 Gevent’s. But if you look carefully and compute median of packages upload time, you will see that Twisted ones are the oldest, then Gevent and Tornado the freshest. Furthermore there is tornado.platform.twisted module which allows you to run code written for Twisted on Tornado.

Summary

With Tornado you can use a code from Twisted. There is no need to use cyclone which only twists your code (your code becomes more messy).

As for 2014, Tornado is considered as widely accepted and default async framework which works both on python2 and python3. Also the latest version 4.x brings a lot of functionality from https://docs.python.org/dev/library/asyncio.html.

I wrote an article, explaining why I consider that Tornado – the best Python web framework where I wrote much more about Tornado functionality.


回答 3

更新:我对这里推荐甚至提到Gevent的答案很少感到惊讶,我认为这与这个出色的库的受欢迎程度,性能和易用性不成比例!)

Gevent和Twisted并不是互斥的,尽管乍一看似乎相反。有一个名为的项目geventreactor,可以使人们相对平稳地利用两全其美的优势,即:

  • Gevent的高效,廉价(绿色协作)线程模型,在并发方面更容易编程—坦率地说,inlineCallbacks对于许多协同程序,Twisted的性能根本无法胜任,在易用性/透明度方面:yieldDeferreds无处不在; 通常很难建立一些抽象;带有Deferred,甚至还有的可怕的无用堆栈跟踪@inlineCallbacks
  • 您可以梦想得到的Twisted的所有内置功能,包括但不限于IReactorProcess.spawnProcess

我目前个人使用Gevent 1.0rc2和Twisted 12.3桥接geventreactor。我已经实现了我自己尚未发布的增补和增强功能geventreactor,我将很快对其进行发布,希望作为geventreactor原始GitHub存储库的一部分:https : //github.com/jyio/geventreactor

我目前的布局可以让我在节目中GEVENT漂亮的编程模型,并利用的东西,如非阻塞socketurllib2和其他模块。我可以使用常规的Python代码来完成常规的工作,而不是通过Twisted方式来学习曲线和简单甚至基本的工作带来的不便。我也可以轻松地使用大多数第三方库,这些库通常对于Twisted来说是毫无疑问的,或者需要使用线程。

我还可以通过使用greenlets(而不是Deferreds和callbacks和/或@inlineCallbacks)完全避免笨拙且通常过于复杂的基于回调的编程。

(此答案是根据我在现实生活项目中同时使用Twisted和Gevent的个人经验编写的,并且使用Twisted的经验也很多(但我并没有声称自己是Twisted专家)。我必须编写hasn的软件不必使用Twisted的太多功能,因此根据Twisted所需的功能集,混合Gevent和Twisted的(相对轻松)额外的复杂性可能不值得。

(UPDATE: I’m sadly surprised about how few answers here recommend or even mention Gevent—I don’t think it’s in proportion to the popularity, performance and ease of use of this excellent library!)

Gevent and Twisted are not mutually exclusive, even though the contrary might seem obvious at first. There is a project called geventreactor which allows one to relatively smoothly leverage the best of both worlds, namely:

  • The efficient and cheap (cooperative green) thread model of Gevent, which is much easier to program in when it comes to concurrency—frankly, Twisted’s inlineCallbacks is simply not up to the job in terms of performance when it comes to many coroutines, and neither in terms of ease/transparency of use: yield and Deferreds everywhere; often hard to build some abstractions; horrifyingly useless stack traces with both bare Deferreds as well as, and even more so with @inlineCallbacks.
  • All the built-in functionality of Twisted you can ever dream of, including but not limited to IReactorProcess.spawnProcess.

I’m personally currently using Gevent 1.0rc2 with Twisted 12.3 bridged by geventreactor. I have implemented my own as-of-yet unpublished additions and enhancements to geventreactor which I will publish soon, hopefully as part of geventreactor‘s original GitHub repository: https://github.com/jyio/geventreactor.

My current layout allows me to program in the nice programming model of Gevent, and leverage things such as a non-blocking socket, urllib2 and other modules. I can use regular Python code for doing regular things, as opposed to the learning curve and inconvenience of doing even simple, basic things the Twisted way. I can also easily use most 3rd party libraries that are normally either out of question with Twisted, or require the use of threads.

I can also completely avoid the awkward and often overly complex callback based programming by using greenlets (instead of Deferreds and callbacks, and/or @inlineCallbacks).

(This answer was written based on my personal experiences having used both Twisted and Gevent in real life projects, with significantly more experience using Twisted (but I don’t claim to be a Twisted expert). The software I’ve had to write hasn’t had to use too many of Twisted’s features, so depending on the set of features you require of Twisted, the (relatively painless) extra complexity of mixing Gevent and Twisted might not be worth the trouble.)