Learning Django. Part One: Building a Blog Application

In this blog post we will go throughthe general overview of the Django framework. We will walk through the different major components used for creating a fully functional web application. We will cover the concepts of models, templates, views, and URLs. You will learn how Django works and how its different components interact.

You will also learn the difference between Django projects and applications, and you will learn about the most important Django settings.

To put these concepts and help you understand them in a practical manner, we will build a simple blog application that allows users to navigate through all published posts and read individual posts. We will also create a simple administration interface to manage and publish posts. This blog post will be your roadmap for constructing a fully functional Django application

Table of Contents

1. Installing Python
2. Creating a Python virtual environment
3. Installing Django
4. Creating and configuring a Django project
5. Building a Django application
6. Designing data models
7. Creating and applying model migrations
8. Setting up an administration site for your models
9. Working with QuerySets and model managers
10. Building views, templates, and URLs
11. Understanding the Django request/response cycle

1.Installing Python

As stated, Django is a python web framework, and runs on python. For us to work with Django, we will need to have Python installed on our working machines. Also, As stated, we will be working with Django 5. Django 5 works with python 3.10, 3.11,and above.

If you’re using Linux or macOS, you probably have Python installed. If you’re using Windows, you can download a Python installer from the python.org website. You can download Python for your OS from https://www.python.org/downloads

Download it for the operating system you are using, and then follow the installation guides that are provided with the installation package. Once done, verify that it is installed. On windows, use this command

If it is installed, correctly, you should see results as seen in the results above, although you may have a different version depending on when you are reading this.

2. Creating a Python virtual environment

When working with python, python language, that we just installed, comes with its own standard library. The packages we use, mostly, like django, are third party libraries, that depend on python, but may also require other packages to run properly. There are scenarios where some of these libraries use same libraries that our installed python language library has, but with different versions. Installing these on the global space(system wide) could cause these libraries to overwrite the standard library modules, and cause some application dependent on them to break. For this, we normally create a virtual environment, that mirrors the python but allows the installation of other packages without conflicting or ovewriting the standard library.

There are a number of ways we can create virtual environment in python, but since version 3.3, Python comes with the venv library, which provides support for creating lightweight

virtual environments and we will be using it to create ours in this series.

On windows, to create a virtual environment, use the command below. But before that, create a separate folder on your system where you will have this project.

Here the first two commands are for creating my working directory and navigating into the newly created directory, the django_blog. Then the third one is for creating the virtual environment, in which py -m venv is a command, and the last venv is the actual virtual environment we are creating.

3. Installing Django

As stated, django is a python package, and like other languages python comes with its own package libraries hosted online, and installed using a python package manager called 'pip', which works similar to how 'npm' for node modules, if you are from that world, or if you have worked with frameworks like React and others. We will use pip to install django, and all the other modules that we need to use in the project as we progress.

Activate the Virtual Environment

In order to make sure that our packages are installed in an isolated virtual environment we just created, we need to activate it. To do that use the command below

Installing Django

In order to install django in the activated virtua; environment, enter the command below

The pip install django command installs django with all its basic dependecies as you can see in the screen above. If you want to know what these depencies and libraries that django uses are, you can use the command below to see them in a list format

I switched to a mackBook pc, and here is a set of commands that I used to achive the same

When I just started learning Django, I was very curious and I had to make a google search for each of these libraries and read abit about each of them to understand what they each do, and gain an indepth into the understanding of the Django framework which turned out to be very usefull down the line..its up to you to take up some time and understand them. For now, lets proceed.

4. Creating and Configuring a Django Project

Before we can proceed, lets take a step back and have some Concepts and abit of Django Phylosophy out of our way. I will just take a screenshot of what the django documentation says what the django phylosophy is

Django is a framework consisting of a set of components that solve common web development problems.Django components are loosely coupled, which means they can be managed independently. This helps separate the responsibilities of the different layers of the framework; the database layer knows nothing about how the data is displayed, the template system knows nothing about web requests, and so on.

Django offers maximum code reusability by following the DRY (don’t repeat yourself) principle. Django

also fosters rapid development and allows you to use less code by taking advantage of Python’s

dynamic capabilities, such as introspection.

The Main components of Django

Django follows the MTV (Model-Template-View) pattern. It is a slightly similar pattern to the wellknown MVC (Model-View-Controller) pattern, where the template acts as the view and the framework itself acts as the controller. The responsibilities in the Django MTV pattern are divided as follows:

• Model: This defines the logical data structure and is the data handler between the database and the view.
• Template: This is the presentation layer. Django uses a plain-text template system that keeps everything that the browser renders.
• View: This communicates with the database via the model and transfers the data to the template for viewing.

The framework itself acts as the controller. It sends a request to the appropriate view, according to the Django URL configuration. When developing any Django project, you will always work with models, views, templates, and URLs.

The Django architecture

Now, thats an overview of the framework, but how does one use that, or how does Django translate that into code blocks that one can use and build applications?

When developing any Django project, you will always work with models, views, templates, and URLs.

As a web framework, and that it uses the HTTP PROTOCOL, Django like other http based applications, takes in requests, and generates responses to these requests. And this is what makes Django streamline and make the development of web services using Python such a breez. Here is a summarised flow of how Django handles HTTP requests and generates responses:

1. A web browser requests a page by its URL and the web server passes the HTTP request to Django.
   
2. Django runs through its configured URL patterns and stops at the first one that matches the requested URL.
   
3. Django executes the view that corresponds to the matched URL pattern.
   
4. The view potentially uses data models to retrieve information from the database.
   
5. Data models provide data definitions and behaviors. They are used to query the database.
   
6. The view renders a template (usually HTML) to display the data and returns it with an HTTP response.
   

We will get back to the Django request/response cycle at the end of this chapter in the The request/ response cycle section.

Django 5 New features

As stated, this blog series will be focusing on among other things, the new features added to Django, up to the most recent , in Django 5. Ofcourse, the principles taught in this can be used in other previous versions, except for the specific features that are new(obviously you wont get them in older versions).

It is also important to note that this version also deprecates certain features and eliminates previously deprecated functionalities.

Here is a list of features you should expect in the Django 5:

• Facet filters in the administration site: Facet filters can be added now to the administration site. When enabled, facet counts are displayed for applied filters in the admin object list.
  
• Simplified templates for form field rendering: Form field rendering has been simplified with the capability to define field groups with associated templates. This aims to make the process of rendering related elements of a Django form field, such as labels, widgets, help text, and errors, more streamlined.
  
• Database-computed default values: Django adds database-computed default values.

• Database-generated model fields: This is a new type of field that enables you to create data- base-generated columns. An expression is used to automatically set the field value each time the model is changed. The field value is set using the GENERATED ALWAYS SQL syntax.
  
• More options for declaring model field choices: Fields that support choices no longer require accessing the .choices attribute to access enumeration types. A mapping or callable instead of an iterable can be used directly to expand enumeration types.
  
  

Django 5.0 drops support for Python 3.8 and 3.9.
You can check out the list of features added, improved, and removed from the officail django documentation at this link:
https://docs.djangoproject.com/en/5.2/releases/5.0/

5. Creating your first project

Now that we have an understanding of what and how Django works, lets create our first django project and have a first hand experience of how these lego blocks fit tigether, and puts Python into usable web engine.

Like any other mature framework, Django comes packed with utility commands for managing the aspects of creating and managing development tasks. To create a project, django offers the createproject utility and here is how we create our blog project

In the commands above, am activating the virtual environment named venv, then, we are creating a django project named blog_project. Then we are navigating into the created project directory.After that we are running the project. Now, lets launch the project in the browser by entering the url http://127.0.0.1:8000/ provided in the console.

Our project has been created, and thats the default project template. But what files are provided out of the box for us. Iam using maOS so I will run the command below to display the project files

In a graphical tree diagram interface, here is how we can represent this

The outer mysite/ directory is the container for our project. It contains the following files:

• manage.py: This is a command-line utility used to interact with your project. You won’t usually
  need to edit this file.
  
• mysite/: This is the Python package for your project, which consists of the following files:
  
• __init__.py: An empty file that tells Python to treat the mysite directory as a Python module.
• asgi.py: This is the configuration to run your project as an ASGI application with ASGI-compatible web servers. ASGI is the emerging Python standard for asynchronous web servers and applications.
• settings.py: This indicates settings and configuration for your project and contains initial default settings.
• urls.py: This is the place where your URL patterns live. Each URL defined here is mapped to a view.
• wsgi.py: This is the configuration to run your project as a Web Server Gateway Inter- face (WSGI) application with WSGI-compatible web servers.

With this, we now have enough going to start from and build the blog application in the next post. Otherwise, this might turn out into a book itself. All I can encourage you is to go read through, rvise it, and gothrough the process of creating the django project, take a look at its files, and gain an eindepth understanding of how it works.