Links

Django For Beginners

A comprehensive introduction to Django for beginners
This tutorial aims to help beginners getting started with Django, a popular Web Framework written in Python. To get maximum from this content, the audience should be familiar with a terminal and have a minimal set of tools already installed. Python3, a modern code editor (VsCode, Atom), and GIT versioning command-line tool should be enough to experiment with all the code.

Install Python

The core of dependency for Django is Python and we should install the interpreter first. Most of the systems come with Python already installed and we can easily check in the terminal:
$ python --version
Python 3.8.4 <-- All Good
If the version displayed in the terminal is Python2, please note that this version has been discontinued for versioning and development since Jan.2020. To download and install Python access the official page, select the installer that matches the operating system, and follow the installation setup. Once the process is finished, recheck the Python version in the terminal.

Manage Dependencies

With Python up and running, we can install Django and other modules required by our development. The recommended way to install and manage the dependencies for a Python project is to use a virtual environment, a safe way to isolate the dependencies across multiple projects.
$ # Linux-based systems
$ virtualenv env
$ source env/bin/activate
For Windows-based systems, the syntax is slightly different:
$ virtualenv env
$ .\env\Scripts\activate
Let's install Django, using PIP (official package manager for Python)
$ pip install django
The above command will install the latest stable version of Django. From this point, we can use all tools provided by Django to create a new project, apps and manage the project via Django CLI.

Install a Code Editor

This section has plenty of options from the old-school (yet modern) Vim to VsCode and Atom. For those unfamiliar with any of these tools, VsCode might be a good choice to get started fast.
Programming Kit - VSCode editor.

Build a Django Project

A new project can be generated with ease in Django by using django-admin that provides a collection of settings for the database, Django, and security layer.
Create the project folder
$ mkdir my-django-project
$ cd my-django-project
Inside the directory, we will generate the core of our project using django-admin tool :
$ django-admin startproject config .
Note: Take into account that . at the end of the command.
Create the database and the app tables
$ python manage.py makemigrations
$ python manage.py migrate
Start the application
$ python manage.py runserver
$
$ # Access the web app in browser: http://127.0.0.1:8000/
At this point we should see the default Django page in the browser:
Django - Default Project Page.

Create New Application

In the previous section, we've generated the core of the project that handles the configuration and now we will create the first Django application to serve a simple page to the users.
$ python manage.py startapp app
Add a new route - edit app/views.py
from django.shortcuts import render
from django.http import HttpResponse # <-- NEW
​
def hello(request): # <-- NEW
return HttpResponse("Hello Django") # <-- NEW
The next step is to inform Django that we've created a new app and update the routing to include the new definition.
Update the configuration to include the new app - core/settings.py
# File: config/settings.py (partial content)
...
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'app' # <-- NEW
]
...
Update the routing rules as below - core/urls.py
# File: config/urls.py (partial content)
...
from django.contrib import admin
from django.urls import path
from django.conf.urls import include, url # <-- NEW
from app.views import hello # <-- NEW
​
urlpatterns = [
path('admin/', admin.site.urls),
url('', hello), # <-- NEW
]
After saving all changes we should no longer see the Django default page (the one with the green rocket):
Django For Beginners - The first page.

Create New Model

Even simple applications require minimal storage for persistent data. Django provides out-of-the-box an SQLite database, just to help us start fast. During this section, we will create and interact with a new table (model).
Visualize the default SQL settings - config/settings.py
# File: config/settings.py (partial content)
...
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
...
The ENGINE specify the technology used to manage the database. In our case is a lightweight (yet powerful) SQLite engine. NAME informs Django where to save the database on the filesystem.
Define a new model Books in sample application. The below changes should be added to sample/models.py:
# File: sample/models.py
​
from django.db import models
​
class Book(models.Model): # <- NEW
title = models.CharField(max_length=100) # <- NEW
author = models.CharField(max_length=100) # <- NEW
publication_date = models.DateField() # <- NEW
Tip - for a quick check over the latest changes we can run check subcommand.
$ python manage.py check
System check identified no issues (0 silenced).
Generate the SQL code (migrate the database).
$ python manage.py makemigrations # generate the SQL code
Migrations for 'sample':
sample\migrations\0001_initial.py
- Create model Book
Apply changes on the database
$ python manage.py migrate
Operations to perform:
Apply all migrations: admin, auth, contenttypes, sample, sessions
Running migrations:
Applying sample.0001_initial... OK
Use the model via CLI
Once the model is created we can use it via the Django shell:
$ python manage.py shell
>>>
>>> from sample.models import Book # import the Book model in our context
>>> from django.utils import timezone # used to provide the value for publication_date
>>>
>>> book1 = Book(title='The Adventures of Tom Sawyer', author='Mark Twain', publication_date=timezone.now() )
>>> book1.save() # save the new book
​
List all items (books) (using the CLI)
$ python manage.py shell
>>>
>>> from sample.models import Book
>>> Book.objects.all()
<QuerySet [<Book: Book object (1)>]>
We can see our new book returned by the query. Let's improve the information that describes the object.
Django Model - add text representation of an object
To achieve this goal, we should define the __str__() method for the Book model
# File: sample/models.py
​
from django.db import models
​
class Book(models.Model):
title = models.CharField(max_length=100)
author = models.CharField(max_length=100)
publication_date = models.DateField()
​
def __str__(self): # <- NEW
return self.title # <- NEW
​
Let's restart the Django console and check the results:
$ python manage.py shell
>>>
>>> from sample.models import Book
>>> Book.objects.all()
<QuerySet [<Book: The Adventures of Tom Sawyer>]>
​

​

Using Admin Section

Django comes by default with a usable admin dashboard that allows us to manage all app models and users with ease. In order to access the module, a superuser should be created using the Django CLI:
Create Django Superuser
$ python manage.py createsuperuser
sername (leave blank to use 'test'): admin
Email address: [email protected].us
Password: ********
Password (again): ********
Superuser created successfully.
Django Admin - Default View.
CRUD (create, read, update, delete) actions are provided for all default models (users, groups) shipped by Django. To register the new models, Books in our case, we need just a few lines of code.
Register Book model to be visible in the admin section
# File: sample/admin.py
​
from django.contrib import admin
​
from .models import Book # <- NEW
​
admin.site.register(Book) # <- NEW
After this small change in our code, we should see Books model listed in the admin page:
Django Admin - Register Books Model.
Django Admin - Edit Book Items
Django Admin - Edit Book Item.
​
Thanks for reading! For more topics, feel free to contact Appseed.
​

Resources