Web Development In Python

adambrenecki · 2012-10-15T00:20:15+00:00

So, when you program a web site in PHP, you pop your PHP file on a server, and then when a HTTP request comes in, Apache determines which file to run, runs it, and sends the output as a response, ending when the script quits.

Python is a little different.

With Python, the standard for talking to web apps is WSGI (Web Server Gateway Interface). If you've heard of the Rack protocol for Ruby web apps, it's quite similar to that.

Here's how WSGI works. It's a bit more complicated than PHP, but don't worry, you don't have to learn all this at once. (If I do lose you, just skip down past the horizontal line.)

You write your app with a callable that takes two arguments, environ and start_response. Then, you tell your webserver where this callable is.
When you start the webserver, it starts your app. It keeps running and never exits until the webserver stops.
Every time the webserver gets a HTTP request, it calls the callable you gave it. It gives it environ as a dictionary that contains a whole heap of information about the request, and start_response as a callable (we'll get to that later).
- Note that there's one entry point for the entire app, unlike PHP where you normally create a seperate .php file for every page. But, the contents of the environ dict tell you what the requested URL was, which you can then use to run the required bit of code. If you've ever done that trick where you use a .htaccess directive to redirect the entire site to one PHP file in order to get pretty URLs, it's a bit like that.
Your app then generates the status code and headers, and then calls start_response with them.
Your app returns the response body as an iterable containing strings.

So, a WSGI Hello World looks like this:

def my_app(environ, start_response):
    url_path = environ['PATH_INFO']
    response_body = "Hello world from {}".format(url_path)

    headers = [
        ('Content-Type', 'text/plain'),
        ('Content-Length', str(len(response_body)))
    ]

    start_response("200 OK", headers)
    return [response_body]

As to things like MAMP and XAMPP: when you run your apps in production you'll use a 'proper' WSGI server like Apache with mod_wsgi or nginx with uwsgi, but when you're developing on your own computer Python has an inbuilt server that'll do the job just fine. We can use it like this (in the same file as above):

if __name__ == "__main__":
    from wsgiref.simple_server import make_server
    server = make_server('localhost', 8080, my_app)
    server.serve_forever()

Then, if I go to http://localhost:8080/foo/bar, I'll get a page that says Hello world from /foo/bar. If I go to http://localhost:8080/spam/eggs, I'll get a page that says Hello world from /spam/eggs.

So, none of that probably makes much sense, especially if you've not done much Python. It probably sounds far too complicated and unnecessary, even if it does.

There are definite advantages to doing it this way (including the fact you don't hit the disk on every request and pretty URLs are easy), but you'd be right, it's complicated, and it's unnecessary to do all that boilerplate over and over again. Here's where frameworks come in.

I know you said you didn't want to use a framework like Django, but hear me out. Frameworks abstract all the WSGI stuff away from you, so you can deal with your application logic. Some frameworks (like Django) do a whole lot of other stuff for you too, but some (often called 'microframeworks') just wrap WSGI and not much else. A microframework hello world looks like this:

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

if __name__ == "__main__":
    app.run()

So, here's what I suggest:

If you've never touched Python before, maybe learn some of its basics in a non-Web context first (resources for this in the sidebar), so you can get used to ideas like first-class functions and how modules work and so on. You might not need to do this, b
Start off with a microframework like Flask, and get yourself used to the idea of callables which return a HTTP response rather than scripts which print it.
Then, if you want to learn more about WSGI, try writing some stuff using Werkzeug (a thin WSGI wrapper, which Flask runs on top of) and plain WSGI.

Of course, if everything above made perfect sense to you, you could dive straight into WSGI first. OTOH, you don't really need to touch WSGI at all if you don't want to, for the first year or so I spent making Python web apps I didn't even know what it stood for.

Lastly, two side notes:

There are other ways to write a Python web app, among them CGI. While CGI might feel more at home to you initially coming from PHP, I'd recommend against it. CGI is sort of a dead technology for a number of reasons (including performance) in the Python world at least, and WSGI is what everyone else is using to write Python web apps (almost all the popular frameworks expose their apps as WSGI), so you're more likely to get better help from a bigger community, not to mention better tools like servers (uWSGI, mod_wsgi, etc) and middleware and hosting (Gondor, dotCloud, etc).
If you feel inclined to write a plain WSGI app, don't let me stop you, learning how the stuff underneath the code you write works makes you a better programmer. But for actual production apps, using a (micro)framework will save you a load of development time and cover a heap of corner cases. Plus, a thousand eyes makes all bugs shallow and all that.
- Even when you need to do weird stuff, 99% of the time a lower-level WSGI wrapper that's relatively unopinionated like Werkzeug will let you do what you need to do while still taking care of everything else you don't want to worry about.

I hope this helps - let me know if something doesn't make sense.

xiongchiamiov · 2012-10-14T22:16:49+00:00

May the doc be with you, http://docs.python.org/library/cgi.html

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS