Django Crud: Getting Started with Django Framework

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, 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  >>  settings.py file and edit the Databases object. Then, replace that object with the following object to configure the mysql database.

// settings.py

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'djangocrud',
        'USER': 'root',
        'PASSWORD': 'root',
        'HOST': '127.0.0.1',
        '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 manage.py 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 manage.py 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 manage.py createsuperuser

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

python manage.py runserver

Now so it will start the server, and we can access the application at http://localhost:8000.

We can also access the admin area of our application since we have created the superuser. Go to http://localhost:8000/admin. Insert your newly created superuser username and password, and you can log in to the application.

Step 3: Create a new app.

The 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 manage.py 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  >>  settings.py file.

// settings.py

INSTALLED_APPS = [
    'coins',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

Step 4: Write your first view.

First, create the urls.py file inside the coins folder.

// urls.py

from django.urls import path

from . import views

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

Now, include this file inside djangocrud  >>  urls.py file.

// urls.py

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

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

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

// views.py

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 the main root folder. In that folder, create one folder called coins. Then, go into that folder and create one file called index.html.

<!DOCTYPE html>
<html lang="en">
<head>
    <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>
</head>
<body>
    <h1>Welcome to Coins app in Django</h1>
</body>
</html>

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

// settings.py

'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,

// view.py

from django.shortcuts import render

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

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

<!DOCTYPE html>
<html lang="en">
<head>
    <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>
</head>
<body>
    <h1>{{ title }}</h1>
</body>
</html>

We can also define the master layout and then use that layout for 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  >>  models.py file and create a new model called Coin.

// models.py

from django.db import models

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

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

python manage.py makemigrations coins

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

// 0001_initial.py

from django.db import migrations, models


class Migration(migrations.Migration):

    initial = True

    dependencies = [
    ]

    operations = [
        migrations.CreateModel(
            name='Coin',
            fields=[
                ('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 manage.py migrate

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

Step 6: Register the model Coin.

Open coins  >>  admin.py file and add the following code.

// admin.py

from .models import Coin

admin.site.register(Coin)

So, basically, we are attaching this model to the backend of our application, which is the admin area. So, 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 it 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. So 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, and it has created the form fields and write the code to insert, edit, update and delete functionalities. So the Django framework is prevalent for rapid development.

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

// models.py

 def __str__(self):
        return self.coin_name

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

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

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

Fork Me