Rapid web application development using django - Part (1)

Rapid Web Application
Development using Python/
Django framework
Part 1
<made by: Nishant Soni>

WHY PYTHON ?
Python is a general-purpose interpreted, interactive, object-
oriented, and high-level programming language. It was created
by Guido van Rossum during 1985- 1990. Like Perl, Python
source code is also available under the GNU General Public
License (GPL).
1
2
3
4
5
I T I S H I G H L Y R E A D A B L E .
I T I S I N T E R A C T I V E .
I T I S O B J E C T O R I E N T E D .
I T I S S C A L A B L E .
I T I S E X T E N D A B L E .

Applications of Python
1
Web & Internet
Development
2
Scientific & Numeric
computing
3
Building Desktop
GUI's
4
Software
Development
5
Business Application
Development
made by Nishant Soni

Django is a high-level Python web framework that
encourages rapid development and clean progmatic
design.
Some Features of Django Framework:
> ORM
> Automatic Admin Interface
> Cache Infrasturcture
> Internationalization
> Templating System
> Command Line job framework
> Regex based URL Design
INTRODUCTION TO
DJANGO
"For Perfectionists with
deadlines"
SOUDERTON SENIOR HIGH SCHOOmade by Nishant Soni

MODEL (models.py) Defines the data structure and handles the database queries. It defines the
data in python and iteracts with it). Typically contained in RDBMS(MySQL,
SQLite etc.) other data storage mechanisms are also possible as well (LDAP
etc.)
Views (views.py)
TEMPLATE
Determines what data from the model should be returned in HTTP
response. Tasks involve reading and writing to the database. (usually in
views.py)
Renders data in HTML(or JSON or XML) and makes it look pretty
There is also a Controller (URL dispatcher)- this maps the requested urlto a
view function and calls it . If caching is enabled , the view function can
check to see if a cached version of the page exists and bypass all the further
steps , returning cached version. (urls.py)
CONTROLLER
DJANGO ARCHITECTURE
MVT - "Model-View-Template"

Django HTTPs Request
Handler
Django Flow goes something like this:
1) Visitor’s browser asks for a URL.
2) Django matches the request against its urls.py files.
3) If a match is found, Django moves on to the view that’s
associated with the URL. Views are generally found inside each app
in the views.py file.
4) The view generally handles all the database manipulation. It
grabs data and passes it on.
5) A template (specified in the view) then displays that data.

Rapid web application development using django - Part (1)

Django
Project
Layout
<PROJECT_ROOT>
manage.py
<PROJECT_DIR>
__init__.py
settings.py
urls.py
wsgi.py

SOUDERTON SENIOR HIGH SCHOOL
settings.py is a core file in Django projects. It holds all the
configuration values that your web app needs to work; database
settings, logging configuration, where to find static files, API keys if
you work with external APIs, and a bunch of other stuff.
Settings.py contains :
> Core Settings
> Auth
> Messages
> Sessions
> Sites
> Static Files
> Core Settings Topical Index
Django- settings.py
Defines the settings used by our Django
Application

An Django App is an submodule of the project which
is a self-sufficient. An app typically has it's own
models.py.
DJANGO- APPS
Apps bring modularity to your project.!

Django Model contains the essential fields and
behaviors of the data you're storing. Generally, each
model maps to a single database table. The basics:
Each model is a Python class that subclasses
django.db.models.Model .
Django - Models
"let the models be fatter, and views thin"

Django
Models
Example
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models
from datetime import datetime,date
from taggit.managers import TaggableManager
from ckeditor.fields import RichTextField
from home.models import Category ,Author
from django.template.defaultfilters import slugify
# Create your models here
class Blogs(models.Model):
title=models.CharField(max_length=50,null=False,blank=False)
slug = models.SlugField(blank=True)
content=RichTextField()
tags=TaggableManager()
categories=models.ForeignKey(Category, related_name='comments')
author=models.ForeignKey(Author)
published_on=models.DateField(default=datetime.now(),blank=True)
image=models.ImageField(upload_to='images/blogs/')
def __str__(self):
return self.title
class Meta:
verbose_name_plural="blogs"

Activating
Django
Models
> Add the app to INSTALLED_APPS
in settings.py
> Run manage.py validate
> Run manage.py syncdb
> Migrations
> Write custom script or manually
handle migrations
Use South

Django Views take an HTTP Request and return an HTTP Response to the user.
Any Python callable can be a view.The only hard and fast requirement is that it
takes the request object (customarily named request) as its first argument.
from django.http import HttpResponse
def hello_world(request):
return HttpResponse("Hello, World")
Django - views.py

1. Django allows two styles of views – functions or class based views.
2. Functions – take a request object as the first parameter and must
return a response object.
3. Class based views – allow CRUD operations with minimal code.
Can inherit from multiple generic view classes (i.e. Mixins)
Django - views.py (cont'd)

Function Based View is very easy to implement and it’s
very useful but the main disadvantage is that on a large
Django project, there are usually a lot of similar
functions in the views; one case could be that all objects
of a Django project usually have CRUD operations, so
this code is repeated again and again unnecessarily, and
so, this was one of the reasons that the class-based
views. Function-based generic views are created to
address the common use cases.
Example of Function based view in following slide:
Django - Function
based view

Django views.py
(function based view)

Django ships with generic views to do the following:
>    Display list and detail pages for a single object. If we were creating an
application to manage conferences then a TalkListView and a
RegisteredUserListView would be examples of list views. A single talk page
is an example of what we call a “detail” view.
>    Present date-based objects in year/month/day archive pages, associated
detail, and “latest” pages.
>    Allow users to create, update, and delete objects – with or without
authorization.
Django - Generic Views or
class based view
Generic View take certain common idioms and patterns found
in view development and abstract them so that you can
quickly write common views of data without having to write
too much code.

The simplest way to use generic views is to create them directly in your URLconf. If you’re
only changing a few simple attributes on a class-based view, you can simply pass them into
the as_view() method call itself:
from django.urls import path
from django.views.generic import TemplateView
urlpatterns = [
path('about/', TemplateView.as_view(template_name="about.html")),
]
The second, more powerful way to use generic views is to inherit from an existing view and
override attributes (such as the template_name) or methods (such as get_context_data) in
your subclass to provide new values or methods. (As shown in following slide)
Django - Generic Views or class based
view (cont'd)
Django provides an example of some classes which can be used as views.
These allow you to structure your views and reuse code by harnessing
inheritance and mixins

Django views.py
(class based view)

To design URLs for an app, you create a Python module informally
called a URLconf (URL configuration). This module is pure Python
code and is a mapping between URL path expressions to Python
functions (your views).
Django - Urls.py

> Preparing and restructuring data to make it ready for
rendering
> Creating HTML forms for the data
> Receiving and processing submitted forms and data
from the client
Django - forms
Django handles three distinct parts of the work involved in
forms:

Django - ModelForms
Our Teachers and Assistant Teachers
A ModelForm maps a model class’s fields to HTML form
<input> elements via a Form; this is what the Django admin
is based upon.

How to use
a
Model Form
Instantiating, processing, and rendering forms
1. When rendering an object in Django, we generally:
2. Get hold of it in the view (fetch it from the database,
for example)
3. Pass it to the template context
4. Expand it to HTML markup using template variables

Made with love by :
Nishant Soni
IT Engineer | Python Developer
contact: nishantsoni78@gmail.com
www.linkedin.com/in/thenishantsoni

Rapid web application development using django - Part (1)

More Related Content

Similar to Rapid web application development using django - Part (1) (20)

Recently uploaded (20)

Rapid web application development using django - Part (1)