Python for Programmers: A Project-Based Tutorial

PyCon 2013 Sandy Strong & Katharine Jarmul

Please visit this page and follow the instructions:

https://us.pycon.org/2013/community/tutorials/5/

Introduction to Workshop

Who are we?

Alexandra (Sandy) Strong (@sandymahalo): Systems Engineer at Dreamhost, Python Education, PyLadies

Katharine Jarmul (@kjam): Director of Technology at HYFN, Pythonista, PyLadies

Who are you?

Py-curious computer programmers, with beginning to intermediate level of experience in your language of choice, and a rudimentary understanding of your operating system's command line. If you have never programmed before, this tutorial is probably not for you. We will be moving through material extremely quickly in order to complete an entire web app in 3 hours.

View the tutorial slides here:

http://bit.ly/YXKWic
I recommend downloading and saving the slides as a PDF now!

A little Python history

Created by Guido van Rossum in late 80s
Benevolent Dictator for Life Now works at Google

Name is based off Monty Python

Why Python?
Simple to get started, easy for beginners, powerful enough for professionals Code is clean, modular, and elegant, making it easy to read and edit Whitespace enforcement Extensive standard library, many modules to import from Cross platform - Windows, Mac, Linux Supportive, large, and helpful community

Who is using Python?

Google Reddit Twitter Pinterest/Instragram DreamHost YouTube BitTorrent DropBox ...and countless more!

Why a project?
Getting your hands dirty is the best way to develop a new skill! Your efforts in this tutorial will produce a meaningful project, and give you something to show for your work.

Questions so far?

Introduction to Project and a Quick Tour of Python

Libraries: CherryPy and Jinja2

Why did we choose these? CherryPy:
Lightweight and easy to use microframework Has direct interface with WSGI It's fun to learn new things and we know you've all used django or flask ;)

Jinja2
Commonly used python templating language Easy to grok syntax Integrates with many python libraries

Initial environment setup (you should already have this done)

pip install ipython pip install jinja2 pip install cherrypy

There are a few important additions!!

We're going to use memcache as our storage backend for this app. This requires that we install memcached, and a Python library called pylibmc: pip install pylibmc Linux: apt-get install libmemcached-dev apt-get install memcached Mac: brew install memcached

Important note to Mac users:

If you receive an error referencing a failure in the llvm-gcc-4.2 library when attempting to install pylibmc, please try the following: brew link libevent brew install libmemcached sudo pip install pylibmc

Raise your hand if you were not able to install memcached and/or pylibmc successfully!

IPython: Initial debugging

my-computer:~ sandy$ ipython In [1]: import urllib4 -------------------------------------------------------ImportError Traceback (most recent call last) <ipython-input-1-87716ee6ccca> in <module>() ----> 1 import urllib4 ImportError: No module named urllib4

IPython
? operator %who and %whos %hist %pdb More details: http://pages.physics.cornell.
edu/~myers/teaching/ComputationalMethods/python/ipy thon.html

So what is IPython, anyway?

It's a gussied up version of the standard Python interpreter. Python is an interpreted language. This means that the interpreter executes the program source code directly, statement by statement. In comparison, compiled languages (like C) must be explicitly translated into a lower-level machine language executable.

Brief Intro to Python Data Types

Integers Strings Lists Tuples Dictionaries

Integers and basic math

In [6]: 2 + 2 Out[6]: 4 In [7]: 3 * 3 Out[7]: 9 In [8]: 2**3 Out[8]: 8 In [9]: 4/2 Out[9]: 2 In [11]: 2%4 Out[11]: 2

Strings
In [1]: my_name = "Sandy Strong" In [2]: print my_name Sandy Strong Now type, "my_name." and hit the tab key: In [3]: my_name. my_name.capitalize my_name.center my_name.count my_name.decode my_name.encode <snip>

Useful string methods

strip
strips leading/trailing whitespace

upper
makes all characters upper case

lower
makes all characters lower case

split
splits string into a list, whitespace delimited

find
search for a string within your string

startswith
test for what your string starts with

String formatting
You can pass variables into strings to format them in a specific way, for example:
In [14]: age = 28 In [15]: name = 'Sandy' In [16]: print "Hello, my name is %s." % name Hello, my name is Sandy. In [17]: print "Hello, my name is %s, and I'm %s years old." % (name, age) Hello, my name is Sandy, and I'm 28 years old.

Lists
[2]: items = ['bacon', 3.14, ['bread', 'milk'] ] In [3]: print items ['bacon', 3.14, ['bread', 'milk']]

You can put lists (and other Python data types) inside of lists.

Useful list methods

insert
provide index position and item to be inserted into the list

append
append an item to the end of your list

pop
provide index position to "pop" an item out of your list

Tuples
In [12]: colors = ('red', 'blue', 'green') In [13]: print colors ('red', 'blue', 'green')

Tuples are immutable. Once they're created, they cannot be changed. Because they are immutable, they are hashable.

What does "hashble" mean?

An object is hashable if it has a hash value which never changes during its lifetime. If we run a hashing algorithm on a tuple, it will return to us the hash value for that object. If we ran that same algorithm again on the same tuple, it would be identical-- because a tuple is immutable (it's values cannot change after it is defined).

Useful tuple methods

index
provide an item in your tuple, and it returns the index position for that item

Dictionaries
In [1]: favorite_sports = {'John': 'Football', 'Sally': 'Soccer'} In [2]: print favorite_sports {'John': 'Football', 'Sally': 'Soccer'}

The first parameter is the "key" and the second parameter is the "value". A dictionary can have as many key/value pairs as you wish, and keys are immutable.

Useful dictionary methods

get
retrieves the value of the given key or returns None if the key doesn't exist in the dictionary

values
all values in your dictionary

keys
all keys in your dictionary

items
list of 2-element tuples that correspond to the key/value pairs in your dictionary

update
add a new key/value pair to your dictionary

Wait, what is None?

It's a Python built-in constant that is frequently used to represent the absence of a value. None is Python's version of NULL. In [1]: None == None Out[1]: True

Incrementing and Decrementing Values

# increment counter += 1 # decrement counter -= 1

Introduction to Python Loops, Code Blocks, and Boolean Logic

for while BUT before we can jump into loops....

... we have to talk about whitespace awareness

Python is a "whitespace aware" programming language. This simply means that, within a code block, Python expects uniform indentation, the standard is 4 spaces. What defines a code block? Let's try out some loops and find out...

For loops: "for each item in x, do y"

In [1]: items = ['socks', 'shoes', 'shirt', 'pants'] In [2]: for x in items: ...: print x ...: socks shoes shirt pants The green highlighted code represents a code block. See how the line "print x" is indented in 4 spaces from the line "for x in items:"? IPython does this for you, when coding outside of IPython, you must make your own indentations.

What happens if I don't indent?

In [1]: items = ['socks', 'shoes', 'shirt', 'pants'] In [2]: for x in items: ...: print x ...: IndentationError: expected an indented block

I highly recommend this article explaining whitespace further:

http://www.secnetix.de/olli/Python/block_indentation.hawk

Now that that's out of the way, let's move on!

Enough boolean logic for this tutorial:

In [3]: True == True Out[3]: True In [4]: False == True Out[4]: False In [5]: False == False Out[5]: True In [6]: not False == True Out[6]: True In [7]: not True == False Out[7]: True For more practice with booleans in Python, I highly recommend the Boolean Practice chapter from Zed Shaw's Learn Python the Hard Way.

While loops: "while x is true, do y"

In [4]: counter = 3 In [5]: while counter >= 0: ...: print counter ...: # decrement the counter ...: counter -= 1 ...: 3 2 1 0 This while-loop will continue to execute until the condition "counter >= 0" no longer evaluates to True.

Watch out for infinite loops!

In programming, an infinite loop is a loop of code which your program enters, but never returns from. While-loops can be tricky, because they continue running while a condition remains True. The slightest logic error can lead to an infinite while-loop. For-loops are less prone to infinity because they operate on iterable objects (lists, strings, dictionaries), which are finite by nature.

Basic Control Flow Tools

These are the keywords you need to know: if else elif In Python we use the above keywords to control flows within our program. Depending on which condition is met (evaluates to True) within a block of control flow code, we may want our application to behave differently.

Comparison operators
Equal to: == Less than: < Greater than: > Less than or equal to: <= Greater than or equal to: >=

Let's try it out...

if and else
In [70]: age = 20 In [71]: if age <= 20: ....: print "You're old enough!" ....: You're old enough!

In [72]: if age > 20: ....: print "You're too old!" ....: else: ....: print "You're the right age." ....: You're the right age.

Using elif
The elif keyword allows you to expand your control flow block, and perform additional comparisons within an if-else statement.
In [74]: if age < 20: ....: print "You're too young." ....: elif age >= 20: ....: print "You're the right age!" ....: You're the right age!

List comprehensions: magical!

In [75]: user_pets = {'Sandy': 'Dog', 'Katharine': 'Snake', 'Bob': 'Mouse', 'Sally': 'Fish'} In [76]: pet_list = [ v for k,v in user_pets.iteritems()] In [77]: print pet_list Out[77]: ['Snake', 'Mouse', 'Fish', 'Dog'] Python programmers pride themselves on writing tight, legible, efficient code. List comprehensions are a great example of that.

Using control flow and conditionals in list comprehensions

In [77]: user_pets = {'Sandy': 'Dog', 'Katharine': 'Snake', 'Bob': 'Mouse', 'Sally': 'Fish'} In [78]: pet_list = [ v for k,v in user_pets.iteritems() if k != 'Bob'] In [79]: print pet_list ['Snake', 'Fish', 'Dog']

We will only add the pet to pet_list if the user is not Bob.

Writing Python functions

In [6]: def hello_world(user='John'): ...: """ This is a docstring """ ...: message = "Hello, %s!" % user ...: return message ...: In [7]: my_message = hello_world(user='Sandy') In [8]: print my_message Hello, Sandy!

*args and **kwargs

In addition to single or comma-separated arguments, you can also pass lists or dictionaries of parameters into Python functions
def function(*args): # Expects something like: # ['he', 'she', 'it'] def function(**kwargs): # Expects something like: #{'me': 'you', 'we': they'}

We'll revisit this later when we build our app!

A word about import statements

Python has an extensive standard library, filled with very useful modules that will prevent you from having to write boilerplate code.
# import the random library In [60]: import random # Print a random intiger between 1 and 5: In [61]: print random.randint(1,5) 4

Put import statements at the top of your file.

Intro to Python classes

# import the imaginary 'cars' module import cars class MyCar: ''' This class defines a car object ''' # member variables go here make = "Honda" model = "Civic" # class methods go here def car_color(self, clr="black"): self.color = cars.paint(clr) return True def tire_type(self, type="standard"): self.tires = cars.tire(type) return True

Wait-- what exactly is a class in Python?

In object-oriented programming, a class is a construct that is used to create instances of itself, called class objects. A class defines constituent members which enable its instances to have state and behavior. Data field members (member variables) enable a class instance to maintain state. Other kinds of members, especially methods, enable the behavior of class instances.
http://en.wikipedia.org/wiki/Class_(computer_programming)

Ok, so how do I use the MyCar class?

>>> import MyCar >>> car = MyCar() >>> print car.make Honda >>> print car.model Civic >>> car.car_color() >>> print car.color black >>> car.tire_type(type="sport") >>> print car.tires sport

Be aware of the __init__ method

There's a special method, named __init__ , that is implicitly defined when you create a new class. By default, __init__ is empty and does nothing special. In some cases, you will want to override this method to have it do something in particular, you can do that by simply defining it at the top of your class: class MyCar: def __init__(): # do stuff here!

Methods vs. Functions

In Python, what we call a "method" is actually a member function of a class. A standalone function that belongs to no class, is simply referred to as a "function".

Web Coding in Python

(it's the best, we promise!)

Intro to MVC (Model View Controller)

This is a design pattern followed by most modern web frameworks.
Models: Models represent knowledge-- they can can represent a single object, or a structure of objects. Views: A view is a visual representation of its model. A view typically highlights certain attributes of the model, and suppresses others-- it is a presentation filter. Controllers: A controller is the link between a user and the system. It provides the user with input by arranging for relevant views to present themselves in appropriate places on the screen, and provides means for user output by presenting the user with menus or other means of giving commands and data.
http://www.codinghorror.com/blog/2008/05/understanding-model-view-controller.html

Real world example

Model: User View: Profile page Controller: "Change password" functionality user is represented by a model specific user model data is presented by a view on the profile page for that user functionality allowing a user to change his password-- interact with the model-- is handled by a controller

What is WSGI (whiskey)?

The Web Server Gateway Interface defines a simple and universal interface between web servers and web applications or frameworks for the Python programming language. WSGI is what lets your Python web application talk to web servers like Apache and Nginx.

ORM - Object Relational Mapper

ORM's are libraries that allow your application code to interact with objects in the datastore. CherryPy doesn't have a native ORM, so we will be writing our own simple ORM that will allow us to perform CRUD (Create, Read, Update, and Delete) operations. We will be using memcache, a volatile inmemory datastore, as our backend.

Are there any questions before we start building our project?

CherryPy Setup
You should already have all libraries installed and working on your computer. We will be creating a Poll web application. You will be able to create and edit polls, add and edit choices, and vote on the poll. The first step is to create a directory on your computer named my-cherrypy-poll: mkdir my-cherrypy-poll

Grab the app code from Github, you'll need it later:

If you have git installed:
git clone git://github.com/kjam/cherrypy-poll.git

If you do not have git installed, please review the instructions from our tutorial wiki:
https://us.pycon.org/2013/community/tutorials/5/

db_tools.py: Our ORM

import pylibmc def get_mc(): ''' Get a memcache connection object ''' mc = pylibmc.Client(['127.0.0.1:11211']) return mc def get_value(key): ''' Retrieve value for the given key ''' mc = get_mc() val = mc.get(key) # delete the mc connection object del mc return val

db_tools.py (continued)
def set_value(key,value): ''' Set a given key/value pair in mc ''' mc = get_mc() mc.set(key,value) del mc return True def del_value(key): ''' Delete a key/value pair from mc ''' mc = get_mc() mc.delete(key) del mc return True

What do we have so far?

We've got a simple ORM module, composed of functions that allow us to:
connect to our locally-running memcache instance retrieve values from memcache based on their key set key/value pairs in memcache delete key/value pairs from memcache

We leveraged methods from pylibmc to build our ORM. This library allows Python to easily talk to memcache.

Note our use of pylibmc functions:

def get_value(key): # get value from mc using supplied key val = mc.get(key) def set_value(key,value): # set supplied key/value into mc mc.set(key,value) def del_value(key): # del key/val from mc using supplied key mc.delete(key)

Questions so far?

utils.py: Our "helper function"

import re from unicodedata import normalize

_punct_re = re.compile(r'[\t !"#$%&\'()*\-/<=>?@\[\\\]^_`{|},.]+') def slugify(text, delim=u'-'): """Generates an ASCII-only slug.""" result = [] for word in _punct_re.split(text.lower()): word = normalize('NFKD', word).encode('ascii', 'ignore') if word: result.append(word) return str(delim.join(result))

Notice our usage of string functions (lower, split)!

What is "slugify"?
Suppose a user created a poll named:
"My favorite food is oranges, what is yours? "

This slugify function converts this poll name to:

my-favorite-food-is-oranges-what-is-yours

Why? Prettier URLs, more SEO-friendly, handy unique identifier for the record in the datastore.

Notes on the slugify function

The variable _punct_re: Python does not formally enforce public/private variables or functions. An underscore preceding an object name indicates that the programmer should respect this object and treat it as private.

Normalizing unicode
Unicode is great-- it represents a much larger character set than ASCII. However, it can be challenging to work with. For the purpose of storing slugs in our datastore, it's simpler if we normalize our slug string to only ASCII characters. This code normalizes the string, replacing unicode characters with their ASCII equivalent, and then encodes the string in ASCII format, ignoring any errors raised during the encoding process:
normalize('NFKD', word).encode('ascii', 'ignore')

For a production web application, you would want to use a more robust method for slugifying your Poll names.

How might we organize our data?

Open up initial_json.py:
poll_dict = { 'my-question-slug': { 'question': 'My question is le awesome, no?', 'slug':'my-question-is-le-awesome-no', 'choices': [ { 'id':1, 'text':'yep', 'value':0, }, { 'id':2, 'text':'nerp', 'value':0, }, 'publish': True, }

models.py
The models.py file in a Python application is often used to define class types and create and inherit model instances. In our application, we are essentially using the theory of this to help manipulate data within our memcache datastore. We will use our models to edit and create "poll" instances which we update in our memcache storage.

def add_poll(**kwargs): choices_arr = [] count = 1 poll_dict = {} poll_dict['question'] = kwargs.get('question') for k,v in kwargs.items(): if 'choice' not in k: continue choice_dict = { 'id': count, 'text': v, 'value': 0 } choices_arr.append(choice_dict) count += 1 slug = slugify(kwargs.get('question')) poll_dict['slug'] = slug poll_dict['choices'] = choices_arr set_value(slug,poll_dict) if kwargs.get('publish'): publish_poll(slug)

We grab the poll from kwargs, and then if choices are present, we build out a choice_dict of the choices associated with that poll. The poll question gets slugified, and added to the poll_dict, and then a list containing the choices dictionary is added. to poll_dict. We call set_value and pass in the slug (unique key for the poll), and the contents of poll_dict. Finally, if kwargs contains a key named "publish" we publish the poll.

Now for edit_poll...

This is a big one!

def edit_poll(**kwargs): choices_arr = [] poll = get_poll(str(kwargs.get('slug'))) poll_dict = {} poll_dict['question'] = kwargs.get('question') for k,v in kwargs.items(): if 'choice' not in k: continue this_choice = [ c for c in poll.get('choices') if int(k.strip('choice')) == c.get('id') ] if not len(this_choice): return False else: this_choice = this_choice[0] choice_dict = { 'id': this_choice.get('id'), 'text': v, 'value': this_choice.get('value'), } choices_arr.append(choice_dict)

edit_poll (continued)
slug = str(kwargs.get('slug')) poll_dict['slug'] = slug poll_dict['choices'] = choices_arr set_value(slug,poll_dict) if kwargs.get('publish'): publish_poll(slug) else: unpublish_poll(slug) return poll_dict

The edit_poll function and add_poll functions have some similarities. They start to differ with the list comprehension used to assign this_choice. We build out this_choice using a conditional to validate that the id for the choice passed in is equivalent to the choice id on the poll object from memcache. From there, we build out the choice_dict , get slug from **kwargs , add slug and choices to the poll_dict , and set the value in memcache.

What did we just do?

We created a models file with two functions that allow us to: create and edit poll objects, as well as publish them if they are publishable (according to the editor). Remember, poll objects will be stored in memcache. We used our ORM functions from db_tools.py, and our slugify function from utils.py to help with this.

Any questions about slugs?

We're about to dive into views. There are a lot of views, and I'll explain each as we go along.

views.py: Presenting our model data

from db_tools import get_value, set_value, del_value from utils import slugify def cast_vote(poll_key,choice): poll = get_value(poll_key) for c in poll['choices']: if c['id'] == int(choice): c['value'] += 1 set_value(poll_key,poll) return poll

This is the view that allows visitors to vote on a poll. When executed, it accepts the poll_key (its unique identifier), and the choice that the user selected. The poll is retrieved from memcached, validated, and it's vote count is incremented in memcache.

views.py (continued)
def get_global_links(): return [{ 'name': 'Add a poll', 'url': '/polls/add', }, { 'name': 'Home', 'url': '/' }, { 'name': 'Poll list', 'url': '/polls', }]

This is essentially our site navigation. We return a list of dictionaries, each one containing a pretty name for the view, along with the url path where the view is located within our application. The view to "Add a poll" is mapped to the "/polls/add" url.

views.py (continued)
def get_poll(key): poll = get_value(key) return poll

Retrieve a specific poll from memcache, based on the key-- the slug-- for the poll.

views.py (continued)
def get_polls(): poll_list = [] published_polls = get_value('published_polls') if not published_polls: set_value('published_polls',[]) for p in published_polls: poll = get_value(p) poll_list.append(poll) return poll_list

Return the value from memcache with the key 'published_polls', loop through each poll id (slug), and retrieve the poll object for that id. Build a list of poll objects, and return them.

views.py (continued)
def publish_poll(key): published_polls = get_value('published_polls') if not published_polls: set_value('published_polls',[]) if key not in published_polls: published_polls.append(key) set_value('published_polls',published_polls)

For a given poll id (key), add it to the list of published_polls in memcache if it is not already there. Notice how we're using if-statements to perform validation on published_polls and the individual key we're attempting to add to the published_polls list.

views.py (continued)
def unpublish_polls(key): published_polls = get_value('published_polls') if not published_polls: set_value('published_polls',[]) if key in published_polls: published_polls.remove(key) set_value('published_polls',published_polls)

For a given poll id (key), remove it from list of published_polls in memcache, if it is currently published. Note again how we perform validation.

Whew! That was a lot of coding...

So, who has questions? ...I know someone must have a question! ... c'mon...

app.conf: Important app instructions

These configuration settings tell our app how and where we want it to run its server at. [global] server.socket_host = "127.0.0.1" server.socket_port = 8888 server.thread_pool = 10 When our app is complete and we fire it up, we'll be running on http://127.0.0.1:8888 with 10 worker threads.

app.py: Our main application code

This is another big file. Let's start with imports and environment setup, these go at the top:
import cherrypy from jinja2 import Environment,FileSystemLoader from db_tools import get_value,set_value,del_value from views import get_global_links,get_polls,get_poll,\ add_poll,edit_poll,cast_vote import os.path conf = os.path.join(os.path.dirname(__file__), 'app.conf') env = Environment(loader=FileSystemLoader('templates'))

env tells our app where to find templates at, and conf tells our app where to find the app.conf file.

app.py class 1: the PollViews class

class PollViews: @cherrypy.expose def index(self): data_dict = { 'title': 'Poll List', 'links': get_global_links(), 'polls': get_polls(), } templ = env.get_template('polls.html') return templ.render(data_dict) First, we define a class named PollViews. Then we write our index function, the default page for our app. There are some interesting things here, @cherrypy.expose, env. get_template, and templ.render. Everything else is pretty standard.

What are these things??

@cherrypy.expose The "@" indicates that this is a decorator. Decorators are commonly-used "syntactic sugar" in Python. They allow you to execute the function that @cherrypy.expose is decorating-- in this case, index--, to be passed into the cherrypy.expose function, where additional work is done. This decorator function is a standard part of the CherryPy microframework, and it allows objects passed into index to be traversable by the URL mapping routine. env.get_template('polls.html'), We get the polls.html template from our environment. Remember, we set up env at the top of our app.py file? templ.render(data_dict). We pass our data dictionary-- the attributes of our poll model that will be exposed in our view-- into the render method of our template object, templ.

You will observe these same patterns in other methods within the PollViews class.

app.py class 1 cont: the poll method

@cherrypy.expose def poll(self,key,choice=None): method = cherrypy.request.method.upper() poll = False data_dict = { 'title': 'Poll', 'links': get_global_links(), } if method == 'POST': data_dict['poll'] = cast_vote(key,choice) data_dict['success'] = True else: data_dict['poll'] = get_poll(key) templ = env.get_template('poll.html') return templ.render(data_dict) A little more CherryPy internal magic. Then, if the request is POST, we submit a vote to cast_vote. otherwise, we retrieve the poll to display for the user, get_poll. We then render the data_dict to our poll.html template.

app.py class 1 cont: the add method

@cherrypy.expose def add(self,**kwargs): method = cherrypy.request.method.upper() poll = False data_dict = { 'title': 'Add a poll', 'links': get_global_links(), } if method == 'POST': add_poll(**kwargs) data_dict['success'] = True templ = env.get_template('add_poll.html') return templ.render(data_dict)

This lets us add a poll to our datastore. If method is POST, we pass in **kwargs to add_poll, then we render the contents of our data_dict out to the add_poll.html template.

app.py: class 1 cont: the edit method

@cherrypy.expose def edit(self,key,**kwargs): method = cherrypy.request.method.upper() If method is POST, we poll = False pass **kwargs into data_dict = { edit_poll, then we 'title': 'Edit your poll', add poll to our 'links': get_global_links(), data_dict. } if method == 'POST': Otherwise, we call get_poll with the key poll = edit_poll(**kwargs) passed in to edit, and data_dict['poll'] = poll add that to our data_dict['success'] = True data_dict. else: data_dict['poll'] = get_poll(key) Finally, we render our templ = env.get_template('edit_poll.html')data_dict to edit_poll.html. return templ.render(data_dict)

app.py class 2: the PollApp class

class PollApp: polls = PollViews() @cherrypy.expose def index(self): data_dict = { 'title': 'Welcome to the poll application!', 'links': get_global_links(), } templ = env.get_template('index.html') return templ.render(data_dict) polls is a member variable of the PollApp class, and it is an instance of the PollViews class. The PollApp class has one method, index. This method has a simple data_dict, which is rendered out to index.html.

app.py: The last bit! Let's make our app "go"!

This goes at the very bottom of app.py: if __name__ == '__main__': cherrypy.quickstart(PollApp(), config=conf) else: cherrypy.tree.mount(PollApp(), config=conf) When we run our CherryPy app, Python sees this as the "__main__" function.

Congratulations! You've completed writing your Python code for this app!

App Homework!
Raise an error if a user enters bad data into the form Use the unpublish_polls function in the application to properly unpublish polls Use CherryPy Sessions to validate that each user can only vote once http://docs.cherrypy.
org/dev/refman/lib/sessions.html

Allow users to add more than 4 choices to a poll using a more dynamically generated form

Don't forget the templates!

Within your my-cherrypy-poll directory, create another directory named templates. In the interest of time, we won't be typing out all of the HTML, however, we will go over the highlights and important template syntax. Remember, we're using the jinja2 library to drive templates in our app.

add_poll.html
<html> <head> </head> <body> <h1> {{title}}</h1> <h2>Add a poll</h2> <form action= "/polls/add" method= 'POST'> Question: <input type="text" name="question" value=""><br> Choice 1: <input type="text" name="choice1" value=""><br> Choice 2: <input type="text" name="choice2" value=""><br> Choice 3: <input type="text" name="choice3" value=""><br> Choice 4: <input type="text" name="choice4" value=""><br> Publish? <input type="checkbox" name="publish" value="checked"><br> <input type="submit" value="Add poll"> </form> {% for l in links %} <span><a href=" {{l.url}}">{{l.name}}</a></span> {% endfor %}

Some things to note

We use pairs of double braces-- {{ }} -- to surround a variable passed into the template from our view. When calling a method that posts data to our server, we specify POST as the method inside our form. We are able to use for-loops, and reference attributes on our objects (each link in links, has both a url and a name attribute):
{% for l in links %} <span><a href=" {{l.url}}">{{l.name}}</a></span> {% endfor %}

edit_poll.html
<html> <head></head> <body> <h1> {{title}}</h1> <h2>Edit your poll</h2> <form action=" /polls/edit/{{poll.slug}}" method= 'POST'> Question: <input type="text" name="question" value=" {{poll.question}}" ><br> {% for c in poll.choices %} Choice {{c.id}}: <input type="text" name="choice {{c.id}}" value=" {{c. text}}"><br> {% endfor %} Publish? <input type="checkbox" name="publish" checked=" {% if poll. published %}checked {% endif %}"><br> <input type="hidden" name="slug" value=" {{poll.slug}}"> <input type="submit" value="Edit poll"> </form> {% for l in links %} <span><a href=" {{l.url}}">{{l.name}}</a></span> {% endfor %} </body> </html>

index.html
<html> <head> </head> <body> <h1> {{title}}</h1> <p>Welcome to the polls app. Feel free to add a poll or answer some questions! :)</p> {% for l in links %} <span><a href=" {{l.url}}">{{l.name}}</a></span> {% endfor %} </body> </html>

poll.html
<html> <head></head> <body> <h1> {{title}}</h1> <h2>Poll: {{poll.question}}</h2> {% if success %} <p>Thanks for voting!</p> <h3>Results</h3> {% for c in poll.choices %} <p> {{c.text}}: {{c.value}}</p> {% endfor %} {% else %} <form action=" /polls/poll/{{poll.slug}}" method= 'POST'> {% for c in poll.choices %} <input type="radio" name="choice" value=" {{c.id}}">{{c.text}}<br> {% endfor %} <input type="submit" value="Vote"> </form> {% endif %} {% for l in links %} <span><a href=" {{l.url}}">{{l.name}}</a></span> | {% endfor %} </body></html>

polls.html
<html> <head></head> <body> <h1>{{title}}</h1> <h2>Polls</h2> <ul> {% for p in polls %} <li><a href="/polls/poll/{{p.slug}}">{{p.question}} </a></li> {% endfor %} </ul> {% for l in links %} <span><a href="{{l.url}}">{{l.name}}</a></span> {% endfor %} </body> </html>

What we've learned about templates:

jinja2 allows us to do some powerful things:
Reference variables passed into our template with double-braces: Ex. {{ title }} Reference attributes on variables passed in to the template: Ex. poll.choices Use for-loops: for ... endfor Use control flow structures: if ... endif

Pretty cool, right?

Now, bring in the templates!

Copy the contents of the templates directory from the cherrypy-polls code you downloaded earlier, into the templates directory that you just created in your own version of the app, my-cherrypy-polls.

Fire up the app and play with it

To start your polls app, execute the following command in your terminal, from within the mycherrypy-polls directory: python app.py NOTE: We are running a development server. This method is not suitable for a production environment.

Testing
(/me facepalms)

Testing: What it is and why we do it

"Code not tested is broken by design" - JKM We test our code to determine whether or not it is fit for use. Why, specifically, do we do it? Saves money Saves development time Happier developers Saves on QA time Confidence

Writing Tests
Unit Tests Mocking Request/Response Mocking Objects

Unit Tests vs. Mock Tests

Units: A method by which individual units of source code are tested. A unit is the smallest testable part of an application, like an individual function. Mocks: You can mock the creation, updating, and deletion of request and response objects-- and much more. This type of testing is good for making sure your app behaves in a sane fashion for your users. The mock library is a great tool for doing this.

Unfortunately...
... we don't have time to go into testing in-depth during this tutorial. We want you guys to come away with: Understanding of why writing tests is so important A basic understanding of how tests might be written Resources that inspire you to write your own tests!

Using the Python unittest library

import random import unittest class TestSequenceFunctions(unittest.TestCase): def setUp(self): self.sequence = range(10) def test_choice(self): element = random.choice(self.sequence) self.assertTrue(element in self.sequence) if __name__ == '__main__': unittest.main()

Using the mock library

But first, some sample application code...

class BlogLogin(object): def __init__(self, login, password): self._blogin = Blog(login, password) def my_subscriptions(self): return self._subs(self._blogin.subs(self._blogin.login) def _subs(self, call): crs = -1 results = [] while crs != 0: page = call(crs) subscriptions = page['subscriptions'] crs = page['next_cursor'] results.extend(subscriptions) return results

Mock class to test the sample code...

import BlogLogin import mock class BlogLoginTest(unittest.TestCase): def test_all_subs(self): """Verify that my subscriptions load""" bl = BlogLogin('username', 'password') bl._blogin = Mock() bl._subs.blogin.subs.return_value = \ {subs:[{'a':1}], 'next_cursor':0} result = bl.my_subscriptions() bl._blogin.subs.my_subscriptions.assert_called_with( cursor = -1) self.assertEquals([{'a':1}], result)

Testing homework:
Your app should be well-tested! After PyCon, go home and write a test suite using unittest and mock, you can find great documentation here:
Python unittest Documentation Mock Library Documentation

Errors
(FML)

Python Errors and Exception class

Syntax errors
whitespace violations or other parsing errors

Exceptions:
Python has built-in exceptions that can be caught or raised Alternatively, you can write your own exception classes specific to your application

Catching exceptions
try: # Try to get "my-first-poll" from memcache return get_value('my-first-poll') except KeyError: # If the key is not found in memcache, # return an empty dictionary instead return {} Catching exceptions is useful when you can anticipate what exception might occur, and have the application do something else instead of raising the exception. In this case, if our key is not found, we want our app to return an empty dictionary.

Raising exceptions
If you do not attempt to catch an exception, then Python will raise it automatically. There are many cases where you can catch an exception and mitigate the negative impact for users. However, there are some exceptions that you can never programmatically predict-- and those bubble up into your application error log.

Exception homework:
Go through your completed my-cherrypy-poll app and find places that are missing exceptions. Put in your own try/catch blocks, and then try writing your own custom exception classes:
Python Built-In Exceptions Creating User-Defined Exception Classes

While we're talking about errors...

I want to introduce you to a valuable debugging tool that's part of Python's standard library, pdb. Let's try it out really quickly in IPython:
In [8]: def my_fnc(val1, val2, val3): ...: import pdb; pdb.set_trace() ...: if val1 > val2: ...: print val1 ...: elif val3 < val2: ...: print val2 ...: else: ...: print val3 In [10]: my_fnc(1, 2, 3) > <ipython-input-8-1f89e51121c6>(3)my_fnc() -> if val1 > val2: (Pdb) n

Basic pdb commands

A few options to enter at the pdb prompt:
l = print out lines above/below your cursor n = continue to next line s = step into a function

You can find the full pdb documentation here. Have fun, and happy bug hunting!

Briefly, on server errors

Server Errors: What are they?
http://en.wikipedia.org/wiki/List_of_HTTP_status_codes Use them to handle exceptions or proper situation handling (sorry, I can't find what you're looking for: 404. sorry, you can't see that: 403)

Throwing Server Errors

Each framework has their own way of throwing server errors http://docs.cherrypy.org/stable/refman/_cperror.html#classes

A few more goodies from Python's stdlib

Date object creation and manipulation import datetime Hashing algorithm toolbox import hashlib Encoding and decoding JSON objects import json More advanced math import math Web requests made easy (check out the Missing Manual) import urllib2 Accepting user input to a script import sys

Conclusions
(what did we learn?)

Whew!
Today we gave you a whirlwind tour of basic Python, and we're hoping it's enough to get you guys hooked! We covered data types, loops, control flow statements, conditionals, functions, classes, testing, error handling, debugging, and more!

A few more resources for devs:

Docs:
Official Python Documentation Stack Overflow

IRC:
Freenode #python channel

Cool stuff:
Github

Questions?

Thank you so much for attending our tutorial, we hope you enjoyed it!