Scribd Logo
Carica

Benvenuto in Scribd!

  • Web Development With Django: © Shrinath Shenoy

    Caricato da

    Nidhi Malik
    115 visualizzazioni27 pagine
    bmjsndlwmd;lf

    Titolo originale

    webdevelopmentwithdjango-140904042557-phpapp01

    Copyright

    © © All Rights Reserved

    Formati disponibili

    PDF, TXT o leggi online da Scribd

    Hai trovato utile questo documento?

    Questo contenuto è inappropriato?

    Segnala questo documento
    bmjsndlwmd;lf

    Copyright:

    © All Rights Reserved
    Scarica in formato PDF, TXT o leggi online su Scribd
    Segnala contenuti inappropriati
    115 visualizzazioni27 pagine

    Web Development With Django: © Shrinath Shenoy

    Caricato da

    Nidhi Malik
    bmjsndlwmd;lf

    Copyright:

    © All Rights Reserved
    Scarica in formato PDF, TXT o leggi online su Scribd
    Segnala contenuti inappropriati
    di 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..!!
    )
    :

    Potrebbero piacerti anche