• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Django course summary

Django course summary






Total Views
Views on SlideShare
Embed Views



2 Embeds 10

http://www.slideshare.net 9
http://www.lmodules.com 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: – 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