Getting Started with Django: Building a Blog App

Introduction
Prerequisites
Setup
Creating a Django Project
Creating a Django App
Defining Models
Creating Views
Setting Up URLs
Creating Templates
Adding Styling
Conclusion

Introduction

In this tutorial, we will walk through the process of building a simple blog application using Django. Django is a powerful web framework for Python that allows you to quickly develop web applications. By the end of this tutorial, you will have a working blog app with basic functionality, including creating, editing, and deleting blog posts.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of Python programming language and how to use pip to install packages. It’s recommended to have Python 3.x installed on your system.

Setup

Before we start building our blog app, we need to set up a virtual environment to isolate our project’s dependencies. A virtual environment ensures that the packages installed for this project do not interfere with other Python projects on your system.

Open your terminal or command prompt.
Create a new directory for your project and navigate to it.
Run the following command to create a virtual environment:
```
 python3 -m venv myenv
```
Replace myenv with the name you want to give to your virtual environment.
Activate the virtual environment:

On macOS and Linux: shell source myenv/bin/activate On Windows: shell myenv\Scripts\activate Now that we have our virtual environment set up, let’s proceed with setting up our Django project.

Creating a Django Project

Inside your project’s directory and with the virtual environment activated, run the following command to install Django:
```
 pip install django
```
After Django is installed, run the following command to create a new Django project:
```
 django-admin startproject myblog
```
Replace myblog with the name you want to give to your project.
Change to the newly created project directory:
```
 cd myblog
```
To verify that the project was set up correctly, run the following command:
```
 python manage.py runserver
```
You should see output similar to the following:
```
 Starting development server at http://127.0.0.1:8000/
 Quit the server with CONTROL-C.
```
This means that your Django project is running successfully. You can access it by opening http://127.0.0.1:8000/ in your web browser. Press CTRL + C in the terminal to stop the server.

Creating a Django App

Now that our project is set up, we can create a Django app to handle the blog functionality.

With the virtual environment activated and inside your project’s directory, run the following command:
```
 python manage.py startapp blog
```
This will create a new directory named blog as our Django app.
Open the settings.py file located in myblog/myblog and add 'blog' to the INSTALLED_APPS list:
```
 INSTALLED_APPS = [
     ...
     'blog',
 ]
```
We have now added our blog app to the Django project.

Defining Models

Models in Django are Python classes that represent database tables. We will define our blog post model first.

Open the models.py file inside the blog directory.

Replace the existing code with the following:

 from django.db import models
 from django.utils import timezone
	
 class Post(models.Model):
     title = models.CharField(max_length=200)
     content = models.TextField()
     pub_date = models.DateTimeField(default=timezone.now)
	
     def __str__(self):
         return self.title

In the above code, we define a Post model with fields for title, content, and pub_date. The pub_date field is set to the current time using timezone.now. The __str__ method is used to display the title of the post in the admin interface.

After defining the model, run the following command to create the corresponding database table:
```
 python manage.py makemigrations
 python manage.py migrate
```
Creating Views

Views in Django handle the logic for processing requests and generating responses. We will create views to display blog posts.

Open the views.py file inside the blog directory.

Replace the existing code with the following:

 from django.shortcuts import render
 from .models import Post
	
 def blog_home(request):
     posts = Post.objects.order_by('-pub_date')
     return render(request, 'blog/home.html', {'posts': posts})

In the above code, we import the Post model and retrieve all blog posts ordered by the pub_date. We then pass the posts queryset to the home.html template.

Setting Up URLs

URLs in Django map requests to specific views. We will set up URLs to handle requests for our blog app.

Open the urls.py file inside the myblog directory.
Replace the existing code with the following:
```
 from django.urls import include, path
 from . import views
	
 urlpatterns = [
     path('', views.blog_home, name='home'),
 ]
```
In the above code, we import the blog_home view and define a URL pattern for the homepage. This pattern maps the root path ('') to the blog_home view.

Creating Templates

Templates in Django are used to generate HTML dynamically. We will create a template to display our blog posts.

Create a new directory named templates inside the blog directory.
Inside the templates directory, create a new directory named blog.
Inside the blog directory, create a new file named home.html.
Open the home.html file and add the following code:
```
	
```
In the above code, we use template tags to iterate over the posts queryset and display the title, content, and publication date of each post.

Adding Styling

To make our blog app look better, we will add some basic styling using CSS.

Inside the static directory, create a new directory named css.
Inside the css directory, create a new file named style.css.

Open the style.css file and add the following CSS code:

 /* Define basic styling for the blog posts */
 h2 {
   color: blue;
 }
	
 p {
   font-size: 14px;
 }
	
 /* Customize the appearance of the blog app */
 body {
   background-color: lightgray;
 }

In the above code, we define some basic styling for the h2 and p elements. We also customize the background color of the entire page.

Conclusion

Congratulations! You have successfully built a blog app using Django. In this tutorial, we covered the process of creating a Django project, creating a Django app, defining models, creating views, setting up URLs, creating templates, and adding styling. You can now expand on this foundation to add more features to your blog app, such as user authentication, comments, and more.

Remember to practice and explore Django’s extensive documentation for more advanced topics and techniques. Happy coding!

Published: 5 November 2020