Scribd
Upload
2K views27 pages

Web Development With Django: © Shrinath Shenoy

The document provides an overview of Django, an open-source Python web framework. It describes what Django is, how to create a Django project and app, and the main components like models, views, templates, forms and settings. It also lists some major companies that use Django and benefits like being easy to use and maintain with available plugins.

Uploaded by

Nidhi Malik
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
Download as pdf or txt
2K views27 pages

Web Development With Django: © Shrinath Shenoy

The document provides an overview of Django, an open-source Python web framework. It describes what Django is, how to create a Django project and app, and the main components like models, views, templates, forms and settings. It also lists some major companies that use Django and benefits like being easy to use and maintain with available plugins.

Uploaded by

Nidhi Malik
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
Download as pdf or txt
Download as pdf or txt
You are on page 1/ 27

Web development with Django

© Shrinath Shenoy
What is Django

Django is a MVC like framework ( Django


community call it as MTV - Model, View, Template
) written in pure python

Django can be used with databases like


Postgresql, MySQL, sqlite, MongoDB, Oracle etc..
Who are using Django

Mozilla ( support.mozilla.com, addons.mozilla.org )


Google ( developers.google.com, app engine cloud sql
)
Disqus
Pinterest
Instagram
bitbucket
newyorktimes.com (represent)
washingtonpost.com
guardian.co.uk
developer.vodafone.com
nationalgeographic.com
Creating a django project

Start a new project from


django-admin.py startproject projectname

It will create project folders in the following


structure
projectname/
manage.py
projectname/
__init__.py
settings.py
urls.py
wsgi.py
Django Project Structure

python manage.py startapp appname


projectname/
manage.py
appname/
__init__.py
models.py
tests.py
views.py
projectname/
__init__.py
settings.py
urls.py
wsgi.py
settings.py

This contains all the settings related to the


project. Like DB username-password-
connection-port, middlewares, logs, dev
settings, media path etc.

The settings.py file is used as default


configuration file while running the server. If you
have some other settings file then you can tell
the server to use that by setting the environment
vairable DJANGO_SETTINGS_MODULE
urls.py

• URL patterns are definied in this file.


• URL patterns will be made up of regular
expressions of the url patterns.
• The function/view that needs to be called are
mapped here.
• Best Practice : Maintain a urls.py inside each app
to avoid the global urls.py mess
A typical urls mapping looks like this

from django.conf.urls import patterns, url

urlpatterns += patterns('',
urlpatterns = (
url(r'^$', views.index, name='index'),
)
views.py

The request lands here after the url requested is mapped to


a view through middlewares.

There are two types of view. That a user can opt for
depending on the requirement.
1. Function Based View
2. Classbased view

Function based views are normal python functions that take


request and curresponding custom parameter if any.

Class Based views are the special views that is required to


be inheriting the django's predefined view/any other class
that satisfy the condition to map the url to a class based
view ( Better to inherit the view class given by django :) )
• There are lot of built in views that can be used
accordingly. ( e.g. listview - if you want just to list
the objects of a model that satisfy a queryset )
• url definition will take function based view ( FBV
) as second argument. This will make the view
function gets called for that url. Where as Class
based view's as_view() function should be feed
to url definition. The reason is given below.
• Class Based Views ( CBV ) has the intelligence
to find the method used in request ( get, post or
any other ) and dispatche the data come along
with the request to curresonding method.
• Each view must return a response or raise the relevant
exeption if any.
• response can contain the django template, file, JSON
objects or even just HTTP Status codes.
A typical Django FBV would look like this

from django.http import HttpResponse


import datetime

def current_datetime(request):
now = datetime.datetime.now()
html = "<html><body>Its now %s</body></html>"
% now
return HttpResponse(html)
A typical Django CBV would look like this

import datetime
from django.http import HttpResponse
from django.views.generic import View

class ShowDateView(View):
def get(request):
now = datetime.datetime.now()
html = "<html><body>Its now %s</body></html>"
% now
return HttpResponse(html)
models.py

Models.py file is the place to put the details about


the DB tables that we need in our app.
Models can be imagined as DB Table - definition
written in python :)

Models are the normal python classes that inherit


from the Django "Model" class found in
django.db.models module.

The class attributes/member-variables defines the


columns and data type of their curresponding db
tables.
• models will have thier own "manager" objects
that will be used to query the table.
• Django ORM provides the "query functions" in
each models through thier "manager" objects.
• Each model object will have their save() method
to save the model "instance" into database.
• models have built in validators which will validate
the model object values against their datatype
and constraints.
A typical django model would look like

from django.db import models

class UserProfile(models.Model):
first_name = models.CharField(max_lenght=10)
last_name = models.CharField(max_lenght=10)
phone_number = models.IntegerField(null=True)
Availble Built in Fields in Django models

AutoField
BigIntegerField
BooleanField
CharField
CommaSeparatedIntegerField
DateField
DateTimeField
DecimalField
EmailField
FileField
forms.py

Django forms which is used to process web form


data are similar to django model classes. But
django froms deal with the incoming data from
client rather than database.
Similar to Django models django forms are python
classes inheriting from Django's django.form
module
A django form declaration would look like

from django import forms

class LoginForm(forms.Form):
username = forms.CharField(max_length=12)
password = forms.CharField(max_lenght=12, att)
Django Forms built in Fields

BooleanFieldCharField ChoiceField
DateField DateTimeField
EmailField FileField
FloatField ImageField
IPAddressField GenericIPAddressField
TypedMultipleChoiceField NullBooleanField
SlugField TimeField
TypedChoiceField DecimalField
FilePathField IntegerField
MultipleChoiceField RegexField
URLField
templates

Django templates are the files (Usually HTML ) which allow


us to insert the django variables inside them and write very
minimalistic processing like iterating over a loop, trimming
the string, adding integers inside them etc.

Django templates are designed to make it reusable. Like a


class, you can inherite a template and override the portions
of it.

Django template engine comes with built in tags and filters


which can be used to process the data before rendering.
Even django allows you to create your own custom tags
and filters. So that you can define your custom behaviors in
the template.
Django templates should be written in such a way that only
rendering process will be held in that. No complex logical
algorithm shoul be handled inside the templates.
Django template are designed such that it uses the less of
programming language, and more of the designing part so
that any web designer knowing only creating
HTML/CSS/Javascript can develop it without having the
exposure to the python.
Django Principles

DRY ( Don't Repeat Yourself )


Loose Coupling
Less Code
Explicit is better than implicit
Infinite flexibility in url
Separate logic from presentation
Be decoupled from HTML
Benifits/Pros of using Django

Easy to understand and easily maintainable


code
Write less do more with python-django
combination.
Lot of opensource plugins available that can be
used along with django. You just need to
import and use it in your code.
Django has lot of built-ins which are more
commonly needed functionalities in a web app
along with additional goodies.
• User authentication and password management
• Pagination
• Form-Model validation
• Caching
• Admin Panel
• Session management
• Protection via clickjacking and cross site
• Localization
• Email Integration
• RSS Feeds Integration
• Sitemap Integration
• CSV/PDF save/export integration
• Geographical Query Support
Thank You..!!
)
:

You might also like