Django Tutorial_ Let’s take a deep dive into Django’s web framework.pdf

Django Tutorial: Let’s take a deep
dive into Django’s web
framework
Today, we’ll look at a popular framework that many businesses use to build
online apps. In this Django tutorial, we’ll go over the basics of the framework.
This Django course is designed for web developers who are new to the
framework and will show you how to create web apps using Django so that you
can create websites with this Python backend.
We’ll learn about the Django framework, why you should learn it, its features,
architecture, and benefits in this tutorial. In this Django tutorial, we’ll also go
over the prerequisites for learning Django, the history of Django, and the
companies that utilise it.
When we hear the word “Django”, we immediately ask ourselves, “What is
Django?” and “What are the uses of Django?” Let’s start our journey with the
definition of Django.
What is Django?
Django is a high-level Python web application framework that facilitates quick
web application development. It accomplishes this through a pragmatic, much

cleaner design that is also simple to use (in comparison to other frameworks),
making it a popular choice among web developers.
It’s a backend framework for resolving database connectivity issues, other
server issues, SEO solutions, and so on so that a web developer doesn’t have to
create the same code for each website’s identical modules (such as database
connection, admin interface).
The Django framework provides all of the functionality in the form of web
applications. You just import those applications as needed, allowing you to
focus on your website’s specific application rather than all of these underlying
difficulties.
Why use Django?
A web framework is a collection of modular tools that withdraw away a lot of
the complexity–and repetition–in web development. Most websites, for
example, require the same fundamental functionality: the ability to connect to
a database, configure URL routes, display content on a page, and
appropriately handle security.
Rather than reinventing the wheel, programmers have created web
frameworks in all of the major programming languages, including Python’s
Django and Flask, Ruby’s Rails, and JavaScript’s Express, among many others.
Django takes Python’s “batteries-included” approach and includes
out-of-the-box support for basic web development tasks, such as:
● user authentication

● testing
● database models, forms, URL routes, and templates
● admin interface
● security and performance upgrades
● support for multiple database backends
Instead of recreating the wheel every time for conventional, secure online
application functionality, this method allows web developers to focus on what
makes a website special.
Several popular frameworks, including Python’s Flask and JavaScript’s
Express, take a “microframework” approach. They only supply the bare
minimum for a basic web page, leaving it up to the developer to install and
configure third-party packages to reproduce basic website functionality. This
method gives the developer more flexibility, but it also increases the chances
of making mistakes.
Django has already been used by millions of programmers to create websites,
which is undoubtedly a positive thing. Web creation is difficult. It’s pointless
to rewrite the same code–and make the same mistakes–when a big
community of great developers has already done it.
Django, on the other hand, is still in active development and has a yearly
release plan. The Django community is always introducing new features and
improving security. And, most of all, it’s developed in the Python
programming language, which is both readable and powerful. In short, if
you’re starting from scratch, Django is an excellent choice.
History of Django

Django Reinhardt, the guitarist, was honoured with the framework’s name.
Adrian Holovaty and Simon Willison, two web engineers at the Lawrence
Journal-World newspaper, founded Django in 2003. It was released to the
public under the BSD licence in July 2005.
Django was created because it inherited Python’s “batteries-included”
approach and contains premade modules and applications for typical web
development chores such as user authentication, templates, routes, and views,
an admin interface, solid security, and support for numerous database
backends.
It has solved certain important challenges for web developers that were
previously solved at the cost of time and money.
Django Version History
Vers
ion
Date Description
0.90
16 Nov
2005
–
0.91
11 Jan
2006
magic removal
0.96
23 Mar
2007
newforms, testing tools

1.0
3 Sep
2008
API stability, decoupled admin, Unicode
1.1
29 Jul
2009
Aggregates, transaction-based tests
1.2
17 May
2010
Multiple db connections, CSRF, model validation
1.3
23 Mar
2011
Time Zones, in-browser testing, app templates.
1.5
26 Feb
2013
Support for Python 3 and a user model that can be customised.
1.6
6 Nov
2013
Dedicated to Malcolm Tredinnick, connection pooling, and database
transaction management.
1.7
2 Sep
2014
Migrations, application loading and configuration.
1.8
LTS
2 Sep
2014
Migrations, application loading and configuration.
1.9
1 Dec
2015
Automatic password validation. New styling for the admin interface.
1.10
1 Aug
2016
Full-text search for PostgreSQL. New-style middleware.

1.11 1.11 LTS
The last version is to support Python 2.7. Supported until at least
April 2020
2.0 Dec 2017
First Python 3-only release, Simplified URL routing syntax, Mobile
friendly admin.
How Popular is Django?
There is no technique to measure the popularity of server-side frameworks
that is both trustworthy and accurate ( Although measures such as tracking
the number of GitHub projects and StackOverflow inquiries for each platform
can be used to determine popularity.)
A better thing to ask is if Django is “popular enough” to avoid the issues that
come with unpopular platforms. Is it still developing? Or is it possible to seek
assistance if you require it? Is there a chance you’ll be able to get compensated
if you learn Django?
Yes, Django is a popular framework, based on the number of high-profile
websites that use it, the number of individuals contributing to the codebase,
and the number of people giving both free and commercial support.
Disqus, Instagram, Knight Foundation, MacArthur Foundation, Mozilla,
National Geographic, Open Knowledge Foundation, and Pinterest are just a
few of the high-profile sites that adopt Django.
Is Django “opinionated” or “unopinionated”?

The terms “opinionated” and “unopinionated” are frequently used to describe
web frameworks.
Opinionated frames have strong outlooks about the “correct” approach to
complete a task. Because the appropriate way to accomplish something is
usually well-understood and well-documented, they frequently support rapid
development in a specific domain (fixing problems of a specific sort). They are,
however, less versatile when it comes to handling challenges outside of their
primary domain, with fewer options for components and methodologies.
Unopinionated frameworks, on the other hand, contain significantly fewer
constraints on how to connect components to achieve a goal, or even what
components should be employed. They make it a lot easier for developers to
employ the best tools for a given work but at the risk of having to find those
components yourself.
Hence, Django is “a little opinionated,” therefore it gives you the “best of both
worlds”. It includes a set of components for most web development jobs, as
well as one (or two)recommended methods for using them. Django’s loosely
coupled architecture, on the other hand, allows you to pick and choose from a
variety of alternatives, or provide support for entirely new ones if necessary.
Prerequisites to Learn Django
You should be familiar with Python and have a basic understanding of the
command line interface/PowerShell for Windows or Terminal for
macOS/Linux.

Learning Django simply takes a basic understanding of these technologies,
thus even a Django newbie may quickly pick up the framework.
Overview of the Reasons to Learn Django
We should understand why we should learn technology before we start
learning it. So, here are some of the reasons why you should learn Django.
Django has a lot of features and is a future-oriented emerging technology. It is
worthwhile to learn Django because it is based on Python, which is a very
powerful language that will also be used significantly in the future.
The following are some compelling reasons to learn Django:
1. Django Has Changed Through the Years
Since its release, Django has grown in popularity, and it is still going strong
after more than a decade in the business. It’s been a long time, and several
releases have occurred throughout that time.
Django has corrected numerous security vulnerabilities and added other
features, therefore this period accounts for Django’s stability as well as the
technology’s capacity to remain competitive.
2. Open-Source Technology
Django is an open-source technology, which means that where the documents
aren’t given the attention they deserve, this isn’t the case with Django.

Django has outstanding documentation from its release in 2005, and it is still
well maintained, implying that at the time of release, it was the only
framework with decent documentation.
3. Great Community
The Django framework community is one of the best out there since they
support all projects and respond to any queries helpfully. One of the reasons
for the Django community’s rapid growth is this.
As a result, more and more people are turning to Django, and it will become
more widely used in the future. This is why it is an excellent complement to
your resume.
4. Pre-installed Packages
Because Django has such a vibrant community. It also contains several
packages that might help you address your difficulties quickly. These packages
are easy to find thanks to well-maintained documentation, allowing for quick
developments.
Django Framework’s Features
Since the framework’s introduction, the Django project’s stability,
performance, and community have exploded. With each version, the Django
framework gains additional features such as database migrations and many
more.
1. Stability

Django is generally one of the first frameworks to respond to a newly
discovered vulnerability. It signifies that Django is a tested framework that has
evolved through time. Django fixes a lot of bugs, but not all of them.
As you’ve probably heard, “Humans get wiser with age; software improves
through time”, which is a good say for Django.
2. Documentation is excellent
Despite being an open-source project, Django provides excellent
documentation, which is always up to date by Django developers. It was one of
the key characteristics that set Django different from other open-source
projects when it was first introduced, and it has only become better over time.
3. High Scalability
When employing any technology on larger projects with a vast scope,
scalability is a critical consideration. Django can run on any hardware you
throw at it while yet being able to develop on smaller devices.
It’s built on a “share-nothing” architecture, which means you may add
hardware at any level, including database, server, web, and cache servers.
4. Handles Security Problems
Django eliminates many security vulnerabilities that exist in PHP frameworks
by default. Django accomplishes this by dynamically producing web pages and
using templates to convey data to web browsers via direct internet access.

5. Makes use of SEO
SEO stands for “Search Engine Optimization,” which is a method of enhancing
the quantity and quality of traffic to your website by using natural search
engine results. The lines between web development and SEO appear to be
blurring all the time. However, with Django, this should be less of an issue.
The Django framework uses human-readable website URLs, which aids search
engines and is beneficial not only to users but also to search engine algorithms
that use the keywords in the URL when ranking sites.
6. A Large Package Library
The Django community is large and supportive, and they supply packages for
practically anything you would need in a website, allowing you to quickly
create management systems that suit your needs.
7. Possibilities for Pragmatic and Robust Design
Django’s key advantages include the ability to develop full-scale web
applications with ease. Its code is written from scratch rather than relying on
pre-existing Python libraries.
What is a Web Framework?
A web framework is a piece of software that allows you to create and operate
web applications. As a result, you won’t have to waste time writing code on
your own and hunting for errors and problems.

All applications were hand-coded in the early days of web development, and
only the app’s developer could alter or distribute it. The introduction of web
frameworks provided a simple way out of this bind. Because of the appearance
of general performance, all the bother associated with updating an
application’s structure has been put in order since 1995. Then came the
emergence of web-specific languages. Their wide range of options is now
suitable for both static and dynamic web pages. Depending on your purpose,
you can choose a single framework that meets all of your requirements or
combine multiple.
Understanding Django’s Architecture:
We’ll start with the web application framework before moving on to Django
architecture. The web application framework is a programme that offers you
pre-written components and modules to make online applications easier.
Django offers a lot of features that make it extremely efficient, simple, and
enjoyable to use. Django is built on the Model-View-Controller (MVC)
architecture, which is made up of three parts: model, view, and controller.
Django’s design is MVT (Model-View-Template), with Template replacing
View and View replacing Controller. The procedure is the same, with the
change of the terminologies.
There is a common misperception that the view in MVT functions similarly to
the controller in MVC. However, this is not the case. In the coming articles,
we’ll go through this in greater detail.
● Model:

The model, which is represented by a database, is the logical data structure
that supports the entire application (generally relational databases such as
MySQL, Postgres).
● View:
When you visit a website, the View is the user interface that appears in your
browser. HTML/CSS/JavaScript files are used to display it.
● Controller:
The Controller acts as a link between the view and the model. Data is
transferred from the model to the view via the controller.
Your application will revolve around the model in MVC design, either
displaying it or altering it.
For example, a user will type a URL into their browser, and the request will be
sent to a server over the internet protocol (HTTP), which will then call Django.
If the URL path matches, Django will call the Controller, which will retrieve an
entry from your database and render a View (HTML/CSS/JavaScript Web
page).

MVC Architecture’s Drawbacks –
1. The framework’s navigation can be difficult at times. Users understand the
MVC decomposition criteria as a result of the introduction of three layers with
abstractions.
2. Parallel programming requires multiple developers.
3. Expertise in a variety of technologies is required.
4. Keeping track of a large number of codes in the controller.
How does Django code appear?
A web application waits for HTTP requests from the web browser in a
standard data-driven website (or other clients).

When an application receives a request, it determines what is required based
on the URL and perhaps information in the POST or GET payload. It may next
read or write information from a database or do other operations to complete
the request, depending on what is necessary.
The program will then send a response to the web browser, commonly by
putting the acquired data into placeholders in an HTML template and
dynamically constructing an HTML page for the browser to display.
The code for each of these steps is usually split up into separate files in Django
web applications:
Advertisement
Urls:

While it is possible to process requests from all URLs with a single function,
writing a separate view function for each resource is far more maintainable.
Based on the request URL, a URL mapper is used to redirect HTTP requests to
the appropriate view. The URL mapper can also look for specific patterns of
strings or digits in a URL and transmit them as data to a view function.
View:
A view is an HTTP request handler function that receives and responds to
HTTP requests. Django Models provide views with the data they need to fulfil
requests, while templates handle the return formatting.
Models:
Models are Python objects that specify the structure of an application’s data
and provide techniques for managing (adding, modifying, and deleting) and
querying database entries.
Templates:
Templates are text files that define the structure or layout of a file (such as an
HTML page), with placeholders for actual content. A view can use an HTML
template to dynamically construct an HTML page and populate it with data
from a model. You can use a template to define the structure of any sort of file;
it doesn’t have to be HTML!
Sending a request to the appropriate view
(urls.py).

A URL mapper is usually saved in the urls.py file. The mapper (urlpatterns) in
the example below defines a set of mappings between routes (particular URL
patterns) and view functions. The accompanying view function will be invoked
and passed the request if an HTTP Request is received with a URL matching a
specified pattern.
Let’s study these concepts with the help of the following codes.
from django.contrib import admin
from django.urls import path
from Employee import views
urlpatterns = [
path('admin/', admin.site.urls),
path('TechVidvan/', views.Employee_Details),
]
Urls.py file
Views.py (handling the request):
Views are the heart of the web application, receiving and responding to HTTP
requests from online clients. They use the framework’s other resources in the
meanwhile to access databases, render templates, and so forth.
The example below demonstrates a simple view function index(), which might
have been called by our URL mapper from earlier. It takes an HttpRequest
object as a parameter (request) and returns a HttpResponse object, much like
all view functions. We don’t do anything with the request in this scenario, and
our answer is a hard-coded string.
from django.shortcuts import render, redirect
from django.http import HttpResponse

# Create your views here.
def Employee_Details(request):
return render (request,'Employee_details.html')
Data model definition (models.py):
Models are Python objects that Django web applications use to manage and
query data. Models determine the structure of stored data, including field
types and optionally their maximum size, default values, selection list options,
documentation help text, form label text, and so on.
from django.db import models
# Create your models here.
class Employee(models.Model):
Empid= models.IntegerField()
name= models.CharField(max_length=25)
address= models.CharField(max_length=100)
salary= models.IntegerField()
Department= models.CharField(max_length=25)
Models.py file
Data rendering (HTML templates):
By providing placeholders for data that will be filled in when the page is
generated, template systems allow you to establish the structure of an output
document. Templates are commonly used to construct HTML, but they can
also be used to build other documents. Django comes with support for both its
templating system and Jinja2, a popular Python package (it can also be made
to support other systems if needed).

<!DOCTYPE html>
<html>
<head>
<style>
body{
background-color:burlywood;
}
</style>
<title>Employee_details</title>
</head>
<body>
<h1>The Employees Here at TechVidvan</h1>
Employee name: {{ first_name }}
</body>
</html>
Types of Django Applications
Django comes with everything you’ll need to get your projects up and running
quickly. As a result, many developers consider it to be their preferred
framework. Django allows you to create complicated, database-driven web
applications such as:
● Machine learning
● E-commerce platforms·
● Data analysis
● Content management
Companies that use Django include
Django is widely used by many large names, and you should be utilising it as
well. They alter the framework a lot and use it according to their needs, but it’s
still Django at its heart.

We have the following websites that use Django:
1. Instagram
Instagram is a very popular social media app. It is one of the most widely used
social media apps. Instagram is built on Django, and they’ve recently joined
the Django Software Foundation as a gold sponsor (DSF).
Django works well with other technologies, such as iOS and Android apps. As
a result, Instagram can launch rapidly while simultaneously managing
millions of active users.
2. Disqus
The Disqus software was built from the ground up using Python and Django,
making it one of the largest Django projects out there. They needed their
websites to be able to manage a large number of concurrent users
They also created sentry, a state-of-the-art tool that checks for mistakes and is
also built on Django.
3. Spotify
Spotify has revolutionised the way we listen to music, and it accomplishes it by
implementing machine learning in Python. Python-based AI is used to
manage the large song libraries and training.
It uses Django for its web applications to combine things, giving you a full
Python experience on Spotify.

4. YouTube
YouTube is the world’s largest video hosting platform, including everything
you can think of. It’s a terrific place to watch videos for pleasure, learning, and
other purposes. They were previously utilising PHP, but are currently
switching to Django.
The rationale for this is that it allows for faster development and can handle a
large number of active users. Maintaining the website’s security and speed at
the same time.
Visit the Django Sites database for more examples; they have a list of over
5000 Django-powered websites.
There are many more such applications that include django as their web
framework. We will discuss the list of all these famous websites in our
upcoming article.
Advantages of Django

The Django project is responsible for putting the design concepts into action.
These are some of the key features that distinguish Django from other
frameworks.
1. Loosely Coupled
The Django framework is loosely connected but firmly bonded, thus different
levels of the framework do not need to “know” about one another until it is
required. Django has a security advantage over other frameworks because of
it.
2. Lesser Code
Django takes full advantage of pre-written apps, requiring you to write far less
code.
Django is also created from the ground up in Python, without the use of any

libraries, even though it has several common functions. Django’s code is
highly optimised for online usage, making it significantly more efficient.
3. DIR (Don’t Repeat Yourself)
Multiple copies of something take up more space and provide less
functionality, and the bulkier the code is on the web, the more bandwidth it
consumes from the end-user.
This is a typical coding strategy, but Django takes it a step further. It also
provides applications for all of the things you may ever require. As a result,
you don’t have to write anything that has already been written on other
websites; instead, concentrate on your own.
4. Consistency
The basic function of web applications is to act as intermediaries between
various technologies. Furthermore, the framework is consistent at all levels
and performs consistently. Even if the model is too large or the project is
modest, this can happen.
5. Versatile
Django is capable of handling a wide range of tasks, including content
management, scientific computing platforms, and even large companies.
6. Rapid Development
Django’s philosophy is to do everything it can to make development as quickly
as possible.

7. Clean Design
Django maintains a clean design across its own code, making it simple to
follow.
8. Object-Relational Mapping (ORM)
Django acts as a link between the data model and the database engine, and it
supports a wide range of databases such as MySQL, Oracle, and Postgres.
Django’s Django-nonrel branch also supports NoSQL databases. MongoDB
and Google App Engine are the two NoSQL databases that are currently
supported.
9. Multilingual Support
Django’s built-in internationalisation framework makes it possible to create
multilingual websites. As a result, you can create a website that supports
several languages.
10. Framework Support
Django comes with built-in support for Ajax, RSS, Caching, and a variety of
other frameworks.
11. Administration GUI:
Django offers a wonderful ready-to-use user interface for administration tasks.
12. Development Environment

Django includes a lightweight web server for end-to-end application
development and testing.
Is there anything else you can do?
URL mapping, views, models, and templates are the major aspects that you’ll
utilise in practically every online application, as seen in the prior sections.
Django also provides several other features, such as:
Forms
HTML Forms are used to collect data from users for server processing. Django
makes creating, validating, and processing forms easier.
User authentication and permissions
Django has a secure user authentication and permission system.
Caching
Creating dynamic material takes a lot more computing power (and time) than
delivering static content. Django has configurable caching, allowing you to
save all or part of a rendered page so that it is only re-rendered when
necessary.
Administration Site
When you use the basic skeleton to build an app, the Django administration
site is automatically added. It’s a cinch to provide site administrators access to

an admin page where they can create, change, and examine any data models
on your site.
Data serialization
Django makes it simple to serialise and serve your data in XML or JSON
format. This is beneficial when building a web service (a website that only
feeds data to other applications or sites and does not display anything), or
when building a website where the client-side JavaScript handles all data
presentation.
Disadvantages of Django Framework
● It is unable to handle numerous queries at once.
● It has an impact on the performance of small web apps.
● To work with Django, you must be familiar with the complete
system.
● Regex isn’t easy to use for URL specification.
Summary
Congratulations on taking the first step on your Django adventure! You should
now have a basic understanding of Django’s primary advantages, a brief
history of the language, and an approximate idea of what each of the main
components of a Django programme might look like. You should have a basic
understanding of the Python programming language, including list, function,
and class syntax.

You’ve already seen some real Django code, but you’ll need to build up a
development environment to run it, unlike client-side code. That is the next
stage for us.

Django Tutorial_ Let’s take a deep dive into Django’s web framework.pdf

More Related Content

Similar to Django Tutorial_ Let’s take a deep dive into Django’s web framework.pdf (20)

More from SudhanshiBakre1 (20)

Recently uploaded (20)

Django Tutorial_ Let’s take a deep dive into Django’s web framework.pdf