This document provides an overview of the topics that will be covered in a Django on GAE course, including: 1. Python fundamentals like variables, operators, data structures, and classes. 2. Django topics such as management commands, models, the admin interface, URLs, views, templates, forms, generic views, internationalization, and unit testing. 3. Google App Engine topics such as deploying Django projects using django-nonrel, limitations, features, APIs, and using the BigTable datastore.

1. Django on GAE course
Course summary
Version 0.1, 13-May-2010

2. Agenda
● Python ● Django
– Variables, Operators, – Mgmt commands
Introspection – Models, Admin
– Data structures & – URL's, Views,
Control structures Templates
– List comprehension – Forms, Generic
– Functions, Classes Views, I18n
– Unit testing – Unit testing
● Google AppEngine – Pluggable Apps
– Deploying Django projects using django-nonrel
– Limitations, Features, API's, BigTable datastore

4. 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

5. 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__

6. 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

7. 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}

8. 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]

9. 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()

10. 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/x
else:
print “Naaa”

11. 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

12. 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)

13. Classes

14. String Formatting

15. Unit Testing

16. Reading from the Web

17. Files IO

18. Useful Libraries

19. Summary Examples in Shell

23. 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

24. 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)

25. 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”]

26. 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

27. 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

28. 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

29. 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

30. 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

31. 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

32. 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

33. Pluggable Apps

34. 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

35. Reverse URL

36. Absolute URL

37. Settings

38. Serving Static Files

39. Dumping & Loading Data

41. Deploying using django-nonrel

42. Limitations

43. Features

44. API's

45. BigTable Datastore