django course summary
TRANSCRIPT
Django on GAE course
Course summary
Version 0.1, 13-May-2010
Agenda
● Python
– Variables, Operators, Introspection
– Data structures & Control structures
– List comprehension
– Functions, Classes
– Unit testing
● Django
– Mgmt commands
– Models, Admin
– URL's, Views, Templates
– Forms, Generic Views, I18n
– Unit testing
– Pluggable Apps● Google AppEngine
– Deploying Django projects using django-nonrel
– Limitations, Features, API's, BigTable datastore
Variables
● No typing – data type inferred by assignment– X = 8
– Y = “abc”
● Next assignment can be to a different data type
● Under the hood, primitive variables are pointers to memory locations whose stored values don't change (just the pointer).
– Unlike Data Structures which point to memory locations that may change
Operators
● Standard arithmetical, logical & bits operators– 12 + 7
– “s” * 8
– 10 > 1
● Objects of any class can support operators, by implementing internal methods, such as:
– __mul__, __add__, __div__, __pow__
– __gt__, __lt__, __eq__
– __xor__, __or__, __and__
Introspection
● Everything in Python is an object– Primitive values, methods, classes, modules
● The type function returns the type of an object● The dir function returns the methods of an
object● The hasattr method checks whether an object
has some method● The __doc__ property returns the
documentation of an object, e.g., a method
Data Structures
● There are 4 main types:– Lists: ordered collection of variables, of any
type● l = [21, “ac”, 3.12, 21]
– Tuples: just like lists, but immutable● t = (21, “ac”, 3.12, 21)
– Dictionary (map): set of key-value pairs● d = {“x”: 12, “abc”: “de”, 12: “hh”}
– Set: unordered collection of unique variables● S = {21, “ac”, 3.12}
List Comprehension
● Useful way to transform a collection into another
– e.g., suppose we want to multiply each element of a list by 2:
● list2 = [x*2 for x in list1]
– We can also add condition filtering the elements, e.g., remove odd elements:
● list2 = [x*2 for x in list1 if x mod 2 == 0]
– List comprehension can be nested too:● List3 = [x*2 for x in list2 for list2 in list1]
Unpacking
● Unpacking means assigning the contents of a collection into stand-alone variables
– E.g., you can do:● x, y, z = [56, “bb”, 7]
● There's also an operator for unpacking a sequence - * - e.g.:
– head, *tail = [87, 98, “kk”, 9.8]● head will contain 87, & tail: [98, “kk”, 9.8]
– first, *mid, last = “Charles Philip Arthur George Windsor”.split()
Control Structures
● Standard idioms for controlling the flow of a program, such as condition, loop on list, loop until some condition &c.
● The content of control structure blocks isn't surrounded by some sign (e.g., { }) but rather marked by being indented after the starting line, e.g.:
– If x > 0:print “Yay”
y = 2/xelse: print “Naaa”
Loops
● Looping on lists is done like this:– for el in li:
print el
– for i in range(10): print i
● You can also use unpacking: – li = [(1, “w”), (2, “b”), (3, “f”)]
for i, c in li: print i, “=”, c
– for i, el in enumerate(list1): print i, “ = “, el
Functions
● Functions chunk complex logic into a named operation, with possible parameters:
– def add(x, y): print “add called with”, x, “, “, y return x + y
● Parameters can have default values, & can be invoked by order or name:
– def move(direction, num_steps=1): ...
move(direction=-30)move(180, 5)
Classes
String Formatting
Unit Testing
Reading from the Web
Files IO
Useful Libraries
Summary Examples in Shell
Management Commands
● To start a project, run the startproject command:
– django-admin.py startproject myproj
● Inside this folder, create a Pluggable App:– python manage.py startapp myapp
● To create the DB (configured it in settings.py):– python manage.py syncdb
● Now run the server: – python manage.py runserver
Models
● Models define the entities used in our application, & their business logic behavior
● Models are entered in a file called models.py● class Book(models.Model):
title = models.CharField(max_length=200) author = models.ForeignKey(Author) isbn = models.CharField(max_length=50)
Admin
● Django arrives with an app for generating high-quality data entry GUI for your models
● You need to add metadata for the admin app in a file called admin.py
– The file should contain a metadata class per any model entity you'll need to edit:
– class BookAdmin(admin.ModelAdmin): list_display = [“isbn”, “title”, “author”] search_fields = [“isbn”, “title”] list_filter = [“author”] ordering = [“author”, “title”]
URL's Configuration
● Django encourages you to design meaningful URL's for your application pages & API
● To do that, you need define the URL's patters in the file urls.py, & specify which controller handles each URL
Views
● In Django speak, Views are actually the controllers responsible for handling requests
● Views are defined in a file called views.py, & need to prepare all the data for the page that will be eventually returned
Templates
● To actually render the result page, using the data prepared by the view, you need to write Templates
● Templates are located in 1 or more folders, listed in the settings file
● In order to maintain the DRY (Don't Repeat Yourself) principle, templates can inherit one another, in order for each one to add or override another, without duplicating anything
Forms
● Django can generate data entry forms using simple metadata, that can possibly be inferred from the model definition of the entity being edited
● Forms metadata are defined in a file called forms.py
Generic Views
● Some views repeat themselves, so Django offers several basic views that can replace them, with parameters, such as:
– direct_to_template: view that just returns some template
– object_list: view that lists entities received by some query
– object_detail: view that presents the details of some entity
● The parameters for a generic view are provided as a dictionary
I18n
● Django makes it easy to offer your application in several languages. To do that:
– Wrap the strings you want to translate in your code with a special function (ugettext in code, of trans in templates)
– Run: python manage.py makemessages-l he● This will generate a file containing the strings
you need to translate
– Translate the .po file generated
– Run: python manage.py compile messages
– You can now switch language in the settings, or let the user switch language
Unit Testing
● There are several ways to prepare unit tests for your Django code, in order to be able to monitor that nothing got broken following some code change.
● A nice way is to invoke a view – without having s running server - & test its output or the model embedded inside it
– See the example test developed in the class
● To run all tests defined in some app, run:– python manage.py test myapp
Pluggable Apps
Serializers
● Django comes with a mechanism to represent a collection of entities in a string, to be sent over the wire
– This is useful for API's, e.g., when another application wants to consume your data
● The serializers mechanism supports few standard data protocols, such as XML & JSON
Reverse URL
Absolute URL
Settings
Serving Static Files
Dumping & Loading Data
Deploying using django-nonrel
Limitations
Features
API's
BigTable Datastore