Web development with django - Basics Presentation

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

Web development with django - Basics Presentation

In this document

More Related Content

What's hot

Similar to Web development with django - Basics Presentation

Recently uploaded

Web development with django - Basics Presentation