Django - How to create CRUD with Example


Django is the high-level Python Web framework that encourages rapid development and clean, pragmatic design. If you have not previously installed Django on a mac, then please check out my How To Install Django On Mac.  It will help you to install python and Django web framework step by step.

Django Crud Example
We will start our application by creating a new Django project, and then we will configure it step by step and finally make a fully functional CRUD application.

Step 1: Create a Django Project.

First, start the virtual environment by typing the following command.

source bin/activate

Okay, now we will create a project by the following command.

django-admin startproject djangocrud

Our application name is djangocrud and opens this project on your IDE or Editor. I am using the Visual Studio Code. Our primary project structure looks like this.

Step 2: Configuring the database.

I am using the MySQL database, so I need to configure it. By default, it comes with SQLite, but we do not use that instead of we will use phpMyAdmin

Now, install mysqlclient.

sudo pip install mysqlclient

Go to the djangocrud  >> file and edit the Databases object. Replace that object with the following object to configure the mysql database.


    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'djangocrud',
        'USER': 'root',
        'PASSWORD': 'root',
        'HOST': '',
        'PORT': '8889',
        'OPTIONS': {
            'sql_mode': 'traditional',

Please make sure your database name, username, password, and port number. I am using MAMP so; mine might be different from yours. Confirm all those settings.

Okay, now check the connection of your Django application with the database.

python check

If you see that the System check identified no issues message, then you are good to go.

Now, migrate the tables in the database using the following command.

python migrate

It will migrate the tables to the database successfully. Now, we need to create a superuser for our application. Hit the following command.

python createsuperuser

Okay, so we have successfully created a superuser. Now, start the python server by using the following command.

python runserver

Step 3: Create a new app.

Next step is to create a new module or app we can say. So in the root of your project, type the following command.

python startapp coins

Now, analyze the folder structure. We have one more folder in the root called coins. 

So, it has created a bunch of files for models and views.

Register this new app coins inside djangocrud  >> file.



Step 4: Write your first view.

First, create file inside coins folder.


from django.urls import path

from . import views

urlpatterns = [
    path('', views.index, name='index'),

Now, include this file inside djangocrud  >> file.


from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('coins/', include('coins.urls')),

Finally, inside coins  >> file, write the following code to send the HTTP response.


from django.shortcuts import render
from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world. You're from the coins index")

Switch to the browser and hit http://localhost:8000/coins/

You will get the HTTP response “Hello, world. You’re from the coins index“.

Next, create the templates folder inside main root folder. In that folder create one folder called coins. Go into that folder and create one file called index.html.

<!DOCTYPE html>
<html lang="en">
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Django CRUD Application</title>
    <h1>Welcome to Coins app in Django</h1>

Now, we need to tell the Django application that where our template files are located. So go to the file and edit the TEMPLATES array. Right now ‘DIRS‘ key is empty, and we need to fill the value with the following code. We are merely telling the Django that load all the template files from templates folder.


'DIRS': [os.path.join(BASE_DIR,'templates')],

Again, switch to the browser and go to the http://localhost:8000/coins/

Now, you can able to load the index.html template.

Jinja Templating Engine.

Python uses Jinja templating engine by default. Now, if we return the variable from the view like this,


from django.shortcuts import render

def index(request):
    return render(request, "coins/index.html", 
    {'title': 'All Coins Price'})

Then, we can display title variable inside index.html file like this.

<!DOCTYPE html>
<html lang="en">
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Django CRUD Application</title>
    <h1>{{ title }}</h1>

We can also define the master layout and then use that layout to another layout. You can find more about the jinja templating engine on their official documentation.

Step 5: Write the model for coins application.

Now, open the coins  >> file and create a new model called Coin.


from django.db import models

class Coin(models.Model):
    coin_name = models.CharField(max_length=30)
    coin_price = models.IntegerField()
    created_at = models.DateField()

Next step is to make migration from this Coin model. Go to the terminal and type the following.

python makemigrations coins

It will create the migration file inside coins  >>  migrations folder.


from django.db import migrations, models

class Migration(migrations.Migration):

    initial = True

    dependencies = [

    operations = [
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('coin_name', models.CharField(max_length=30)),
                ('coin_price', models.IntegerField(max_length=10)),
                ('created_at', models.DateField()),

Finally, create a table from this migration file by the following command.

python migrate

It will create a table in the database name like coins_coin.

Step 6: Register the model Coin.

Open coins  >> file and add the following code.


from .models import Coin

So, basically, we are attaching this model to the backend of our application, which is admin area. Now, go to the admin area of the application. The URL is: http://localhost:8000/admin/

Now, you can see that our newly created coins application is there.

Now, try to add the new coin and its price and yes you can add the new coin to the database. But wait, till now we have not created any store function or write the query to insert the values in the database. We event have not created the form at the backend.

So what is going on?? The answer is when we have defined the model, Django has created all the files for us, and based on the database fields, it has created the form fields and write the code to insert, edit, update and delete functionalities. So the Django framework is very popular for rapid development.

We are facing one problem here. After creating the Coin name and price. We can not see their name clearly instead of that, we are seeing the name object, which is not right. So let us fix that by the following code inside coins  >> file.


 def __str__(self):
        return self.coin_name

Now, you can see that we clearly see the name of the coins. You can view, edit, and delete the coins as well.

So basically, Create, Insert, Update, and Delete functionalities are done by default by just creating the models.

That is it. Django Crud Tutorial Example is over. Thanks for taking it.