Eli
Let’s learn by example.
In this tutorial, we’ll walk you through the creation of a basic blog application. This is a self-paced, standalone Django tutorial intended to make you take-off within no time.
We will use Django 2.1, which supports Python 3.5 and later. If you want to use a different version of Django, go to Python Django post and find out Django and Python versions compatibility. Please, make sure to install the version of Django that supports Python 3 version you want to use with or update both Django and Python 3 to the newest versions. Don't worry, we will show you how to install Django and use it with a specific Python version in a meanwhile.
What is Django?
Python Django is a high-level Python web framework "for perfectionists with deadlines" that encourages rapid development and clean, pragmatic web design. Built by experienced developers, Django comes with batteries included.
Django Features
- Django is a high level Python web framework – meaning that it takes care of much of the hassle of web development, so you can focus on writing your application without needing to reinvent the wheel.
- Django is ridiculously fast - meaning that it is designed to help developers take applications from concept to completion as quickly as possible.
- Django is reassuringly secure as it takes security very seriously.
- Django is full featured and full loaded – Django core has tons of inbuilt functionalities.
- Django is exceedingly scalable.
- Django is versatile – it can be adapted to build a wide range of applications.
- Django is free and open source.
- Django web framework is heavily influenced by the model-view-template (MTV) design pattern, although not true MTV, but Django assumes to follow it:
- Model
This is the data access layer that has to do with interacting, relating and validation of data. - Template
This is a presentation layer (presentation related decisions) that takes care of the way information is displayed on the web. - View
This is a business logic layer, it accesses the model and displays the appropriate template. View acts as a bridge between the model and template.
- Model
- Django forces you to do things the “Django way”, usually in the easiest and the best way possible. Although it seems to give less freedom, Django makes you develop secure, scalable, performant apps with no or with little chance of messing up your application.
- Django and/or Python has been used to build some of the largest, busiest and famous sites; also apps and systems that we know, such as Playstore , Youtube, Pinterest, Ubuntu, Debian, RedHat, Instagram, NASA website, Pinterest, Onion, Disqus, Bitbucket, Firefox Help site, and Washington Post, just to mention a few.
- Django uses the concept of apps. Django project/website can be designed as a single app, or a project within which (includes) there can be several/multiple applications, such as blog app, client app and store app. You can as well move, reuse apps or take other people’s apps and integrate them to build your own project. The paradigm to developing Django apps is very flexible, scalable, and reusable.
The best and recommended way to use Django is through Python virtual environments (virtualenv). This is the cleaner way of creating and managing projects by using isolated environments with their own directories and specific requirements; virtualenv keeps project instances separate.
Let’s create a Python virtual environment called “Django_Project” for our project.
Python Virtualenv and Requirements installation
For this tutorial, we will use Python 3.6.5 and Django 2.1. If your system runs at least Python 3.4, you will just be fine, otherwise you will need to install or upgrade to at least Python 3.4 by compiling from the source or through Anaconda distribution, I recommend installing using anaconda.
If you are upgrading your installation of Django to version 2.1 or later from a previous version, you will need to uninstall the old Django version before installing the new version, unless stated otherwise, see this post. We show below how to install and check the packages we need for Django project development.
Open the command line:
$Ctrl + Alt + T
Check if the required version of Python is installed correctly:
$ python --version
Also check pip (pyhton package manager):
$pip –version
If pip is not installed in your system, please go here and install it.
Install the virtualenv (if not installed):
$pip install virtualenv
or Install the virtuenvironment wrapper:
$pip install virtualenvwrapper
if using Mac OS X, Linux-Based OS
or
$pip install virtualenvwrapper-win
for windows.
Make directory to keep all your separate environments in one place:
$mkdir Environments
Move to the directory Environments and create virtualenv for Django project:
$virtualenv Django_Project
If you have multiple virtualenv, you can switch/activate between them:
$workon name_of_virtualenv
if using virtualenv with virtualenvwrapper,
and
$source name_of_virtualenv/bin/activate
or
$. name_of_virtualenv/bin/activate
if using virtualenv with virtualenvwrapper.
Install Django version 2.1 to use with Python 3.6:
$pip3 install django==2.1
This installs django 2.1 globally.
You can check if Django is installed and which version by running the following command in a shell prompt:
$django-admin --version
Or by typing the following in a Python/Ipython interpreter (load an interpreter by typing python/ipython in a shell prompt):
>>> from django import get_version
>>> get_version()
If Django is installed, you should see the version of your installation. If it isn’t, you’ll get an error telling “No module named django”.
Make sure the version of Python you're using is compatible with Django version. Check within the virtualenv which Python version you are using by typing:
$which python
You should see a Python path like this:
/home/user/Environments/Django_Project/bin/python
If the python requirement is not satisfied, you can specify a version of Python you want for a particular virtual environment project. Suppose we want to use anaconda Python 3.6 inside the virtualenv Django_Project:
$virtualenv -p /home/user/anaconda/bin/python
If you are alredy using Python from Anaconda, you’ll see:
Already using interpreter /home/user/anaconda/bin/python
Using base prefix '/home/user/anaconda'
New python executable in /home/user/Environments/Django_Project/bin/python
Installing setuptools, pip, wheel...done.
Creating Django Project
If this is your first time using Django, you’ll have to take care of some initial setup. Namely, you’ll need to auto-generate some code that establishes a Django project – a collection of settings for an instance of Django, including database configuration, Django-specific options and application-specific settings.
It’s not a good idea to put any of this Python code within your Web server’s document root (/var/www), just as is the case with PHP, because it risks the possibility that people may be able to view your code over the Web. Put your code in some directory outside of the document root. In our case, our project will be hosted inside “djangoproject” folder created within the directory Environments under a Python virtualenv Django_Project.
Move to the directory Environments, create virtualenv named Django_Project and activate it:
$cd Environments
$virtualenv Django_Project
$. Django_Project/bin/activate
Install Django 2.1 to use with Python3 on the virtualenv Django_Project:
- pip3 install django==2.1
See here how you could specify during creation of virtualenv the Python version to use with a particular virtualenv, or call a particular version of Python to use within the virtualenv.
Generate an application named djangoproject using utility django-admin:
- $django-admin startprojet djangoproject
You can check which directories are contained in by:
- $dir
You should at least see the directories named Django_Project, djangoproject.
startproject will create a djangoproject directory in our current directory, Environments. The created djangoproject directory is structured as follows:
- djangoproject/
- manage.py
- djangoproject/
- __init__.py
- settings.py
- urls.py
- wsgi.py
These files are:
- The outer djangoproject/ directory is a container for the project. Its name doesn’t matter to Django; we can rename it to anything we like.
- manage.py: is the command line interface (CLI) utility/client that lets you interact with this djangoproject in various ways. It is basically a wrapper of django-admin that we use to create applications. Manage.py is the same thing as django-admin except it is localized to specific projects.
- The inner djangoproject/ directory is the actual Python Django package for your project. This is the Python package name you’ll need to use to import anything inside it (e.g., djangoproject.urls).
- djangoproject/__init__.py: An empty file that tells Python that this directory should be treated as a Python package, it does with filenames and modules.
- djangoproject/settings.py: Contains all settings/configurations for this Django project: Here there are few things to note:
- SECRET_KEY=" ", is a string, used in production, it must be kept secret, don't include it, for example if you push your code to Github.
- DEBUG=True, don't run with DEBUG turned on in production, it is only useful during development stage, since it gives us useful information and messages related to bugs, warnings and errors.
- ALLOWED_HOSTS = [], lists application domain names allowed during deployment.
- INSTALLED_APPS = [], array of apps included in an application.
- MIDDLEWARE = [], array of apps responsible for functions such as security and authentication. The order of middleware is important.
- settings.py also includes arrays/definitions of databases and and templates.
- djangoproject/urls.py: The URL declarations for setting up urls routing and patterns, a table of contents of your Django-powered site.
- djangoproject/wsgi.py: An entry-point for WSGI-compatible web servers to serve your project. This is the primary development platform for Django, stands for webservers and applications.
Note that, you’ll need to avoid naming projects with similar names to Python or Django components. In particular, this means you should avoid using names like django (which will conflict with Django itself) or test (which conflicts with a built-in Python package).
Running the Web Server
Right now, we will use a default database "sqlite3" although this is not a great database for production. In a meanwhile, we will replace sqlite3 with MySQL.
To run server, we need to move to the outer djangoproject directory and execute the following in the Terminal:
- $python manage.py runserver
You should see a message similar to:
- Performing system checks...
- System check identified no issues (0 silenced).
- You have 15 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
- Run 'python manage.py migrate' to apply them.
- December 24, 2018 - 11:20:54
- Django version 2.1, using settings 'djangoproject.settings'
- Starting development server at http://127.0.0.1:8000/
- Quit the server with CONTROL-C.
The message "You have 15 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them."
is displayed because we have not yet applied migrations (not added them to our database). Migrations are files that will perform certain actions to our database, such as creating/writing tables and adding data.
This will run the web server on our localhost at port 8000: http://127.0.0.1:8000/. If we visit this address, we will see a page similar to:
We have not applied migrations yet, if we apply them now they will go to sqlite3 database, we will apply them after switching to MySQL database.
Using MySQL Database with Django Web Framework
To be able to use Django web framework with MySQL database, we will need to install a mysqlclient in our Django_Project virtualenv
- pip install mysqlclient
and then we will also need to create a database.
I you know how to use SQL, you can use the MySQL shell prompt to create databases, but here, we will use PHPMyAdmin - a web application which was created to give users Graphical Interface for handling the MySQL tasks.
So go ahead and install MySQL via the LAMP Stack and then install PHPMyAdmin.
Next, let's navigate to http://localhost/phpmyadmin/ (we will see an interface like this:)
and create a database named "djangoproject".
We will login using the username "root" and administrator's password (the same password you used for MySQL) prompted by
$ mysql -u root -p
After login in, you will be presented with phpMyAdmin interface that looks like:
We can now create a database named djangoproject by using phpMyAdmin facility, by just entering the database name below "create database" and click create next to "collation" as shown in the screenshot above. Our djangoproject database then looks like:
We haven't created tables yet, we will create them by applying migrations using manage.py migrate.
We want to use MySQL database with Django, for that to be possible, let's open /home/user/Environments/djangoproject/djangoproject/settings.py, find
- DATABASES = {
- 'default': {
- 'ENGINE': 'django.db.backends.sqlite3',
- 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
- }
- }
and comment, then put to the next or replace with:
- DATABASES = {
- 'default':{
- 'ENGINE': 'django.db.backends.mysql',
- 'NAME': 'djangoproject',
- 'USER': 'root',
- 'PASSWORD': 'root_password',
- 'HOST': 'localhost',
- 'PORT': ''
- }
- }
Now, let's apply the 15 migrations to our database "djangoproject":
- python manage.py migrate
After applying migrations successfully, a lot of items/tables will be added to our database, as shown below:
Again, let's start the web server:
$python manage.py runserver
This time there is no warning about 15 unapplied migrations, we have already applied them to our database.
Django Backend Administration
After restarting the web server, we can got http://127.0.0.1:8000/admin/ and access the Django back end admin interface:
Creating A SuperUser
There is no user created yet to log in under Django Administration interface, let's create a superuser:
- $python manage.py createsuperuser --username=eli --email=ey@tssfl.com
- Password: Dm[!2W`e]3bM:g}V
- Password (again): Dm[!2W`e]3bM:g}V
- Superuser created successfully.
After restarting the web server and reloading the page http://127.0.0.1:8000/admin/, we can log in as superuser and see the full Django Administration back end:
A superuser can perform an overwhelming amount of tasks, such as adding users/groups, and a lot other functions.
Creating A Posts Application
Django uses the concept of apps. Django project can be designed as a single app, or a project within which there can be multiple applications. Let's now create a posts app:
- $python manage.py startapp posts
The posts directory is structured as follows:
- djangoproject/
- posts/
- admin.py
- apps.py
- __init__.py
- migrations
- models.py
- __pycache__
- templates
- tests.py
- urls.py #We created this file
- views.py
"migrations" and "templates" are directories within the posts directory.
Before using the posts as an app, we need to add it in the list of apps at /home/user/Environments/djangoproject/djangoproject/settings.py
- INSTALLED_APPS = [
- 'posts',
- 'django.contrib.admin',
- 'django.contrib.auth',
- 'django.contrib.contenttypes',
- 'django.contrib.sessions',
- 'django.contrib.messages',
- 'django.contrib.staticfiles',
- ]
Next, we go to /home/user/Environments/djangoproject/djangoproject/urls.py and set urls routing.
Firstly, we need to import modules/libraries as follows:
- from django.contrib import admin
- from django.urls import path
- from django.conf.urls import url, include
and then add url(r'^posts/', include('posts.urls')) to urlpatterns = [ ] to have
- urlpatterns = [
- url(r'^admin/', admin.site.urls),
- url(r'^posts/', include('posts.urls')),
- ]
r'^posts/', means anything that goes to posts/ is parsed to urls.py file inside the posts app.
NB:
Below are examples on how to import functions/methods/modules/libraries and set/configure url patterns/routes (see more: URL dispatcher):
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
Let's open the file /home/user/Environments/djangoproject/posts/urls.py we created and add the following in it:
- from django.conf.urls import url
- from . import views
- #Let's set our first url route/pattern
- urlpatterns = [
- url(r'^$', views.index, name='index')
- ];
"^" means start with, and "$" means end with ....
Let's open /home/user/Environments/djangoproject/posts/views.py and add
- from django.http import HttpResponse
- # Create your views here.
- def index(request):
- return HttpResponse('Hello World From Posts!')
If we restart a server: $python manage.py runserver, and go to http://127.0.0.1:8000/posts/ we should see
- posts.png (11.02 KiB) Viewed 3857 times
- posts.png (11.02 KiB) Viewed 3857 times
Rendering a Template
Let's modify /home/user/Environments/djangoproject/posts/views.py, to return/render a template called index.html instead of HttpResponse.
We move inside the posts directory and create files /home/user/Environments/djangoproject/posts/templates/posts/index.html and
/home/user/Environments/djangoproject/posts/templates/posts/layout.html
Open the layout.html to include the following contents (we use Jinja templating), including materialized css
- <!DOCTYPE html>
- <html lang="en">
- <head>
- <meta charset="UTF-8">
- <meta name="viewport" content="width=device-width, initial-scale=1.0">
- <meta http-equiv="X-UA-Compatible"
- content="ie=edge">
- <!-- Compiled and minified CSS -->
- <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0-rc.2/css/materialize.css">
- <title>TSSFL Open Discussion Forums</title>
- </head>
- <body>
- <header class="container center-align">
- <h1>TSSFL Open Discussion Forums</h1>
- </header>
- <div class="container">
- {% block content %}
- {% endblock %}
- </div>
- </body>
- </html>
We then extend .../posts/templates/posts/layout.html using .../posts/templates/posts/index.html; open
index.html and include the following contents:
- {% extends "posts/layout.html" %}
- {% block content %}
- <h3 class="center-align red lighten-3">{{title}}</h3>
- {% endblock %}
Now, we can render index.html using /home/user/Environments/djangoproject/posts/views.py as follows:
- from django.shortcuts import render
- # Create your views here.
- def index(request):
- return render(request, "posts/index.html",
- {'title': "Latest Posts" })
Registering Models and Creating Posts
Let's go to /home/user/Environments/djangoproject/posts/models.py, create a Class Posts, pass in it models.Model and add some contents:
- from django.db import models
- from datetime import datetime
- # Create your models here.
- class Posts(models.Model):
- title=models.CharField(max_length=250)
- body=models.TextField()
- created_at=models.DateTimeField(default=datetime.now, blank=True)
We then create migrations based on this model - we want to create database tables that can hold up posts. To do so, we first create a migrations file:
- $python manage.py makemigrations posts
This will create a file named posts/migrations/0001_initial.py with contents:
- # Generated by Django 2.1 on 2018-12-29 15:13
- import datetime
- from django.db import migrations, models
- class Migration(migrations.Migration):
- initial = True
- dependencies = [
- ]
- operations = [
- migrations.CreateModel(
- name='Posts',
- fields=[
- ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
- ('title', models.CharField(max_length=250)),
- ('body', models.TextField()),
- ('created_at', models.DateTimeField(blank=True, default=datetime.datetime.now)),
- ],
- ),
- ]
Next, we create database table related to this model:
- $python manage.py migrate
If we visit phpMyAdmin, we will see a table named posts_posts has been added to djangoproject database:
Its structure looks like:
Let's add the contents
<br>
<a style = "display:block" class="center-align" href="/admin"> Admin Login</a>
after {% endblock %} in /home/user/Environments/djangoproject/posts/templates/posts/layout.html
If we reload http://127.0.0.1:8000/posts/, we see that we have created an Admin Login link; when we log in with the superuser credentials we created, that will take us to the former Django Admin back end with no posts created yet:
Let's open /home/user/Environments/djangoproject/posts/admin.py and register our models. We add inside this file:
- from django.contrib import admin
- # Register your models here.
- from .models import Posts
- admin.site.register(Posts)
We open the file /home/user/Environments/djangoproject/posts/models.py and modify it to have:
- from django.db import models
- from datetime import datetime
- # Create your models here.
- class Posts(models.Model):
- title=models.CharField(max_length=250)
- body=models.TextField()
- created_at=models.DateTimeField(default=datetime.now, blank=True)
- def __str__(self):
- return self.title
- class Meta:
- verbose_name_plural = "Posts"
If we restart a web server and reload http://127.0.0.1:8000/admin/ we have a post interface:
We can then create, save/edit/modify posts:
After creating a second post:
Showing Blog Posts
We want to make our posts appear as blog posts at http://127.0.0.1:8000/posts/.
Let's open /home/user/Environments/djangoproject/djangoproject/urls.py and modify it contents to look as
- from django.contrib import admin
- from django.urls import path
- from django.conf.urls import url, include
- urlpatterns = [
- url(r'^$', include('posts.urls')),
- url(r'^admin/', admin.site.urls),
- url(r'^posts/', include('posts.urls')),
- ]
This will enable us to see the Blog interface at http://127.0.0.1:8000/. Let's bring in the posts from the model by modifying the contents of /home/user/Environments/djangoproject/posts/views.py to look as:
- from django.shortcuts import render
- from django.http import HttpResponse
- from .models import Posts
- # Create your views here.
- def index(request):
- #return HttpResponse('Hello World From Posts!')
- posts = Posts.objects.all()[:10] #Show the first 10 posts
- context = {
- 'title': 'Latest Posts',
- 'posts': posts
- }
- return render(request, "posts/index.html", context)
We loop through posts, modify the contents of /home/user/Environments/djangoproject/posts/templates/posts/index.html by adding after <h3 class="center-align red lighten-3">{{title}}</h3>:
- <ul class="collection">
- {% for posts in posts %}
- <li class="collection-item"><a href="/posts/details/{{posts.id}}">{{posts.title}}</a></li>
- {% endfor %}
- </ul>
to have
- {% extends "posts/layout.html" %}
- {% block content %}
- <h3 class="center-align red lighten-3">{{title}}</h3>
- <ul class="collection">
- {% for post in posts %}
- <li class="collection-item"><a href="/posts/details/{{posts.id}}">{{posts.title}}</a></li>
- {% endfor %}
- </ul>
- {% endblock %}
Modify the contents of /home/user/Environments/djangoproject/posts/urls.py to look like:
- from django.conf.urls import url
- from . import views
- urlpatterns = [
- url(r'^$', views.index, name='index'),
- url(r'^details/(?P<id>\d+)/$', views.details, name='details'),
- ];
Modify the contents of /home/user/Environments/djangoproject/posts/views.py by extending them through adding the function:
- def details(request, id):
- post = Posts.objects.get(id=id)
- context = {
- 'post': post
- }
- return render(request, "posts/details.html", context)
Create a file named /home/user/Environments/djangoproject/posts/templates/posts/details.html and add the following contents:
- {% extends "posts/layout.html" %}
- {% block content %}
- <h3 class="center-align red lighten-3">{{post.title}}</h3>
- <div class = "card">
- <div class = "card-content">
- {{post.body}}
- </div>
- <div class = "card-action">
- {{post.created_at}}
- </div>
- </div>
- <a href="/posts" class="btn">Previous Page</a>
- {% endblock %}
Finally, we can display posts in a blog-like style:
First post
Second post
References
Best Django Books 2018
