Forem: Priyanshu Panwar

Django 2.x V/S Django 3.x

Priyanshu Panwar — Mon, 08 Nov 2021 11:10:07 +0000

In this article, we'll talk about the new features added to Django 3.x and their differences, though Django 2.2.x still has a Long Term Support. (I still use Django 2.2.6)
Before we start, Both Django versions work very well with Python 3.x, though one might feel some problem with some libraries in Django 2.x for python 3.6+(in rare libraries).

New Features added in Django 3.x

MARIA DB

Django 3.x comes in support with Maria DB. This might not effect most of the django programmers but for those who are fans of this open source MYSQL database.
This is how you can use MariaDB in your django project.

# settings.py
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'OPTIONS': {
            'read_default_file': '/path/to/my.cnf',
        },
    }
}

# my.cnf
[client]
database = NAME
user = USER
password = PASSWORD
default-character-set = utf8

ASGI in Django - Biggest Upgrade of 3.x

Django 3.0 is now fully async-capable, it provides support for running as an ASGI application in addition to the existing WSGI support.
ASGI (Asynchronous Server Gateway Interface) is a spiritual successor of WSGI, intended to provide a standard interface between async-capable Python web servers, frameworks and applications. Let's take a simple example to see the working of async python in django.

async def application(scope, receive, send):
    event = await receive()
    ...
    await send({"type": "websocket.send", ...})

These two features are the main upgrades in the Django 3.0
If you are looking to work with MariaDB or want to use the power of async python, then definitely upgrade to Django 3.0

THANK YOU

Feel Free to ask me anything in comments or reach out to me directly. Priyanshu Panwar | LinkedIn

Everything About Django - 3 (Models and Migrations)

Priyanshu Panwar — Mon, 08 Nov 2021 07:03:26 +0000

This is the third blog of the series Everything About Django. In this article we are going to study about Models and Migrations.

What are Models?

Models are the database tables.
Django uses ORM (Object Relational Mapping) for models.
Each model is a subclass inherited from django.db.models.Model class.
Every attribute in Django Model specifies a field in the database table.

What is ORM?

ORM means Object Relational Mapper, one of the most powerful feature of Django.
Django's ORM is just a pythonical way to create SQL to query and manipulate your database and get results in a pythonic fashion.
How wonderful this is, you need not type SQL and do all the db stuff.

How to create a model?

Let's take an example to see how a model is made.

from django.db import models
class Student(models.Model):
    name = models.CharField(max_length=100)
    roll = models.IntegerField()
    address = models.CharField(max_length=200)

This way I have created a table Student with the following attributes : name - Char, roll - Integer, address - Char.
In SQL we do this by :

CREATE TABLE Student
(
roll int,
name varchar(100),
address varchar(200)
);

So you see how easy and pythonic this is with Django.

What is a migration?

Once we have defined a model, it's just a python code not yet reflected in our database, no table is created so far, until we migrate this to our database.
Once our models is defined, we need to run python manage.py makemigrations. See the example bro.
Here core is the app in which my models is defined. It creates a folder in my app migrations.
With every makemigrations, a file is created like 0001_initial.py which contains the information about our reflected changes in the database, which looks like this. This is a internal file created by django to reflect changes in the db.
Once we have made migrations, we need to actually reflect them in the database to create and modify the table. For this run, python manage.py migrate. This command will run the latest migrations made and reflect their changes.

I will create an article on tips while creating a model, where I will define all the attributes, functions one should define in a model.

THANK YOU

You can find me on : Priyanshu Panwar | LinkedIn

Please feel free to comment for any help or topic I should write an article on.

Playing with Django Model Objects - CheatSheet

Priyanshu Panwar — Sun, 07 Nov 2021 17:18:40 +0000

One must know how to play with Django models in their views in order to create efficient and short functions.

Let's take a model for example.

class Teacher(models.Model):
    name = models.CharField(max_length=100)

class Student(models.Model):
    name = models.CharField(max_length=100)
    roll = models.CharField(max_length=100)
    mentor = models.ForeignKey(Teacher, on_delete=models.CASCADE)
    reg_date = models.DateTimeField(auto_add_now=True)

Extracting all objects of a model

Let's extract all the students.

students = Student.objects.all()

Extracting a student by ID

ID is the primary key in every model.

from django.shortcuts import get_object_or_404

def my_view(request):
    obj = get_object_or_404(MyModel, pk=1)

Or there is another way to do this.

stud = Student.objects.get(pk=1)

The last one returns a error in case a student doesn't exist with the following id.

Filtering the objects

Simple filtering can be done with equating like

studs = Student.objects.filter(name='Ram Kapoor')

This will return the list of students whose name is Ram Kapoor.
We can also refer to the details of an attribute with the symbol __.

stud_2006 = Student.objects.filter(reg_date__year=2006)

This will return all the students registered in 2006.

stud_p = Student.objects.filter(name__startswith='P')

This will return all the students whose names start with 'P'.

Using Q() - Very Powerful

This is used to add many filters in a single filter using | (or), & (and).

stud = Student.objects.filter(Q(name__startswith='P') | Q(reg_date__year=2006))

This will return both the students whose names start with 'P' or who are registered in year 2006.

THANK YOU

Find me on Priyanshu Panwar | LinkedIn

Everything About Django - 2 (Architecture of Django)

Priyanshu Panwar — Sun, 07 Nov 2021 10:28:05 +0000

This is the second blog of my series Everything About Django. You can read my previous article here.
In this article, we are going to learn the core architecture of Django, how Django works.

Architecture of Django

Django follows the architecture MVT - Model View Template.
Let's break the MVT architecture :

Model : This is the database layer of the architecture. Model means the tables stored in the database. Django follows the ORM (Object Relational Mapping) Protocol by which we can write the database commands in pythonic way without any SQL. We will study this in detail in coming blog.
View : This is the logical layer of the architecture. This is where we write the logic of our project. We create functions/classes which are mapped to different URL Patterns of our site (project).
Template : This is the display layer of the architecture. This contains the html files that are rendered(displayed) on our web interface. Every view(function/class) sends a template or a http response.

Let's take a look at this picture for clear understanding.

Let's drop this into few points:

A user opens a specific url of our site (project) suppose http://localhost:8000/login
Django maps this url to the specific view (function) which implements the logic for this url.
The view takes the data from associated models (database) and sends a template which is rendered on the web interface.

I hope the MVT architecture of Django is clear. Feel free to comment your doubts.

THANK YOU

You can find me at : My Portfolio | LinkedIn

Everything About Django - 1 (How To Start)

Priyanshu Panwar — Sat, 06 Nov 2021 16:53:31 +0000

This is the first blog of the series Everything About Django.

Prerequisite

Just Install Python3 in your system along with pip.

What is Django?

Django is a full stack open source web framework built on top of Python.

How to setup Virtual Environment?

A virtual environment is a Python environment such that the Python interpreter, libraries and scripts installed into it are isolated from those installed in other virtual environments, and the whole system. With virtual environment, you can seperate all the packages and requirements you need for each project. It works in a similar way to package.json in Javascript.

Install pipenv using pip pip install pipenv
Create a folder dev and open command prompt inside it.
Create a virtualenv with pipenv pipenv install
Type pipenv shell
This activates our virtual environment.
Type pip freeze to check the libraries installed. It will give no result as no python libraries are installed in this environment yet.

Install Django

We will be using Django 2.2.6 (3 can also be used).
pip install django==2.2.6
This installs our Django.

Creating a Django Project

We will create a django project named Beginner.
Once our django is installed, we get access to django-admin which is a django administrator with which we initialize our new project.
Type in the same command prompt : django-admin startproject Beginner
This creates our new Django project.

Django Project Created

This is our Django Project created. Let's look at the files.

Inside our parent Beginner Folder, we have the following structure :

Beginner Folder : This folder has the same name as our Parent folder(Project Name). It contains all the settings and configurations of the whole project.
- __init__.py : This file tells the interpreter that it's a python project.
- settings.py : This file contains all the configurations of this project like SECRET_KEY, ALLOWED_HOSTS, INSTALLED_APPS, MIDDLEWARES, 'STATIC FILES CONFIG`, etc. We will discuss about all of this in detail in a seperate blog.
- urls.py : This file contains the root level url configurations. When we run our project, all the urls are checked and matched from this file.
- wsgi.py : This file is the entry point of our project for the web servers during deployment. This file actually connects the web server with our django project. From Django 3.0, we also have asgi.py file. ASGI is the successor of WSGI which would need a seperate blog for discussion.
manage.py : This python file is located at the root directory. This is same as django-admin. It works like a django administrator but only works for the current project. We can control the whole project with this command like python manage.py runserver - We can run this file by giving instructions with it like runserver, createsuperuser, etc.

How to Run my Project?

Let's go to our same command prompt and go inside the Beginner folder cd Beginner and type : python manage.py runserver. This runs our django project on our system's localhost at port 8000: http://localhost:8000/
This is what our command prompt shows :
We have 17 unapplied migrations which we'll discuss in our next blog.
Let's go to the localhost url at 8000 port and test if our project runs.

If we see this template on the screen, our project is working and properly configured. We can start working on it now.

THANK YOU

You can find me at : My Portfolio | LinkedIn