At the Forge - First Steps with Django

If you want the power of Rails with Python instead, give Django a jingle.
Connecting to the Database

Part of the reason for using a framework like Django is because it provides us with an excellent object-relational mapper—a fancy way of saying that it turns Python objects into database tables and back without forcing us to work too hard. But, of course, this is possible only if we connect Django to a database.

For this project, I created a small PostgreSQL database named atf:

createdb -U reuven atf

I then can modify, making the following variable assignments:

DATABASE_ENGINE = 'postgresql'
DATABASE_USER = 'reuven'

Notice that I had to set DATABASE_PORT to 5433 explicitly. On my system, Django tried to connect to the PostgreSQL server on port 5432, but the database was listening on port 5433.

Before we run the application, we now should synchronize the database. This is the Django term for creating tables that have not yet been defined in the database. We do this by typing (in another shell):

python syncdb

Now, if you're coming from the Rails world, you might be scratching your head at this point. What tables could Django possibly need to create? I haven't defined any database tables or model objects—what's going on?

The answer is that although Rails and Django are similar in some ways, they differ significantly in other ways. One of those ways has to do with authentication. Django assumes that everyone will want to have an authentication system. After creating the appropriate database tables, Django then prompts you for the user name, e-mail address and password of the superuser for your site. It then finishes with the creation of the administration tables.

Now we can start our server again:

python runserver

If you are running your Django development site on a machine other than your local workstation, you might want to add an optional IP address and port number:

python runserver

Creating an Application

If you point your Web browser at the server you've just set up, you're bound to be disappointed. Yes, we see that Django is running, but we also see that it is giving us an error message when we try to access the server. What's happening?

The simple answer is that we have not yet populated our project with any applications. The project exists, and the server is running, but they are basically an empty shell. Until we create and install one or more applications, we're not going to see very much.

The exception is the Django administrative package, which comes with the system and is immediately available. Well, that's not quite true. It's available, but only if you explicitly modify the list of installed applications (INSTALLED_APPS) to include the appropriate package name. Luckily, we can do that without too much trouble. We open up mysite/, scroll down to the bottom and modify INSTALLED_APPS such that it includes the string:


You don't even have to restart the server. Once this value has been added, you will be asked to log in with a user name and password. Enter the values that you gave to Django when it created the administrative database, and you'll get a nicely formatted (if sparsely populated) administrative site, complete with links to Django documentation.

Without any other applications installed, it might seem a bit silly to have a Django administrative site. But, one of the things Django provides that Rails doesn't is an underlying authentication and security system. Right out of the box, Django understands that there are users and groups, and that they might need to be assigned different permissions. You easily can add, modify and delete groups, giving them one or more permissions from a provided list.

Even without any applications in place, you can create and administer a system with users, groups and permission levels. It would have been nice if Django were to support hierarchies of groups, rather than the one-level model it currently uses. Regardless, I've always been fond of Web frameworks that come with built-in users, groups and permissions. The fact that Django comes with a graphical system to manipulate them is even better.


This month, we began to look at Django, a popular open-source Web framework written in Python. We got our Django project up and running, including connections to a relational database. We were even able to browse through some of its administrative screens, assigning permissions to users and groups. Next month, we'll continue with our exploration of Django, looking at how we can create new applications with its versions of the MVC (model-view-controller) paradigm.



Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

In case you're reading this

Conny Brunnkvist's picture

In case you're reading this tutorial and can't seem to get the admin interface up, it might be that you're using a version that requires you to edit - the article fails to mention this!

The following lines in should be of special interest to you:

# Uncomment this for admin:
# (r'^admin/', include('django.contrib.admin.urls')),

Small typo, but it should be

Tony S's picture

Small typo, but it should be, not __init.py__.

One more correction

Adrian Holovaty's picture

It's misleading to say "Django assumes that everyone will want to have an authentication system." The authentication system, along with a few other commonly used features, is activated by default, but it's very easy to disable -- just comment out the appropriate lines in INSTALLED_APPS before you run the "syncdb" command, and none of that stuff will be installed.


Adrian Holovaty's picture

Hey there,

It's misleading to say "Django was first written by Adrian Holovaty" -- Simon Willison worked on it from the start, and Jacob Kaplan-Moss also contributed greatly before the framework was open-sourced.