Python and Django: Building a Blogging Platform

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setting up Django
  4. Creating a Django Project
  5. Creating a Django App
  6. Creating Models
  7. Creating Views
  8. Creating Templates
  9. URL Mapping
  10. Conclusion

Introduction

In this tutorial, we will learn how to build a blogging platform using Python and Django. Django is a high-level web framework that allows us to quickly develop web applications. By the end of this tutorial, you will be able to create a fully functional blogging platform where users can create, read, update, and delete blog posts.

Prerequisites

Before starting this tutorial, you should have a basic understanding of Python programming language and the concepts of web development. It is also recommended to have Python installed on your system. You can download and install Python from the official Python website (https://www.python.org/downloads/).

Setting up Django

  1. Open your command line or terminal.
  2. Install Django by running the following command: 
     pip install django
  3. Verify that Django is successfully installed by running the following command: 
     django-admin --version

    Creating a Django Project

  4. Create a new directory for your project and navigate into it: 
     mkdir blogging-platform
 cd blogging-platform
  5. Create a new Django project by running the following command: 
     django-admin startproject myblog .
  6. Verify that the project is set up correctly by running the development server: 
     python manage.py runserver
  7. Open your web browser and visit http://localhost:8000/. You should see the Django default welcome page.

Creating a Django App

  1. In the terminal, navigate to the project directory: 
     cd myblog
  2. Create a new Django app: 
     python manage.py startapp blog
  3. Register the app in the Django settings. Open the settings.py file located in myblog/myblog folder and add 'blog' to the INSTALLED_APPS list. 
     INSTALLED_APPS = [
     ...
     'blog',
 ]

    Creating Models

  4. Open the models.py file located in the blog app folder. 
     cd blog

     touch models.py
  5. Inside the models.py file, define the Post model. The Post model will represent a blog post and will have fields such as title, content, author, and date_created. 
     from django.db import models
 from django.contrib.auth.models import User
	
 class Post(models.Model):
     title = models.CharField(max_length=100)
     content = models.TextField()
     author = models.ForeignKey(User, on_delete=models.CASCADE)
     date_created = models.DateTimeField(auto_now_add=True)
	
     def __str__(self):
         return self.title
  6. Create the initial database migration for the models: 
     python manage.py makemigrations
 python manage.py migrate

    Creating Views

  7. Open the views.py file located in the blog app folder. 
     touch views.py
  8. Inside the views.py file, add the following code to define the views for creating, reading, updating, and deleting blog posts. 
     from django.shortcuts import render, get_object_or_404, redirect
 from .models import Post
 from .forms import PostForm
	
 def post_list(request):
     posts = Post.objects.all()
     return render(request, 'blog/post_list.html', {'posts': posts})
	
 def post_detail(request, pk):
     post = get_object_or_404(Post, pk=pk)
     return render(request, 'blog/post_detail.html', {'post': post})
	
 def post_create(request):
     if request.method == 'POST':
         form = PostForm(request.POST)
         if form.is_valid():
             post = form.save(commit=False)
             post.author = request.user
             post.save()
             return redirect('post_detail', pk=post.pk)
     else:
         form = PostForm()
     return render(request, 'blog/post_create.html', {'form': form})
	
 def post_edit(request, pk):
     post = get_object_or_404(Post, pk=pk)
     if request.method == 'POST':
         form = PostForm(request.POST, instance=post)
         if form.is_valid():
             post = form.save(commit=False)
             post.author = request.user
             post.save()
             return redirect('post_detail', pk=post.pk)
     else:
         form = PostForm(instance=post)
     return render(request, 'blog/post_edit.html', {'form': form})
	
 def post_delete(request, pk):
     post = get_object_or_404(Post, pk=pk)
     post.delete()
     return redirect('post_list')

    Creating Templates

  9. Create a new folder called templates in the blog app folder. 
     mkdir templates
  10. Inside the templates folder, create the following HTML templates:
  • post_list.html: This template will display a list of all blog posts. 
    	
  {% for post in posts %}
      <h2><a href="{% url 'post_detail' pk=post.pk %}">{{ post.title }}</a></h2>
      <p>{{ post.content }}</p>
      <p>Author: {{ post.author }}</p>
      <hr>
  {% empty %}
      <p>No posts found.</p>
  {% endfor %}
  • post_detail.html: This template will display the details of a specific blog post. 
    	
  <h2>{{ post.title }}</h2>
  <p>{{ post.content }}</p>
  <p>Author: {{ post.author }}</p>
  <p>Date Created: {{ post.date_created }}</p>
  • post_create.html: This template will display a form to create a new blog post. 
    	
  <form method="POST">
      {% csrf_token %}
      {{ form.as_p }}
      <button type="submit">Save</button>
  </form>
  • post_edit.html: This template will display a form to edit an existing blog post. 
    	
  <form method="POST">
      {% csrf_token %}
      {{ form.as_p }}
      <button type="submit">Save</button>
  </form>
	

      3. Open the `settings.py` file located in the `myblog/myblog` folder and add the following code to configure the templates directory.   ```python   TEMPLATES = [
  {
      ...
      'DIRS': [os.path.join(BASE_DIR, 'blog', 'templates')],
      ...
  },   ]   ``` ## URL Mapping
  1. Open the urls.py file located in the myblog folder. 
     cd ..

     touch urls.py
  2. Inside the urls.py file, add the following code to define the URL patterns. 
     from django.urls import path
 from blog import views
	
 urlpatterns = [
     path('', views.post_list, name='post_list'),
     path('post/<int:pk>/', views.post_detail, name='post_detail'),
     path('post/new/', views.post_create, name='post_create'),
     path('post/<int:pk>/edit/', views.post_edit, name='post_edit'),
     path('post/<int:pk>/delete/', views.post_delete, name='post_delete'),
 ]

    Conclusion

Congratulations! You have successfully built a blogging platform using Python and Django. In this tutorial, we covered the basics of Django, including creating a project, creating an app, defining models, creating views, and configuring URL mappings. You can now further enhance your blogging platform by adding additional features such as user authentication, comments, and categories.

Remember, this is just the beginning of your Django journey. Django offers many more powerful features and functionalities, so keep exploring and building amazing web applications!

If you have any questions or get stuck, don’t hesitate to refer to the Django documentation or ask for help in online communities. Happy coding!

Published:

Related Articles