Ask HN: Best Python web framework

Flask is best IMHO. Django is good enough.

Sadly, Django is still by far the most popular. It's ok, though. You're likely to not hate it intensely. It also has a lot of third party code available, and a fair amount of functionality built-in.

Flask is nicer (and lets you seamlessly use SQLAlchemy, which is so much better than Django's crappy ORM), but also tiny. It's basically just a bit of glue between werkzeug, SQLAlchemy and Jinja2.

Pyramid has more things in it than Flask and also uses SQLAlchemy.

web2py appears both bad and unpopular to me.

The best for what? What do you want to do?

We have found Django to be great for throwing up a site quickly. We primarily use Pyramid now for our more serious development as it fits more with what we're trying to achieve. My feeling is the beauty of Python is that there are more than one ways of doing something. Define what you want out of your framework, try some and then see how you feel

Depends on what you want from the framework. Django is good, but for a smaller blog, try pyblosxom, it's quite nice!

Pylons is now called pyramid. I don't know how much it changed?

I prefer pylons above Django. Simply because it feels less like a framework.

web.py

I use web2py. It struggles to get the attention that Django gets, but it has a robust development community.

It offers a good balance between Django (which i find a little big and unwieldy), and Flask (which I think suffers from the opposite problem).

Depends on what you are developing, of course.

I picked web2py about 3 years ago, and it has worked well for me. I'm developing CRUD apps to solve business problems with the minimum of fuss and effort, but with the confidence that I can roll my sleeves up and exercise more control if I need to - web2py has been a good fit for that.

I really like bottle.py [1]. I've used it for a couple of different projects; although not fundamentally different from web.py or flask, it seems to just "make sense".

[1] http://bottlepy.org/docs/stable/

An example from their website:

    from bottle import get, post, request

    @get('/login') # or @route('/login')
    def login_form():
        return '''<form method="POST">
                    <input name="name"     type="text" />
                    <input name="password" type="password" />
                  </form>'''

    @post('/login') # or @route('/login', method='POST')
    def login_submit():
        name     = request.forms.get('name')
        password = request.forms.get('password')
        if check_login(name, password):
            return "<p>Your login was correct</p>"
        else:
            return "<p>Login failed</p>"

    from flask import Flask, request
    app = Flask(__name__)

    @app.route('/login')
    def login_form():
        return '''<form method="POST">
                    <input name="name"     type="text" />
                    <input name="password" type="password" />
                  </form>'''

    @app.route('/login', methods=['POST'])
    def login_submit():
        name     = request.form.get('name')
        password = request.form.get('password')
        if check_login(name, password):
            return "<p>Your login was correct</p>"
        else:
            return "<p>Login failed</p>"

CherryPy has had Python 3 support for quite a while now. Not many Python frameworks have that. Pylons just got it, so I'd go with CherryPy. You can get WebSocket support too, and documentation is OK.

Tornado.

Built-in async operations.

Not standing in your way.

Rapid developments.

Huge community.

Simply works.

Simple, yet rich.

(Full disclosure: I'm a member of Django's core team)

There's no single "best" for every application. One-size-fits-none. One of Django's strengths is in the fact that parts of the framework come off easily when they no longer serve your needs. If the ORM is no longer working for you, you can use SQLAlchemy or write raw SQL. Authentication no longer working for you? Write your own or use a 3rd party one.

Et cetera. The key aspect is that you don't need to sacrifice the entire framework when only one part of it no longer addresses your needs. Keep in mind that 99% of sites never even reach this point.

The other major strength of django is the rich ecosystem of 3rd party apps. That's a lot of code you don't need to write yourself.

That being said, Flask is popular for a reason. Django offers a lot of power, which means adding some complexity to even the simplest projects (something we're working to address with features like project templates in Django 1.4). Flask fills a niche for a framework that is easy to get up and running and addresses 90% of the things which 90% of people need for many projects.

I've heard good things about pyramid, but haven't had a chance to play yet.

I haven't had the "pleasure" of working with web2py, and I'm not knocking the effort which Massimo puts into it, but the choices made there often elicit a raised eyebrow. Ignoring my opinion for a moment, the smartest web hackers I know universally regard web2py as a fundamentally incorrect way to approach web development—but usually say so in far more colorful terms.

TL;DR

* Flask for simpler stuff

* Django for anything larger, or simple stuff that leverages a 3rd-party app you need.

* What matters is the app you ship, not the framework it was built with.

* Django developers are in super-high demand. I get cold-called frequently.

I'm surprised nobody mentioned brubeck (http://brubeck.io) until now, which takes a completely fresh approach to concurrent handling via implicit context switching (more on their website).

Obviously, as idan mentioned already, there is no single "best" framework, so it really depends on the type of application you want to build whether you should choose something like bottle/flask, django/mezzanine/pinax or brubeck/tornado, or even twisted.

Pyramid is probably the best at the moment. It has a lot of power when it comes to fine grained security utilizing access control lists and it integrates really well with the major python libraries out there.

Which (or do any) of the major Python frameworks have Python 3 support?

Pyramid.

http://en.wikipedia.org/wiki/Pyramid_%28web_framework%29

* faster.

* better quality (100% statement coverage via unit tests)

* supports latest python.

* great documentation (including free up to date book). There's also a separate pyramid cookbook.

* simplicity. If you just see a pyramid app, you can dive right in fairly easily without learning lots of alien stuff.

* sensible defaults, and you can choose to swap out parts easily if you want (templates, ORM, etc).

* works well with other python software, doesn't bundle everything in, with NIH syndrome.

* great tools. like the web console that drops straight into a debugger when an exception happens on the page you're looking at.

The framework that starts with D is a legacy framework (doesn't even support python3 yet).

Flask is at about the right level of abstraction in the age of polyglot DBs and the JS movement to put the presentation in the browser. Flask gets out of your way and makes it easy to adapt to the changing environment without having to hack your way out of a monolith.

Diesel (http://diesel.io/) has piqued my interest as of late -- it's a high-concurrency, coroutine-based framework with Flask under the hood, by the guys at Bump.

The next-gen Python Web frameworks will probably be non-WSGI because WSGI doesn't support WebSockets.

One approach would be a ZeroMQ-based framework like Brubeck (http://brubeck.io/) behind Mongrel2 (http://mongrel2.org/). But AFAIK, WebSocket support is not yet fully baked into Mongrel2. The handshake still needs to happen on the handler side.

Try Brubeck. It's a Python web framework built around Gevent, DictShield and ZeroMQ. It communicates with Mongrel2, it's web server, via ZeroMQ sockets so even the annoying design of WSGI is moved out of the way.

It converts your blocking calls to nonblocking, has no spaghetti code filled with callback shenanigans, and can even generate a full REST API for you.

https://github.com/j2labs/brubeck

As with whichever framework you choose you will have to get inside its code to understand it, adapt to it or fix it, I would advise to choose one framework that has code that is pleasing to read and follow very strictly conventions. Right now my box is broken so I can't check but last I have checked Django had a relatively good pylint score, while Flask had a seemingly slightly more messy code base.

web2py is great. Really. I'm quite sure some people are confusing web.py (toolkit behind reddit) and web2py - I know I was a couple of years ago.

web2py is super complete, but doesn't get in your way, and doesn't require you to learn everything up front. It's DAL is much simpler (and in my opinion, much more effective) than an ORM -- but you don't have to use it.

Its templating system is just plain python inside {{}}, where you need to add "pass:" to dedent if it cannot be inferred from the code, but that's it. No need to learn a new templating system.

The community is super awesome. Starter applications like issue trackers, minimal facebooks or twitters etc. are often posted on the mailing list inside one short message (not as an attachment -- the whole thing is posted inside the message text, and takes no more than two screenfuls)

Really, give web2py a try if you haven't.

I have used web2py for the last few years and have been happy with it:

- well designed components: DAL, SQLFORM, views, etc

- commitment to backwards compatibility

- works on GAE

- helpful community (groups.google.com/group/web2py)

- thorough documentation (web2py.com/book)

The main criticism of web2py is that its design is not 'pythonic', which is irrelevant to me.

BlueberryPy author here. Allow me to plug CherryPy and my micro-framework built on top of CherryPy called BlueberryPy.

Here's my answer on stackoverflow early last year when someone asked for a CherryPy vs Flask comparison. I believe all the points still stand and still represent CherryPy's strengths.

1. Simplicity. Controller object trees more or less equal to how you would define your URLs. 2. Flexibility. In case you don't like how the URLs are defined by default, you can use routes or methods to expose your URL handlers, which are just as easy. 3. Tools. CherryPy isn't religious about WSGI, though it's 100% compatible with the WSGI spec, the recommended approach is to use Tools. They are simple to make and use, and the way they are wired to the request is a lot more efficient than WSGI, which typically a request has to pass through whether or not that particular WSGI middleware is relevant. (Unless you use a framework where each URL handler is a WSGI application, but wiring up WSGI apps are still annoying). There are LOTS of them supplied by default that cover most of the use cases you can think of. 4. Plugins. For cross-cutting concerns, engine plugins are a much more granular, well-defined, and suitable way to deal with them as opposed to a WSGI app, which is typically the hammer people use to hammer in every screw these days. 5. Easy chunked responses. You just yield a string in the controller and that's it. Very useful for returning large documents in pieces. 6. Full-featured request and response objects. WebOb and CherryPy are about the only 2 frameworks that have comparably complete implementations of them, but I'd still choose CherryPy for the last reason: 7. Zero dependency on other packages. You won't bring in a dozen other libraries just to run a server. You just easy_install or pip install cherrypy and that's it.

Its WSGI server is also the canonical choice if you need a fast and stable pure Python WSGI server implementation. It's actually really really fast and stable:

    http://nichol.as/benchmark-of-python-web-servers

Now, I've been using CherryPy for about 5 years now and am still absolutely in love with it. I love it so much that I've decided last month to open source the micro-framework I've built on top of CherryPy called BlueberryPy:

    https://bitbucket.org/wyuenho/blueberrypy

It's basically a set of additional tools and plugins for CherryPy which give you an easier integration with SQLAlchemy, logging, Redis and Jinja2, webassets and various other goodies. It also comes with a project skeleton generator akin to many other frameworks out there but doesn't get in your way with the generated source files. All that BlueberryPy asks for is a configuration directory with a few correct YAML config files with a few keys pointing to a few classes in your package. Documentation is a little light but more will come soon enough as I find time to finish them up. Stay tuned :P

Richard Jones did a nice presentation about this in August 2011, comparing 10 Python frameworks along a lot of useful metrics (perf, simplicity, size, documentation, etc) by developing the same "hello world"-ish app in each one. He even scored them at the end.

The slides are at http://www.slideshare.net/r1chardj0n3s/web-microframework-ba... -- they don't seem to be loading inline now but the PDF download still works. Video of the talk is at http://www.youtube.com/watch?v=AYjPIMe0BhA .

Spoiler alert: the winner was bottle.py, by a nose.

I've been using Flask for my current project and I absolutely love it.

The project is a web interface for our library's digital archives (mostly audio and video assets, but also images and print documents). Version 1 of the project used php and mysql for the front end with python scripts handling the transcoding and metadata handling on the back end. For a variety of reasons the project got bloated to the point of being unmanageable. I decided I wanted a fresh start with a python framework and considered all the ones mentioned here.

I went with Flask because I wanted to leave the existing database structure in place and I wanted to err on the side of the framework doing too little instead of too much.

As a non-programmer (my job title says "audio engineer"), Flask was simple enough to understand, but did enough to make my life considerably easier. My one gripe is I think Flask-Login still has room for improvement, at least in terms of documentation. I've gotten it working good enough, but I still don't understand how credentials are passed around my application.

I'm sure other frameworks would have also gotten me to where I needed to be, but after working with Flask for a month or so, I'm not immediately reaching for something else.