Django course summary
Upcoming SlideShare
Loading in...5

Django course summary






Total Views
Views on SlideShare
Embed Views



2 Embeds 10 9 1



Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
Post Comment
Edit your comment

Django course summary Django course summary Presentation Transcript

  • Django on GAE course Course summary Version 0.1, 13-May-2010
  • 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
  • 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/x else: 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: – startproject myproj ● Inside this folder, create a Pluggable App: – python startapp myapp ● To create the DB (configured it in – python syncdb ● Now run the server: – python runserver
  • Models ● Models define the entities used in our application, & their business logic behavior ● Models are entered in a file called ● 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 – 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, & 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, & 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
  • 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 makemessages-l he ● This will generate a file containing the strings you need to translate – Translate the .po file generated – Run: python 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 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