Learn how to create a step -by -step django blog (Part One)

​This tutorial is a detailed explanation of the creation of a blog using Django. This tutorial is written for beginners and is prepared from the point of view of beginners.

To do this tutorial, you must have installed the latest version of Python and VS Code Editor. We will do this tutorial on the Mac system, but the steps for Windows and Linux will not be much different. We will also use Tailwind CSS design and some other tools that I will cover during the tutorial.

Create a blog project using Django

To create a django blog, first create a folder for your project. Open a terminal (or command instructor in Windows) and run the following orders one by one:

pip install virtualenv
virtualenv env
source env/bin/activate # this command might be different on windows
pip install django
pip freeze > requirements.txt
django-admin startproject blogpost

Explain the basic orders in the previous code.

Virtualenv virtual environments are the Python insulated environments used to work in a variety of projects. As you can see, we first install PIPundefined Install Virtualenv, then we run the command Virtualenv and activate it (Source Env / ACTIVATE).

 Then we install the Django using the PIP Install Django command, using the PIP Freeze command,> Requirements.TXT.

 The last thing is Django-admin Startproject Blogpost. Create a DJANGO project with the specified name. I have named BlogPost.

Implementation of deportations in Django

 The implementation of deportations should become a familiar practice for you, but if you still do not know the reason for their implementation, in short, deportations are the way Django records the changes made on models.

 To implement the deportation in the tutorial to build the blog using Django, run the following orders at the terminal one by one:

python manage.py migrate

 You will now see a new file called DBSQLite3, which is the database. Inside the project.

 Then run this:

python manage.py runserver

 You should now be able to view the page uploaded to the title of http://127.0.0.1:8000. As in the picture  Next:

 Create applications in Django

 To create a new application, first stop the server by clicking on the CTRL + C keys from the keyboard, then run the next command at the terminal:

python manage.py startapp nameapp

 For example, I created my application as follows:

python manage.py startapp posts

 Once you do this, go to the Blogost folder and open the Settings.Py file. Pass down the page to reach the Installed_Apps section and add your application name to the list.

 As in the following code:

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
 'posts',
 # أضف اسم التطبيق الخاص بك هنا    
]

 By adding the application name to this list, Django realizes that he must download the application at the time of the launch of the project.

Create models in Django

 Models are the way Django gets, managing and storing data using Python objects. Since we are building a blog, our models will represent what undefined The blog usually owns, such as authors, categories and blog publications.

 First, in the Models.Py file, enter the fun_user_model function, which is an auxiliary function for Django to access the project user model. Also add the Django Models unit at the top of the file:

from django.contrib.auth import get_user_model
from django.db import models
User = get_user_model()

 Author Model (Author)

 Let's start with the author's model in simple detail; All we need is the name and image of the author:

class Author(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
profile_picture = models.ImageField()
def __str__(self):       
return self.user.username              

 Category Category Model

 The category model requires a title, sub -address, mini -image and link. The link is a short identifier that only contains letters, numbers, lower stations, or signs, and is commonly used in URL addresses. For example, instead of http://127.0.0.1:8000/posts/1 address, we can use the http://127.0.0.1:8000/post/my-firstt-blog-post look more readable.

class Category(models.Model):
title = models.CharField(max_length=20)
subtitle = models.CharField(max_length=20)
slug = models.SlugField()
thumbnail = models.ImageField()
def __str__(self):
return self.title

 Post Port Form

 Finally, we will create a post form. This model has more information, so it contains more details. Everything in this model is well shown by their names.

class Post(models.Model):
title = models.CharField(max_length=100)
slug = models.SlugField()
overview = models.TextField()
timestamp = models.DateTimeField(auto_now_add=True)
content = models.TextField()
author = models.ForeignKey(Author, on_delete=models.CASCADE)
thumbnail = models.ImageField()
categories = models.ManyToManyField(Category)
featured = models.BooleanField()
def __str__(self):
return self.title

 For more information about Manetomanyfield, you can visit Django: Manetomanyfield documents

Implementation of deportations in Django

 After applying the changes to the models, to record these changes in the database, close the server with CTRL+C and then Qum undefined By running the following orders:

python manage.py makemigrations


python manage.py migrate

 Every time you make a change to the models, you will need to use these orders to make changes on the database

Create a management board about using Django

To use the DJANGO management panel, we first need to edit the Admin.py file. In this file, you need to enter the required forms and libraries as follows:

from django.contrib import admin
from .models import Author, Category, Post
admin.site.register(Author)
admin.site.register(Category)
admin.site.register(Post)

 Create a distinguished user (Superuser) in Django

The next step is to create a distinguished user. Superuser is an official user who can easily make changes in the DJANGO management panel. The creation of a distinguished user should be a standard step in any DJANGO project. Anything we specify in models will be displayed on the DJANGO official page, and you can access it using SUPERUSER.

 To create a premium user, first stop the server with CTRL+C and then run the following orders in the terminal:

python manage.py createsuperuser

 Follow the steps, such as the username, password, email, etc. This information can be dedicated to your choice. Make sure to write down this information somewhere. But if you forget them, you can always create a new user.

 You should now access the official's page by logging into https://127.0.1:8000/admin/login. Here, you will see all the categories you created in the Models.PY file. You can start adding content to the author, category and publications sections.

Views.Py file in Django

Views.py file is where the logic of programming and the main process of the project occurs. This part is one of the most important parts of the project. In the Views.Py file, we first need to include the function and models that we have already created:

from django.shortcuts import render
from .models import Post, Category, Author

 Create a home page function in Views.Py

 This section determines the method of display on the details page for each post in the blog:

def post(request, slug):
post = Post.objects.get(slug=slug)
context = {
'post': post,
}
return render(request, 'post.html', context)

 In this function, the distinctive groups, posts and modern posts are received and sent to the homepage.html template in the form of dictionary (dictionary).

Create a publishing details page in the Views.Py file

 This section determines the method of display on the details page for each post in the blog:

def post(request, slug):
post = Post.objects.get(slug=slug)
context = {
'post': post,
}
return render(request, 'post.html', context)

 This function finds a specific post using its link and sends information to the post.html style.

Create a page for who we are in the Views.Py file

 If you want to add a brief page on us to the project, you can use this function:

def about(request):
return render(request, 'about_page.html')

 This function downloads the About_Page.html template only.

Create a category page function in the Views.Py file

 This section is used to display posts related to a specific category:

def category_post_list(request, slug):
category = Category.objects.get(slug=slug)
posts = Post.objects.filter(categories__in=[category])
context = {
'posts': posts,
}
return render(request, 'post_list.html', context)

 This function finds all posts related to a specific category and sends it to the post_list.html template.

Create a function page of all posts in the Views.Py file

 Finally, offer all posts:

def allposts(request):
posts = Post.objects.order_by('-timestamp')
context = {
'posts': posts,
}
return render(request, 'all_posts.html', context)

 This function sorted all publications according to the publication time and sends them to the All_posts.html template.

 Using these functions, you can manage the logic of the display for your various blog pages. These jobs receive the information required from the models and send them to HTML formats to display at the user interface.

Preparation of URL addresses in Django

 To prepare URL addresses in the Django project, you need to move to the URLS.PY file and enter the following at the beginning of the file:

from django.conf import settings
from django.contrib import admin
from posts.views import homepage, post, about, postlist, allposts
from django.urls import path

Determine URLs in Django

 We now need to determine road paths undefined The offer we created in the previous sections. These re -guidances are used to redirect URL to the appropriate display functions within the Django app. Finally, the Urlpatterns icon will look as follows:

urlpatterns = [
path('admin/', admin.site.urls),
path('', homepage, name='homepage'),
path('post//', post, name='post'),
path('about/', about, name='about'),
path('postlist//', postlist, name='postlist'),
path('posts/', allposts, name='allposts'),
]

 These re -guidance processes guarantee each specific URL to its view.

Create templates in Django

 The templates are where the front end of our bloc is stored. This is where HTML and other components related to the user interface are stored.

1. Create a folder of molds: Create a folder called templates on your project root.


2. Create HTML files inside the template folder:

 Create the following files inside the template folder:

• homepage.html


• footer.html


• base.html


• navbar.html


• post_list.html


• all_posts.html


• about_page.html


• post.html

 Sorry, even for you, we will explain the rest of the topic (Create Blog using Django) in the following article.