0% found this document useful (0 votes)
95 views37 pages

Rapid Web Development With Python/Django: Julian Hill

This document provides an overview of rapid web development using Python and the Django web framework. It discusses why Python is a good choice, introduces Django and its core concepts like MVC and ORM. It explains Django project layout and common files like models, views, templates, urls. It demonstrates creating models, querying objects, and using generic class-based views. It also covers forms, templates, authentication, and other Django features and best practices.

Uploaded by

jppn33
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
95 views37 pages

Rapid Web Development With Python/Django: Julian Hill

This document provides an overview of rapid web development using Python and the Django web framework. It discusses why Python is a good choice, introduces Django and its core concepts like MVC and ORM. It explains Django project layout and common files like models, views, templates, urls. It demonstrates creating models, querying objects, and using generic class-based views. It also covers forms, templates, authentication, and other Django features and best practices.

Uploaded by

jppn33
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 37

Rapid Web Development

with Python/Django
Julian Hill
Why Python?
 Written in C – high performance, ability to link to C libraries
for extensions
 Interpreted script language compiled on the fly into bytecode
 Easier to read coding standards – whitespace sensitive
 Object Oriented
Introducing…Django
 “The framework for perfectionists with deadlines”
 MVC
 Flexible template language that can be used to generate
HTML, CSV, Email or any other format
 Includes ORM that supports many databases – Postgresql,
MySQL, Oracle, SQLite
 Lots of extras included – middleware, csrf protections,
sessions, caching, authentication
Django Concepts/Best Practices
 DRY Principle – “Don’t Repeat Yourself”
 Fat models, thin views
 Keep logic in templates to a minimum
 Use small, reusable “apps” (app = python module with
models, views, templates, test)
Django Project Layout
django-admin.py startproject

<PROJECT_ROOT>

manage.py

<PROJECT_DIR>

__init__.py

settings.py

urls.py

wsgi.py
settings.py
 Defines settings used by a Django application
 Referenced by wsgi.py to bootstrap the project loading
 Techniques for managing dev vs prod settings:
 Create settings-dev.py and settings-prod.py and use symlink to
link settings.py to the correct settings
 Factor out common settings into base-settings.py and import.
Use conditionals to load correct settings based on DEBUG or
other setting
Sample Settings…
DEBUG = True

TEMPLATE_DEBUG = True

ALLOWED_HOSTS = []

# Application definition

INSTALLED_APPS = (

'django.contrib.admin',

'django.contrib.auth',

'django.contrib.contenttypes',

'django.contrib.sessions',

'django.contrib.messages',

'django.contrib.staticfiles',

)
Django Apps
 Reusable modules
 django-admin.py startapp <app_name>
 Creates stub layout:
<APP_ROOT>
admin.py
models.py
templates (directory)
tests.py
views.py
urls.py
Django Models
 Defined in models.py
 Typically inherit from django.db.models.Model
Example Model:

from django.db import models

class TestModel(models.Model):

name = models.CharField(max_length = 20)

age = models.IntegerField()
Models (cont’d)
 Default is to set NOT NULL on all fields. Override by
adding null = True to field definition:

name = models.CharField(max_length=20, null = True)


 Relationships defined through special field types:
models.OneToOneField(model)

models.ForeignKey(model)

models.ManyToManyField(model)
Models (cont’)
 Need Nulls in a Boolean Field? Use models.NullBooleanField()
 Set Default value with “default”:
count = models.IntegerField(default = 0)
 Use a inner Meta class to define additional options, especially
useful for abstract classes:

class TestModel(models.Model):

class Meta:

abstract = True
Model Methods
 model.save(self, *args, **kwargs)
 model.delete(self, *args, **kwargs)
 model.get_absolute_url(self)
 model.__str__(self) [Python 3]
model.__unicode__(self) [Python 2]
 Override with super(MODEL, self).save(*args, **kwargs)
Activating a Model
 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
Selecting Objects
 Models include a default manager called objects
 Manager methods allow selecting all or some instances
Question.objects.all()
Question.objects.get(pk = 1)
Use try block, throws DoesNotExist exception if no
match
Question.objects.filter(created_date__lt = ‘2014-01-01’)
 Returns QuerySet
Introspecting Legacy Models
 manage.py inspectdb
 Cut and paste generated code into models.py – Easy!!
Full Sample
from django.db import models
from datetime import datetime

class TimestampedModel(models.Model):
created_datetime = models.DateTimeField()
updated_datetime = models.DateTimeField()

def save(self, *args, **kwargs):


if self.id is None:
self.created_datetime = datetime.now()
updated_datetime = datetime.now()
super(TimestampedModel,self).save(*args, **kwargs)

class Meta:
abstract = True
Full Sample (cont’d)
class Question(TimestampedModel):
question_text = models.CharField(max_length = 200)

def __str__(self):
return self.question_text
Function vs. Class Views
 Django allows two styles of views – functions or class based
views
 Functions – take a request object as the first parameter and
must return a response object
 Class based views – allow CRUD operations with minimal
code. Can inherit from multiple generic view classes (i.e.
Mixins)
Sample – Viewing a List of
Questions
 Function based:
from .models import Question
from django.shortcuts import render_to_response

def question_list(request):
questions = Question.objects.all()
return render_to_response(‘question_list.html’, {
‘questions’:questions})
Quick CRUD Operations with
Generic Views
 ListView
 UpdateView
 CreateView
 If Model is specified, automagically creates a matching
ModelForm
 Form will save the Model if data passes validation
 Override form_valid() method to provide custom logic (i.e
sending email or setting additional fields)
Sample – As Class Based View
from .models import Question
from django.views.generic import ListView

class QuestionList(ListView):
model = Question
context_object_name = ‘questions’
Django Templates
 Very simple syntax:
variables = {{variable_name}}

template tags = {%tag%}


 Flexible – can be used to render html, text, csv, email, you
name it!
 Dot notation – template engine attempts to resolve by
looking for matching attributes, hashes and methods
Question List Template
<!doctype html>
<html lang=en>
<head>
<meta charset=utf-8>
<title>List of Questions</title>
</head>
<body>
{%if questions%}
<ul>
{%for q in questions%}
<li>{{q.question_text}}</li>
{%endfor%}
</ul>
{%else%}
<p>No questions have been defined</p>
{%endif%}
</body>
</html>
urls.py
 Defines routes to send urls to various views
 Can use regular expressions
 Extract parameters from a url and pass to the view as a named
parameter:

r(‘^question/(?P<question_id>\d+)/$’,’views.question_detail’)
 Extensible – urls.py can include additional url files from
apps:
r(‘^question/’,include(question.urls))
Hooking up the Question List
from django.conf.urls import patterns, url, include

urlpatterns = patterns(‘’,

(r’^questions/$’,’views.QuestionList’)

OR:

from django.conf.urls import patterns


from views import QuestionListView

urlpatterns = patterns(‘’,
(r’^questions/$’,’views.QuestionList.as_view())

)
Forms in Django
 django.forms provides a class to build HTML forms and
validation. Example:

from django import forms

class EditQuestionForm(forms.Form):
question_text = forms.CharField(max_length = 200)

 Often redundant when creating forms that work on a single


model
ModelForms
 Automatically generate a form from a model.
 Handles saving a bound model
 Can specify fields to be included or excluded in the form
 Sample:
from django.forms import ModelForm
from .models import Question

class QuestionForm(ModelForm):
class Meta:
model = Question
fields = [‘question_text’]
Using a ModelForm
 Create an instance of an empty form:
form = QuestionForm()
 Create a form to update an existing instance of a model:
question = Question.objects.get(pk = 1)
form = QuestionForm(instance = question)
 Pass the form into the template and use the form methods to
render the form:
form.as_p
form.as_ul
form.<field_name>
form.<field_name>.errors
Request & Response
 Request object encapsulate the request and provide access to a number of
attributes and methods for accessing cookies, sessions, the logged in user
object, meta data (i.e environment variables),
 Response objects are returned to the browser. Can set content type,
content length, response does not have to return HTML or a rendered
template
 Special response types allow for common functionality:
HttpResponeRedirect
Http404
HttpStreamingResponse
Django Extras
 CRSF Middleware – enabled by default. Include template tag in all
forms:
{%csrf_token%}
 Authentication
 Caching
 Sessions
 Messages
 Email
 Logging
Authentication
 Django’s out of the box Auth system uses database
authentication.
 Changed extensively in Django 1.6 to allow custom User
objects.
 AUTHENTICATION_BACKENDS setting in settings.py
allows overriding how User objects are authenticated
 If using the Authentication middleware and
context_processors the current user is available to code as
request.user and {{user}} is defined in all templates
Auth Decorators
 Live in django.contrib.auth.decorators
 login_required
@login_required
def function_view(request):
….
 user_passes_test (can be used with lambda functions for real power) –
@user_passes_test(lambda u: u.is_staff)
def function_view(request):

 has_perms – test for user permissions
Decorating CBVs
 Decorator is applied to the dispatch method
 Must be converted to a method_decorator – use
django.utils.decorators.method_decorator function:

class MyView(ListView):

@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
super(MyView,self).dispatch(*args, **kwargs)
Custom Auth Backend for the
Bubble
Sending Email
 django.core.mail includes functions and classes for handling
email
 Set EMAIL_HOST in settings.py to outgoing mailserver
 Import send_mail for simple mail:
send_mail(subject, message, from, to_emails)
 Use django.template.render_to_string to format a message
using a template
 Use EmailMultiAlternatives to create a text message and
attach a html version as well.
Resources
 Python – http://www.python.org
 Django – http://www.djangoproject.com
 Python Packages – https://pypi.python.org
 Django Packages – https://www.djangopackages.com
Q&A

You might also like