3. Hello World - urls & views

Everybody starts with Hello World. I was not an exception, either. It takes time to learn something, especially, it's not a primary everyday task at work place.

Django was my side kick and it took me several years to get used to it. Still, I consider myself as a novice.

It's been very hard to set aside a time slot for Django. But I managed to start something real such as this:

I've been exposed to couple of web frameworks, and currently managing my sites with RubyOnRails, Angular/Node, Laravel, and Django. I prefer Django over others. Probably, not just because I like Python but also Python has several promising areas including NLTK/Scikit/Spark and also graphics tool like Matplotlib which seems to be overcoming once the hot one like D3.js.

So, if you're new to Django, I encourage you to move forward and learn it.

If you're new to REST, then you can try lighter ones such as Bottle or Flask (actually, I haven't tried Flask).

In the previous chapters, we've learned how to setup project and made a polling app utilizing SQL. However, it's a little bit tougher than this "Hello World" example that I'll show in this chapter. So, let's pause the polling app here, instead do a simpler one first. We'll resume the polling project in later chapters.

In this chapter, we'll take much simpler project as a review what we've learned so far.

Let's create a HelloWorld project:

$ django-admin.py startproject HelloWorld
$ cd HelloWorld
$ ls
HelloWorld  manage.py

Note that we have manage.py file and HelloWorld folder inside HelloWorld project.

1. __init__.py: An empty file that tells Python that this directory should be considered a Python package.
2. settings.py: Settings/configuration for this Django project. Django settings will tell us all about how settings work. In other words, this file will hold all apps, database settings information.
3. urls.py: The url declarations for this Django project; a "table of contents" of our Django-powered site. This is a file to hold the urls of our website such as "http://localhost/HelloWorldApp". In order to use /HelloWorldApp in our HelloWorld project we have to mention this in urls.py.
4. wsgi.py: An entry-point for WSGI-compatible web servers to serve our project. This file handles our requests/responses to/from django development server.

Inside the HelloWorld project directory, we need to run the development server:

$ python manage.py runserver
Validating models...

0 errors found
...
Django version 1.6.5, using settings 'HelloWorld.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Open a browser and put "http://127.0.0.1:8000/" into url box, then we get the default page:

To create an app (inside HelloWorld project directory), we need to run the following command:

$ django-admin startapp HelloWorldApp
$ ls
HelloWorld  HelloWorldApp  manage.py

As we can see from the layout in picture above, the django-admin startapp app created files:

1. __init__.py - this file indicates our app as python package.
2. models.py - file to hold our database informations.
3. views.py - our functions to hold requests and logics.
4. tests.py - for testing.

We need to edit settings.py under HelloWorld project directory to add our application HelloWorldApp as shown below:

# Application definition

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'HelloWorldApp',
)

How does Django know what view to send a particular request?
Django uses a mapping file called urls.py which maps html addresses to views, using regular expressions. In other words, Django has a way to map a requested url to a view which is needed for a response via regular expressions.

Let's modify the urls.py which is under the project directory, HelloWorld:

from django.conf.urls import patterns, include, url
from HelloWorldApp.views import foo

#from django.contrib import admin
#admin.autodiscover()

urlpatterns = patterns('',
    # Examples:
    # url(r'^$', 'HelloWorld.views.home', name='home'),
    # url(r'^blog/', include('blog.urls')),

    #url(r'^admin/', include(admin.site.urls)),
    url(r'HelloWorldApp/$', foo),
)

In the commented lines, we have ^$. Since the caret(^) means the start and the dollar($) means the end, ^$ indicates we got nothing. The r in "url(r..) is not a part of regex but it's a python indicating "raw" to prevent any character in regex from being parsed in python's way. In other words, it tells python that a string is "raw" - that nothing in the string should be escaped.

The url() is a function call that builds url patterns and it takes five arguments, most of which are optional:

url(regex, view, kwargs=None, name=None, prefix='')

The foo is the Python import string to get to a view.

Visit django.conf.urls utility functions for more information.

As a next step, we'll modify views.py under app directory, HelloWorldApp:

# Create your views here.
from django.http import HttpResponse
def foo(request):
    return HttpResponse("Hello World!")

This views.py takes a request object and returns a response object.

Note that we first import the HttpResponse object from the django.http module. Each view exists within the views.py file as a series of individual functions. In our case, we only created one view - called foo. Each view takes in at least one argument - a HttpRequest object, which also lives in the django.http module. Each view must return a HttpResponse object. A simple HttpResponse object takes a string parameter representing the content of the page we wish to send to the client which is requesting the view.

$ python manage.py runserver

If we type in http://localhost:8000/HelloWorldApp/, we get the successful "Hello World!":

1. When we type localhost:8000/HelloWorldApp into the browser, this will send request to Django. Django framework provides a way to map HelloWorldApp to a code to do something as listed in the next steps.
2. Django will read urls.py and look for url matching pattern.
3. If it matches, it calls the associated function.
4. In our case, it matches HelloWorldApp in urls.py.
5. So, foo() in views.py is called.
6. In views.py, we have the code to display the "Hello World!" as HttpResponse.

1. Creating a new Django Project
   
   To create the project, we need to run,

   django-admin.py startproject <project_name>
   

2. Creating a new Django application
   
   
   1. To create a new application, we should run,

      python manage.py startapp <app_name>
      

   2. Tell our Django project about the new application by adding it to the INSTALLED_APPS tuple in our project's settings.py file.
   3. In our project urls.py file, add a mapping to the application and this info in urls.py file will be used to direct incoming URL strings to views.
   4. In our application's view.py, create the required views ensuring that they return a HttpResponse object.