Python Cheat Sheet

by TELUGU GYAAN
 Dictionaries store connections between pieces of
List comprehensions information. Each item in a dictionary is a key-value pair.
squares = [x**2 for x in range(1, 11)]
A simple dictionary
Slicing a list alien = {'color': 'green', 'points': 5}
finishers = ['sam', 'bob', 'ada', 'bea']
Accessing a value
first_two = finishers[:2]
print("The alien's color is " + alien['color'])
Variables are used to store values. A string is a series of Copying a list
characters, surrounded by single or double quotes. Adding a new key-value pair
copy_of_bikes = bikes[:]
Hello world alien['x_position'] = 0
print("Hello world!") Looping through all key-value pairs
Hello world with a variable Tuples are similar to lists, but the items in a tuple can't be fav_numbers = {'eric': 17, 'ever': 4}
modified. for name, number in fav_numbers.items():
msg = "Hello world!"
print(name + ' loves ' + str(number))
print(msg) Making a tuple
Concatenation (combining strings) dimensions = (1920, 1080) Looping through all keys
fav_numbers = {'eric': 17, 'ever': 4}
first_name = 'albert'
for name in fav_numbers.keys():
last_name = 'einstein'
print(name + ' loves a number')
full_name = first_name + ' ' + last_name If statements are used to test for particular conditions and
print(full_name) respond appropriately. Looping through all the values
Conditional tests fav_numbers = {'eric': 17, 'ever': 4}
for number in fav_numbers.values():
equals x == 42 not equal
A list stores a series of items in a particular order. You print(str(number) + ' is a favorite')
access items using an index, or within a loop. x != 42 greater than x >
42
Make a list or equal to x >= 42
less than x < 42 Your programs can prompt the user for input. All input is
bikes = ['trek', 'redline', 'giant'] or equal to x <= 42 stored as a string.
Get the first item in a list Conditional test with lists Prompting for a value
first_bike = bikes[0] 'trek' in bikes name = input("What's your name? ")
Get the last item in a list 'surly' not in bikes print("Hello, " + name + "!")
last_bike = bikes[-1] Assigning boolean values Prompting for numerical input
Looping through a list game_active = True age = input("How old are you? ")
can_edit = False
for bike in bikes: age = int(age)
print(bike) A simple if test
pi = input("What's the value of pi? ")
Adding items to a list if age >= 18:
pi = float(pi)
print("You can vote!")
bikes = []
bikes.append('trek') If-elif-else statements
bikes.append('redline') if age < 4:
bikes.append('giant') ticket_price = 0
Making numerical lists elif age < 18:
ticket_price = 10
squares = [] else:
for x in range(1, 11): ticket_price = 15
squares.append(x**2)
A while loop repeats a block of code as long as a certain A class defines the behavior of an object and the kind of Your programs can read from files and write to files. Files
condition is true. information an object can store. The information in a class are opened in read mode ('r') by default, but can also be
is stored in attributes, and functions that belong to a class opened in write mode ('w') and append mode ('a').
A simple while loop are called methods. A child class inherits the attributes and
methods from its parent class. Reading a file and storing its lines
current_value = 1
while current_value <= 5: filename = 'siddhartha.txt'
Creating a dog class
print(current_value) with open(filename) as file_object:
current_value += 1 class Dog(): lines = file_object.readlines()
"""Represent a dog."""
Letting the user choose when to quit for line in lines:
def __init__(self, name):
msg = '' print(line)
while msg != 'quit': """Initialize dog object."""
self.name = name Writing to a file
msg = input("What's your message? ")
print(msg) filename = 'journal.txt'
def sit(self):
with open(filename, 'w') as file_object:
"""Simulate sitting.""" file_object.write("I love programming.")
print(self.name + " is sitting.")
Functions are named blocks of code, designed to do one Appending to a file
specific job. Information passed to a function is called an my_dog = Dog('Peso')
argument, and information received by a function is called a filename = 'journal.txt'
parameter. print(my_dog.name + " is a great dog!") with open(filename, 'a') as file_object:
file_object.write("\nI love making games.")
my_dog.sit()
A simple function
def greet_user(): Inheritance
"""Display a simple greeting.""" class SARDog(Dog): Exceptions help you respond appropriately to errors that
print("Hello!") """Represent a search dog.""" are likely to occur. You place code that might cause an
greet_user() error in the try block. Code that should run in response to
def __init__(self, name): an error goes in the except block. Code that should run only if
the try block was successful goes in the else block.
Passing an argument """Initialize the sardog."""
super().__init__(name)
def greet_user(username): Catching an exception
"""Display a personalized greeting.""" def search(self): prompt = "How many tickets do you need? "
print("Hello, " + username + "!") """Simulate searching.""" num_tickets = input(prompt)
print(self.name + " is searching.")
greet_user('jesse') try:
my_dog = SARDog('Willie') num_tickets = int(num_tickets)
Default values for parameters
except ValueError:
def make_pizza(topping='bacon'): print(my_dog.name + " is a search dog.") print("Please try again.")
"""Make a single-topping pizza.""" my_dog.sit() else:
print("Have a " + topping + " pizza!") my_dog.search() print("Your tickets are printing.")

make_pizza()
make_pizza('pepperoni')
If you had infinite programming skills, what would you Simple is better than complex
Returning a value build?
If you have a choice between a simple and a complex
def add_numbers(x, y): As you're learning to program, it's helpful to think solution, and both work, use the simple solution. Your
"""Add two numbers and return the sum.""" about the real-world projects you'd like to create. It's code will be easier to maintain, and it will be easier
return x + y a good habit to keep an "ideas" notebook that you for you and others to build on that code later on.
sum = add_numbers(3, 5) can refer to whenever you want to start a new project.
print(sum) If you haven't done so already, take a few minutes
and describe three projects you'd like to create.
 You can add elements to the end of a list, or you can insert The sort() method changes the order of a list permanently.
them wherever you like in a list. The sorted() function returns a copy of the list, leaving the
original list unchanged. You can sort the items in a list in
Adding an element to the end of the list alphabetical order, or reverse alphabetical order. You can
also reverse the original order of the list. Keep in mind that
users.append('amy')
lowercase and uppercase letters may affect the sort order.
Starting with an empty list
Sorting a list permanently
users = []
A list stores a series of items in a particular order. users.append('val') users.sort()
Lists allow you to store sets of information in one users.append('bob')
Sorting a list permanently in reverse
place, whether you have just a few items or millions users.append('mia')
alphabetical order
of items. Lists are one of Python's most powerful
Inserting elements at a particular position
features readily accessible to new programmers, and users.sort(reverse=True)
they tie together many important concepts in users.insert(0, 'joe')
Sorting a list temporarily
program m ing. users.insert(3, 'bea')
print(sorted(users))
print(sorted(users, reverse=True))

Use square brackets to define a list, and use commas to You can remove elements by their position in a list, or by Reversing the order of a list
separate individual items in the list. Use plural names for the value of the item. If you remove an item by its value,
users.reverse()
lists, to make your code easier to read. Python removes only the first item that has that value.

Making a list Deleting an element by its position

users = ['val', 'bob', 'mia', 'ron', 'ned'] del users[-1] Lists can contain millions of items, so Python provides an
efficient way to loop through all the items in a list. When
Removing an item by its value you set up a loop, Python pulls each item from the list one
users.remove('mia') at a time and stores it in a temporary variable, which you
provide a name for. This name should be the singular
Individual elements in a list are accessed according to their
version of the list name.
position, called the index. The index of the first element is
The indented block of code makes up the body of the
0, the index of the second element is 1, and so forth.
loop, where you can work with each individual item. Any
Negative indices refer to items at the end of the list. To get If you want to work with an element that you're removing lines that are not indented run after the loop is completed.
a particular element, write the name of the list and then the from the list, you can "pop" the element. If you think of the
index of the element in square brackets. list as a stack of items, pop() takes an item off the top of the
stack. By default pop() returns the last element in the list, Printing all items in a list
Getting the first element but you can also pop elements from any position in the list. for user in users:
first_user = users[0] print(user)
Pop the last item from a list
Getting the second element most_recent_user = users.pop() Printing a message for each item, and a
print(most_recent_user) separate message afterwards
second_user = users[1]
for user in users:
Getting the last element Pop the first item in a list
print("Welcome, " + user + "!")
newest_user = users[-1] first_user = users.pop(0)
print(first_user) print("Welcome, we're glad to see you all!")

Once you've defined a list, you can change individual

elements in the list. You do this by referring to the index of The len() function returns the number of items in a list.
the item you want to modify.
Find the length of a list
Changing an element num_users = len(users)
users[0] = 'valerie' print("We have " + str(num_users) + " users.")
users[-2] = 'ronald'
You can use the range() function to work with a set of To copy a list make a slice that starts at the first item and A tuple is like a list, except you can't change the values in a
numbers efficiently. The range() function starts at 0 by ends at the last item. If you try to copy a list without using tuple once it's defined. Tuples are good for storing
default, and stops one number below the number passed to this approach, whatever you do to the copied list will affect information that shouldn't be changed throughout the life of
it. You can use the list() function to efficiently generate a the original list as well. a program. Tuples are designated by parentheses instead
large list of numbers. of square brackets. (You can overwrite an entire tuple, but
Making a copy of a list you can't change the individual elements in a tuple.)
Printing the numbers 0 to 1000 finishers = ['kai', 'abe', 'ada', 'gus', 'zoe'] Defining a tuple
for number in range(1001): copy_of_finishers = finishers[:]
print(number) dimensions = (800, 600)

Printing the numbers 1 to 1000 Looping through a tuple

for number in range(1, 1001): You can use a loop to generate a list based on a range of for dimension in dimensions:
numbers or on another list. This is a common operation, so print(dimension)
print(number)
Python offers a more efficient way to do it. List
Making a list of numbers from 1 to a million comprehensions may look complicated at first; if so, use the Overwriting a tuple
for loop approach until you're ready to start using
numbers = list(range(1, 1000001)) comprehensions. dimensions = (800, 600)
To write a comprehension, define an expression for the print(dimensions)
values you want to store in the list. Then write a for loop to
generate input values needed to make the list. dimensions = (1200, 900)
There are a number of simple statistics you can run on a list
containing numerical data. Using a loop to generate a list of square numbers
Finding the minimum value in a list squares = [] When you're first learning about data structures such as
ages = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77]
for x in range(1, 11): lists, it helps to visualize how Python is working with the
youngest = min(ages) square = x**2 information in your program. pythontutor.com is a great tool
squares.append(square) for seeing how Python keeps track of the information in a
Finding the maximum value list. Try running the following code on pythontutor.com, and
Using a comprehension to generate a list of then run your own code.
ages = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77] square numbers
oldest = max(ages)
squares = [x**2 for x in range(1, 11)] Build a list and print the items in the list
Finding the sum of all values dogs = []
Using a loop to convert a list of names to upper case dogs.append('willie')
ages = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77]
names = ['kai', 'abe', 'ada', 'gus', 'zoe'] dogs.append('hootz')
total_years = sum(ages)
dogs.append('peso')
upper_names = [] dogs.append('goblin')
for name in names: for dog in dogs:
You can work with any set of elements from a list. A portion upper_names.append(name.upper())
of a list is called a slice. To slice a list start with the index of print("Hello " + dog + "!")
the first item you want, then add a colon and the index after Using a comprehension to convert a list of names print("I love these dogs!")
the last item you want. Leave off the first index to start at to upper case
the beginning of the list, and leave off the last index to slice print("\nThese were my first two dogs:")
names = ['kai', 'abe', 'ada', 'gus', 'zoe']
through the end of the list. old_dogs = dogs[:2]
for old_dog in old_dogs:
upper_names = [name.upper() for name in names]
Getting the first three items print(old_dog)
finishers = ['kai', 'abe', 'ada', 'gus', 'zoe'] del dogs[0]
first_three = finishers[:3] dogs.remove('peso')
Readability counts print(dogs)
Getting the middle three items
Use four spaces per indentation level.
middle_three = finishers[1:4]
 Keep your lines to 79 characters or fewer.
Getting the last three items Use single blank lines to group parts of your
program visually.
last_three = finishers[-3:]
 You can store as many key-value pairs as you want in a You can loop through a dictionary in three ways: you can
dictionary, until your computer runs out of memory. To add loop through all the key-value pairs, all the keys, or all the
a new key-value pair to an existing dictionary give the name values.
of the dictionary and the new key in square brackets, and A dictionary only tracks the connections between keys
set it equal to the new value. and values; it doesn't track the order of items in the
This also allows you to start with an empty dictionary and dictionary. If you want to process the information in order,
add key-value pairs as they become relevant. you can sort the keys in your loop.

Adding a key-value pair Looping through all key-value pairs

alien_0 = {'color': 'green', 'points': 5} # Store people's favorite languages.
fav_languages = {
alien_0['x'] = 0 'jen': 'python',
Python's dictionaries allow you to connect pieces of 'sarah': 'c',
alien_0['y'] = 25
related information. Each piece of information in a 'edward': 'ruby',
alien_0['speed'] = 1.5
dictionary is stored as a key-value pair. When you 'phil': 'python',
provide a key, Python returns the value associated Adding to an empty dictionary }
with that key. You can loop through all the key-value
alien_0 = {}
pairs, all the keys, or all the values. alien_0['color'] = 'green' # Show each person's favorite language.
alien_0['points'] = 5 for name, language in fav_languages.items():
print(name + ": " + language)

Use curly braces to define a dictionary. Use colons to Looping through all the keys
connect keys and values, and use commas to separate You can modify the value associated with any key in a # Show everyone who's taken the survey.
individual key-value pairs. dictionary. To do so give the name of the dictionary and for name in fav_languages.keys():
enclose the key in square brackets, then provide the new print(name)
Making a dictionary value for that key.
alien_0 = {'color': 'green', 'points': 5} Looping through all the values
Modifying values in a dictionary
# Show all the languages that have been chosen.
alien_0 = {'color': 'green', 'points': 5} for language in fav_languages.values():
print(alien_0) print(language)
To access the value associated with an individual key give
the name of the dictionary and then place the key in a set of # Change the alien's color and point value. Looping through all the keys in order
square brackets. If the key you're asking for is not in the
alien_0['color'] = 'yellow'
dictionary, an error will occur. # Show each person's favorite language,
You can also use the get() method, which returns None alien_0['points'] = 10 # in order by the person's name.
instead of an error if the key doesn't exist. You can also print(alien_0) for name in sorted(fav_languages.keys()):
specify a default value to use if the key is not in the print(name + ": " + language)
dictionary.

Getting the value associated with a key You can remove any key-value pair you want from a
dictionary. To do so use the del keyword and the dictionary
You can find the number of key-value pairs in a dictionary.
alien_0 = {'color': 'green', 'points': 5} name, followed by the key in square brackets. This will
delete the key and its associated value. Finding a dictionary's length
print(alien_0['color'])
Deleting a key-value pair num_responses = len(fav_languages)
print(alien_0['points'])
alien_0 = {'color': 'green', 'points': 5}
Getting the value with get() print(alien_0)
alien_0 = {'color': 'green'}
del alien_0['points']
alien_color = alien_0.get('color') print(alien_0)
alien_points = alien_0.get('points', 0)
print(alien_color)
print(alien_points) Try running some of these examples on pythontutor.com.
It's sometimes useful to store a set of dictionaries in a list; Storing a list inside a dictionary alows you to associate Standard Python dictionaries don't keep track of the order
this is called nesting. more than one value with each key. in which keys and values are added; they only preserve the
association between each key and its value. If you want to
Storing dictionaries in a list Storing lists in a dictionary preserve the order in which keys and values are added, use
an OrderedDict.
# Start with an empty list. # Store multiple languages for each person.
users = [] fav_languages = { Preserving the order of keys and values
'jen': ['python', 'ruby'],
# Make a new user, and add them to the list. from collections import OrderedDict
'sarah': ['c'],
new_user = { 'edward': ['ruby', 'go'],
'last': 'fermi', 'phil': ['python', 'haskell'], # Store each person's languages, keeping
'first': 'enrico', } # track of who respoded first.
'username': 'efermi', fav_languages = OrderedDict()
} # Show all responses for each person.
users.append(new_user) for name, langs in fav_languages.items(): fav_languages['jen'] = ['python', 'ruby']
print(name + ": ") fav_languages['sarah'] = ['c']
# Make another new user, and add them as well. for lang in langs: fav_languages['edward'] = ['ruby', 'go']
new_user = { print("- " + lang) fav_languages['phil'] = ['python', 'haskell']
'last': 'curie',
'first': 'marie', # Display the results, in the same order they
'username': 'mcurie', # were entered.
} You can store a dictionary inside another dictionary. In this for name, langs in fav_languages.items():
users.append(new_user) case each value associated with a key is itself a dictionary. print(name + ":")
for lang in langs:
# Show all information about each user. Storing dictionaries in a dictionary print("- " + lang)
for user_dict in users: users = {
for k, v in user_dict.items(): 'aeinstein': {
print(k + ": " + v) 'first': 'albert',
print("\n") 'last': 'einstein', You can use a loop to generate a large number of
'location': 'princeton', dictionaries efficiently, if all the dictionaries start out with
You can also define a list of dictionaries }, similar data.
directly, without using append(): 'mcurie': { A million aliens
'first': 'marie',
# Define a list of users, where each user aliens = []
'last': 'curie',
# is represented by a dictionary.
'location': 'paris',
users = [ # Make a million green aliens, worth 5 points
},
{ # each. Have them all start in one row.
}
'last': 'fermi', for alien_num in range(1000000):
'first': 'enrico', new_alien = {}
for username, user_dict in users.items():
'username': 'efermi', new_alien['color'] = 'green'
print("\nUsername: " + username)
}, new_alien['points'] = 5
full_name = user_dict['first'] + " "
{ new_alien['x'] = 20 * alien_num
full_name += user_dict['last']
'last': 'curie', new_alien['y'] = 0
location = user_dict['location']
'first': 'marie', aliens.append(new_alien)
'username': 'mcurie',
print("\tFull name: " + full_name.title())
}, # Prove the list contains a million aliens.
print("\tLocation: " + location.title())
] num_aliens = len(aliens)
# Show all information about each user.
print("Number of aliens created:")
for user_dict in users:
for k, v in user_dict.items(): Nesting is extremely useful in certain situations. However, print(num_aliens)
print(k + ": " + v) be aware of making your code overly complex. If you're
nesting items much deeper than what you see here there
print("\n")
are probably simpler ways of managing your data, such as
using classes.
 Testing numerical values is similar to testing string values. Several kinds of if statements exist. Your choice of which to
use depends on the number of conditions you need to test.
Testing equality and inequality You can have as many elif blocks as you need, and the
>>> age = 18 else block is always optional.
>>> age == 18
Simple if statement
True
>>> age != 18 age = 19
False
if age >= 18:
Comparison operators print("You're old enough to vote!")
>>> age = 19
If-else statements
>>> age < 21
True age = 17
>>> age <= 21
True if age >= 18:
If statements allow you to examine the current state >>> age > 21 print("You're old enough to vote!")
of a program and respond appropriately to that state. False else:
>>> age >= 21 print("You can't vote yet.")
You can write a simple if statement that checks one
False
condition, or you can create a complex series of if The if-elif-else chain
statements that idenitfy the exact conditions you're
age = 12
looking for.
You can check multiple conditions at the same time. The
While loops run as long as certain conditions remain if age < 4:
and operator returns True if all the conditions listed are
true. You can use while loops to let your programs True. The or operator returns True if any condition is True. price = 0
elif age < 18:
run as long as your users want them to.
Using and to check multiple conditions price = 5
else:
>>> age_0 = 22 price = 10
>>> age_1 = 18
A conditional test is an expression that can be evaluated as >>> age_0 >= 21 and age_1 >= 21 print("Your cost is $" + str(price) + ".")
True or False. Python uses the values True and False to False
decide whether the code in an if statement should be >>> age_1 = 23
executed. >>> age_0 >= 21 and age_1 >= 21
True You can easily test whether a certain value is in a list. You
Checking for equality can also test whether a list is empty before trying to loop
A single equal sign assigns a value to a variable. A double equal Using or to check multiple conditions
sign (==) checks whether two values are equal. through the list.
>>> age_0 = 22
>>> car = 'bmw' Testing if a value is in a list
>>> age_1 = 18
>>> car == 'bmw' >>> players = ['al', 'bea', 'cyn', 'dale']
>>> age_0 >= 21 or age_1 >= 21
True >>> 'al' in players
True
>>> car = 'audi' True
>>> age_0 = 18
>>> car == 'bmw' >>> 'eric' in players
>>> age_0 >= 21 or age_1 >= 21
False False
False
Ignoring case when making a comparison
>>> car = 'Audi'
>>> car.lower() == 'audi' A boolean value is either True or False. Variables with
True boolean values are often used to keep track of certain
conditions within a program.
Checking for inequality
>>> topping = 'mushrooms' Simple boolean values
>>> topping != 'anchovies' game_active = True
True can_edit = False
Testing if a value is not in a list Letting the user choose when to quit Using continue in a loop
banned_users = ['ann', 'chad', 'dee'] prompt = "\nTell me something, and I'll " banned_users = ['eve', 'fred', 'gary', 'helen']
user = 'erin' prompt += "repeat it back to you."
prompt += "\nEnter 'quit' to end the program. " prompt = "\nAdd a player to your team."
if user not in banned_users: prompt += "\nEnter 'quit' when you're done. "
print("You can play!") message = "" players = []
while message != 'quit':
Checking if a list is empty message = input(prompt) while True:
player = input(prompt)
players = [] if player == 'quit':
if message != 'quit':
break
if players: print(message)
elif player in banned_users:
for player in players: print(player + " is banned!")
print("Player: " + player.title())
Using a flag
continue
else: prompt = "\nTell me something, and I'll " else:
print("We have no players yet!") prompt += "repeat it back to you." players.append(player)
prompt += "\nEnter 'quit' to end the program. "
print("\nYour team:")
active = True for player in players:
You can allow your users to enter input using the input() while active: print(player)
statement. In Python 3, all input is stored as a string. message = input(prompt)
Simple input if message == 'quit':
name = input("What's your name? ") active = False
print("Hello, " + name + ".") Every while loop needs a way to stop running so it won't
else: continue to run forever. If there's no way for the condition to
print(message) become False, the loop will never stop running.
Accepting numerical input
age = input("How old are you? ")
Using break to exit a loop An infinite loop
age = int(age) prompt = "\nWhat cities have you visited?" while True:
prompt += "\nEnter 'quit' when you're done. " name = input("\nWho are you? ")
if age >= 18:
while True: print("Nice to meet you, " + name + "!")
print("\nYou can vote!")
else: city = input(prompt)
print("\nYou can't vote yet.") if city == 'quit':
The remove() method removes a specific value from a list,
Accepting input in Python 2.7 break
but it only removes the first instance of the value you
Use raw_input() in Python 2.7. This function interprets all input as a else:
string, just as input() does in Python 3. print("I've been to " + city + "!") provide. You can use a while loop to remove all instances
of a particular value.
name = raw_input("What's your name? ")
print("Hello, " + name + ".") Removing all cats from a list of pets
pets = ['dog', 'cat', 'dog', 'fish', 'cat',
Sublime Text doesn't run programs that prompt the user for
input. You can use Sublime Text to write programs that 'rabbit', 'cat']
prompt for input, but you'll need to run these programs from print(pets)
A while loop repeats a block of code as long as a condition
is True. a terminal. while 'cat' in pets:
Counting to 5 pets.remove('cat')
print(pets)
current_number = 1
You can use the break statement and the continue
while current_number <= 5: statement with any of Python's loops. For example you can
use break to quit a for loop that's working through a list or a
print(current_number) dictionary. You can use continue to skip over certain items
current_number += 1 when looping through a list or dictionary as well.
 The two main kinds of arguments are positional and A function can return a value or a set of values. When a
keyword arguments. When you use positional arguments function returns a value, the calling line must provide a
Python matches the first argument in the function call with variable in which to store the return value. A function stops
the first parameter in the function definition, and so forth. running when it reaches a return statement.
With keyword arguments, you specify which parameter
each argument should be assigned to in the function call. Returning a single value
When you use keyword arguments, the order of the
arguments doesn't matter. def get_full_name(first, last):
"""Return a neatly formatted full name."""
full_name = first + ' ' + last
Using positional arguments
return full_name.title()
def describe_pet(animal, name):
"""Display information about a pet.""" musician = get_full_name('jimi', 'hendrix')
Functions are named blocks of code designed to do
print("\nI have a " + animal + ".") print(musician)
one specific job. Functions allow you to write code
print("Its name is " + name + ".")
once that can then be run whenever you need to Returning a dictionary
accomplish the same task. Functions can take in the describe_pet('hamster', 'harry') def build_person(first, last):
information they need, and return the information they
describe_pet('dog', 'willie') """Return a dictionary of information
generate. Using functions effectively makes your
about a person.
programs easier to write, read, test, and fix. Using keyword arguments
"""
def describe_pet(animal, name): person = {'first': first, 'last': last}
"""Display information about a pet.""" return person
The first line of a function is its definition, marked by the print("\nI have a " + animal + ".")
keyword def. The name of the function is followed by a set print("Its name is " + name + ".") musician = build_person('jimi', 'hendrix')
of parentheses and a colon. A docstring, in triple quotes, print(musician)
describes what the function does. The body of a function is describe_pet(animal='hamster', name='harry')
indented one level. describe_pet(name='willie', animal='dog') Returning a dictionary with optional values
To call a function, give the name of the function followed def build_person(first, last, age=None):
by a set of parentheses. """Return a dictionary of information
about a person.
Making a function You can provide a default value for a parameter. When
"""
function calls omit this argument the default value will be
def greet_user(): used. Parameters with default values must be listed after person = {'first': first, 'last': last}
"""Display a simple greeting.""" parameters without default values in the function's definition if age:
print("Hello!") so positional arguments can still work correctly. person['age'] = age
return person
greet_user() Using a default value
musician = build_person('jimi', 'hendrix', 27)
def describe_pet(name, animal='dog'): print(musician)
"""Display information about a pet."""
print("\nI have a " + animal + ".") musician = build_person('janis', 'joplin')
Information that's passed to a function is called an
print("Its name is " + name + ".") print(musician)
argument; information that's received by a function is called
a parameter. Arguments are included in parentheses after
the function's name, and parameters are listed in describe_pet('harry', 'hamster')
parentheses in the function's definition. describe_pet('willie')
Try running some of these examples on pythontutor.com.
Passing a single argument Using None to make an argument optional
def greet_user(username): def describe_pet(animal, name=None):
"""Display a simple greeting.""" """Display information about a pet."""
print("Hello, " + username + "!") print("\nI have a " + animal + ".")
if name:
greet_user('jesse') print("Its name is " + name + ".")
greet_user('diana')
greet_user('brandon') describe_pet('hamster', 'harry')
describe_pet('snake')
You can pass a list as an argument to a function, and the Sometimes you won't know how many arguments a You can store your functions in a separate file called a
function can work with the values in the list. Any changes function will need to accept. Python allows you to collect an module, and then import the functions you need into the file
the function makes to the list will affect the original list. You arbitrary number of arguments into one parameter using containing your main program. This allows for cleaner
can prevent a function from modifying a list by passing a the * operator. A parameter that accepts an arbitrary program files. (Make sure your module is stored in the
copy of the list as an argument. number of arguments must come last in the function same directory as your main program.)
definition.
Passing a list as an argument The ** operator allows a parameter to collect an arbitrary Storing a function in a module
number of keyword arguments. File: pizza.py
def greet_users(names):
Collecting an arbitrary number of arguments def make_pizza(size, *toppings):
"""Print a simple greeting to everyone."""
for name in names: def make_pizza(size, *toppings): """Make a pizza."""
msg = "Hello, " + name + "!" """Make a pizza.""" print("\nMaking a " + size + " pizza.")
print(msg) print("\nMaking a " + size + " pizza.") print("Toppings:")
print("Toppings:") for topping in toppings:
usernames = ['hannah', 'ty', 'margot'] for topping in toppings: print("- " + topping)
greet_users(usernames) print("- " + topping)
Importing an entire module
Allowing a function to modify a list File: making_pizzas.py
# Make three pizzas with different toppings. Every function in the module is available in the program file.
The following example sends a list of models to a function for
printing. The original list is emptied, and the second list is filled. make_pizza('small', 'pepperoni')
make_pizza('large', 'bacon bits', 'pineapple') import pizza
def print_models(unprinted, printed): make_pizza('medium', 'mushrooms', 'peppers',
"""3d print a set of models.""" 'onions', 'extra cheese') pizza.make_pizza('medium', 'pepperoni')
while unprinted: pizza.make_pizza('small', 'bacon', 'pineapple')
current_model = unprinted.pop() Collecting an arbitrary number of keyword arguments
print("Printing " + current_model) Importing a specific function
def build_profile(first, last, **user_info): Only the imported functions are available in the program file.
printed.append(current_model) """Build a user's profile dictionary."""
# Build a dict with the required keys. from pizza import make_pizza
# Store some unprinted designs, profile = {'first': first, 'last': last}
# and print each of them. make_pizza('medium', 'pepperoni')
unprinted = ['phone case', 'pendant', 'ring'] # Add any other keys and values. make_pizza('small', 'bacon', 'pineapple')
printed = []
print_models(unprinted, printed)
for key, value in user_info.items(): Giving a module an alias
profile[key] = value
import pizza as p
print("\nUnprinted:", unprinted) return profile
print("Printed:", printed) p.make_pizza('medium', 'pepperoni')
# Create two users with different kinds p.make_pizza('small', 'bacon', 'pineapple')
Preventing a function from modifying a list
The following example is the same as the previous one, except the # of information.
Giving a function an alias
original list is unchanged after calling print_models(). user_0 = build_profile('albert', 'einstein',
location='princeton') from pizza import make_pizza as mp
def print_models(unprinted, printed): user_1 = build_profile('marie', 'curie',
"""3d print a set of models.""" location='paris', field='chemistry') mp('medium', 'pepperoni')
while unprinted:
print(user_0) mp('small', 'bacon', 'pineapple')
current_model = unprinted.pop()
print("Printing " + current_model) print(user_1) Importing all functions from a module
printed.append(current_model) Don't do this, but recognize it when you see it in others' code. It
can result in naming conflicts, which can cause errors.
# Store some unprinted designs,
from pizza import *
# and print each of them. As you can see there are many ways to write and call a
original = ['phone case', 'pendant', 'ring'] function. When you're starting out, aim for something that make_pizza('medium', 'pepperoni')
printed = [] simply works. As you gain experience you'll develop an
make_pizza('small', 'bacon', 'pineapple')
print_models(original[:], printed) understanding of the more subtle advantages of different
structures such as positional and keyword arguments, and
print("\nOriginal:", original) the various approaches to importing functions. For now if
print("Printed:", printed) your functions do what you need them to, you're doing well.
 If the class you're writing is a specialized version of another
Creating an object from a class class, you can use inheritance. When one class inherits
my_car = Car('audi', 'a4', 2016) from another, it automatically takes on all the attributes and
methods of the parent class. The child class is free to
Accessing attribute values introduce new attributes and methods, and override
attributes and methods of the parent class.
print(my_car.make) To inherit from another class include the name of the
print(my_car.model) parent class in parentheses when defining the new class.
print(my_car.year)
Classes are the foundation of object-oriented The __init__() method for a child class
Calling methods
programming. Classes represent real-world things class ElectricCar(Car):
you want to model in your programs: for example my_car.fill_tank()
"""A simple model of an electric car."""
dogs, cars, and robots. You use a class to make my_car.drive()
objects, which are specific instances of dogs, cars,
Creating multiple objects def __init__(self, make, model, year):
and robots. A class defines the general behavior that """Initialize an electric car."""
a whole category of objects can have, and the my_car = Car('audi', 'a4', 2016)
super().__init__(make, model, year)
information that can be associated with those objects. my_old_car = Car('subaru', 'outback', 2013)
Classes can inherit from each other – you can my_truck = Car('toyota', 'tacoma', 2010)
# Attributes specific to electric cars.
write a class that extends the functionality of an # Battery capacity in kWh.
existing class. This allows you to code efficiently for a self.battery_size = 70
wide variety of situations. You can modify an attribute's value directly, or you can # Charge level in %.
write methods that manage updating values more carefully. self.charge_level = 0

Modifying an attribute directly Adding new methods to the child class

Consider how we might model a car. What information my_new_car = Car('audi', 'a4', 2016)
class ElectricCar(Car):
would we associate with a car, and what behavior would it --snip--
my_new_car.fuel_level = 5
have? The information is stored in variables called def charge(self):
attributes, and the behavior is represented by functions. Writing a method to update an attribute's value """Fully charge the vehicle."""
Functions that are part of a class are called methods. self.charge_level = 100
def update_fuel_level(self, new_level): print("The vehicle is fully charged.")
The Car class """Update the fuel level."""
class Car():
if new_level <= self.fuel_capacity: Using child methods and parent methods
self.fuel_level = new_level
"""A simple attempt to model a car.""" my_ecar = ElectricCar('tesla', 'model s', 2016)
else:
print("The tank can't hold that much!")
def __init__(self, make, model, year): my_ecar.charge()
"""Initialize car attributes.""" Writing a method to increment an attribute's value my_ecar.drive()
self.make = make
def add_fuel(self, amount):
self.model = model
"""Add fuel to the tank."""
self.year = year
if (self.fuel_level + amount
# Fuel capacity and level in gallons. <= self.fuel_capacity): There are many ways to model real world objects and
self.fuel_level += amount situations in code, and sometimes that variety can feel
self.fuel_capacity = 15 print("Added fuel.") overwhelming. Pick an approach and try it – if your first
self.fuel_level = 0 else: attempt doesn't work, try a different approach.
print("The tank won't hold that much.")
def fill_tank(self):
"""Fill gas tank to capacity."""
self.fuel_level = self.fuel_capacity
print("Fuel tank is full.")
def drive(self): In Python class names are written in CamelCase and object
names are written in lowercase with underscores. Modules
"""Simulate driving.""" that contain classes should still be named in lowercase with
print("The car is moving.") underscores.
 Class files can get long as you add detailed information and
Overriding parent methods functionality. To help keep your program files uncluttered, Classes should inherit from object
class ElectricCar(Car): you can store your classes in modules and import the class ClassName(object):
--snip-- classes you need into your main program.
def fill_tank(self): The Car class in Python 2.7
Storing classes in a file
"""Display an error message.""" car.py class Car(object):
print("This car has no fuel tank!")
"""Represent gas and electric cars.""" Child class __init__() method is different
class ChildClassName(ParentClass):
class Car():
def __init__(self):
A class can have objects as attributes. This allows classes to """A simple attempt to model a car.""" super(ClassName, self).__init__()
work together to model complex situations. --snip—
The ElectricCar class in Python 2.7
A Battery class class Battery():
class ElectricCar(Car):
class Battery(): """A battery for an electric car."""
def __init__(self, make, model, year):
"""A battery for an electric car.""" --snip--
super(ElectricCar, self).__init__(
def __init__(self, size=70): class ElectricCar(Car): make, model, year)
"""Initialize battery attributes.""" """A simple model of an electric car."""
# Capacity in kWh, charge level in %. --snip--
self.size = size
Importing individual classes from a module A list can hold as many items as you want, so you can
self.charge_level = 0 my_cars.py make a large number of objects from a class and store
them in a list.
def get_range(self): from car import Car, ElectricCar Here's an example showing how to make a fleet of rental
"""Return the battery's range.""" cars, and make sure all the cars are ready to drive.
if self.size == 70: my_beetle = Car('volkswagen', 'beetle', 2016)
return 240 my_beetle.fill_tank() A fleet of rental cars
elif self.size == 85: my_beetle.drive() from car import Car, ElectricCar
return 270
my_tesla = ElectricCar('tesla', 'model s', # Make lists to hold a fleet of cars.
Using an instance as an attribute 2016) gas_fleet = []
class ElectricCar(Car): my_tesla.charge() electric_fleet = []
--snip-- my_tesla.drive()

def __init__(self, make, model, year): Importing an entire module # Make 500 gas cars and 250 electric cars.
for _ in range(500):
"""Initialize an electric car.""" import car
car = Car('ford', 'focus', 2016)
super().__init__(make, model, year) gas_fleet.append(car)
my_beetle = car.Car(
for _ in range(250):
# Attribute specific to electric cars. 'volkswagen', 'beetle', 2016)
ecar = ElectricCar('nissan', 'leaf', 2016)
self.battery = Battery() my_beetle.fill_tank()
electric_fleet.append(ecar)
my_beetle.drive()
def charge(self):
# Fill the gas cars, and charge electric cars.
"""Fully charge the vehicle.""" my_tesla = car.ElectricCar(
self.battery.charge_level = 100 'tesla', 'model s', 2016) for car in gas_fleet:
print("The vehicle is fully charged.") my_tesla.charge() car.fill_tank()
my_tesla.drive() for ecar in electric_fleet:
ecar.charge()
Using the instance
Importing all classes from a module
my_ecar = ElectricCar('tesla', 'model x', 2016) (Don’t do this, but recognize it when you see it.) print("Gas cars:", len(gas_fleet))
from car import * print("Electric cars:", len(electric_fleet))
my_ecar.charge()
print(my_ecar.battery.get_range())
my_beetle = Car('volkswagen', 'beetle', 2016)
my_ecar.drive()
 Storing the lines in a list Opening a file using an absolute path
filename = 'siddhartha.txt' f_path = "/home/ehmatthes/books/alice.txt"

with open(filename) as f_obj: with open(f_path) as f_obj:

lines = f_obj.readlines() lines = f_obj.readlines()
for line in lines: Opening a file on Windows
print(line.rstrip()) Windows will sometimes interpret forward slashes incorrectly. If
you run into this, use backslashes in your file paths.
f_path = "C:\Users\ehmatthes\books\alice.txt"
Your programs can read information in from files, and Passing the 'w' argument to open() tells Python you want to with open(f_path) as f_obj:
they can write data to files. Reading from files allows write to the file. Be careful; this will erase the contents of
you to work with a wide variety of information; writing lines = f_obj.readlines()
the file if it already exists. Passing the 'a' argument tells
to files allows users to pick up where they left off the Python you want to append to the end of an existing file.
next time they run your program. You can write text to
files, and you can store Python structures such as Writing to an empty file When you think an error may occur, you can write a try-
lists in data files. filename = 'programming.txt' except block to handle the exception that might be raised.
The try block tells Python to try running some code, and the
except block tells Python what to do if the code results in a
Exceptions are special objects that help your with open(filename, 'w') as f:
particular kind of error.
programs respond to errors in appropriate ways. For f.write("I love programming!")
example if your program tries to open a file that Handling the ZeroDivisionError exception
Writing multiple lines to an empty file
doesn’t exist, you can use exceptions to display an
try:
informative error message instead of having the filename = 'programming.txt'
print(5/0)
program crash.
with open(filename, 'w') as f: except ZeroDivisionError:
f.write("I love programming!\n") print("You can't divide by zero!")
f.write("I love creating new games.\n") Handling the FileNotFoundError exception
To read from a file your program needs to open the file and
then read the contents of the file. You can read the entire
Appending to a file f_name = 'siddhartha.txt'
contents of the file at once, or read the file line by line. The filename = 'programming.txt'
with statement makes sure the file is closed properly when try:
the program has finished accessing the file. with open(filename, 'a') as f: with open(f_name) as f_obj:
f.write("I also love working with data.\n") lines = f_obj.readlines()
Reading an entire file at once f.write("I love making apps as well.\n") except FileNotFoundError:
filename = 'siddhartha.txt' msg = "Can't find file {0}.".format(f_name)
print(msg)
with open(filename) as f_obj:
contents = f_obj.read() When Python runs the open() function, it looks for the file in
the same directory where the program that's being excuted
print(contents) is stored. You can open a file from a subfolder using a It can be hard to know what kind of exception to handle
relative path. You can also use an absolute path to open when writing code. Try writing your code without a try block,
any file on your system. and make it generate an error. The traceback will tell you
Reading line by line what kind of exception your program needs to handle.
Each line that's read from the file has a newline character at the
end of the line, and the print function adds its own newline Opening a file from a subfolder
character. The rstrip() method gets rid of the the extra blank lines
this would result in when printing to the terminal.
f_path = "text_files/alice.txt"

filename = 'siddhartha.txt' with open(f_path) as f_obj:

lines = f_obj.readlines()
with open(filename) as f_obj:
for line in lines:
for line in f_obj:
print(line.rstrip()) print(line.rstrip())
The try block should only contain code that may cause an Sometimes you want your program to just continue running The json module allows you to dump simple Python data
error. Any code that depends on the try block running when it encounters an error, without reporting the error to structures into a file, and load the data from that file the
successfully should be placed in the else block. the user. Using the pass statement in an else block allows next time the program runs. The JSON data format is not
you to do this. specific to Python, so you can share this kind of data with
Using an else block people who work in other languages as well.
print("Enter two numbers. I'll divide them.") Using the pass statement in an else block
Knowing how to manage exceptions is important when
f_names = ['alice.txt', 'siddhartha.txt', working with stored data. You'll usually want to make sure
x = input("First number: ") 'moby_dick.txt', 'little_women.txt'] the data you're trying to load exists before working with it.
y = input("Second number: ")
for f_name in f_names:
try: Using json.dump() to store data
# Report the length of each file found.
result = int(x) / int(y) try: """Store some numbers."""
except ZeroDivisionError: with open(f_name) as f_obj:
print("You can't divide by zero!") lines = f_obj.readlines() import json
else: except FileNotFoundError:
print(result) # Just move on to the next file. numbers = [2, 3, 5, 7, 11, 13]
pass
Preventing crashes from user input else: filename = 'numbers.json'
Without the except block in the following example, the program
num_lines = len(lines) with open(filename, 'w') as f_obj:
would crash if the user tries to divide by zero. As written, it will
handle the error gracefully and keep running. msg = "{0} has {1} lines.".format( json.dump(numbers, f_obj)
f_name, num_lines)
"""A simple calculator for division only.""" print(msg) Using json.load() to read data
"""Load some previously stored numbers."""
print("Enter two numbers. I'll divide them.")
print("Enter 'q' to quit.") import json
Exception-handling code should catch specific exceptions
while True: that you expect to happen during your program's execution. filename = 'numbers.json'
x = input("\nFirst number: ") A bare except block will catch all exceptions, including
if x == 'q': keyboard interrupts and system exits you might need when with open(filename) as f_obj:
break forcing a program to close. numbers = json.load(f_obj)
y = input("Second number: ") If you want to use a try block and you're not sure which print(numbers)
if y == 'q':
exception to catch, use Exception. It will catch most
break
exceptions, but still allow you to interrupt programs
Making sure the stored data exists
intentionally. import json
try:
result = int(x) / int(y)
Don’t use bare except blocks f_name = 'numbers.json'
except ZeroDivisionError:
print("You can't divide by zero!") try:
try:
else: # Do something
print(result) except: with open(f_name) as f_obj:
pass numbers = json.load(f_obj)
except FileNotFoundError:
Use Exception instead msg = "Can’t find {0}.".format(f_name)
Well-written, properly tested code is not very prone to try:
print(msg)
internal errors such as syntax or logical errors. But every # Do something
else:
time your program depends on something external such as except Exception:
print(numbers)
user input or the existence of a file, there's a possibility of
pass
an exception being raised. Practice with exceptions
Printing the exception Take a program you've already written that prompts for user
It's up to you how to communicate errors to your users.
input, and add some error-handling code to the program.
Sometimes users need to know if a file is missing; try:
sometimes it's better to handle the error silently. A little # Do something
experience will help you know how much to report. except Exception as e:
print(e, type(e))
 Building a testcase with one unit test Running the test
To build a test case, make a class that inherits from When you change your code, it’s important to run your existing
unittest.TestCase and write methods that begin with test_. tests. This will tell you whether the changes you made affected
Save this as test_full_names.py existing behavior.

import unittest E
from full_names import get_full_name ================================================
ERROR: test_first_last (__main__.NamesTestCase)
class NamesTestCase(unittest.TestCase): Test names like Janis Joplin.
"""Tests for names.py.""" ------------------------------------------------
Traceback (most recent call last):
def test_first_last(self): File "test_full_names.py", line 10,
When you write a function or a class, you can also """Test names like Janis Joplin.""" in test_first_last
write tests for that code. Testing proves that your full_name = get_full_name('janis', 'joplin')
code works as it's supposed to in the situations it's 'joplin') TypeError: get_full_name() missing 1 required
designed to handle, and also when people use your self.assertEqual(full_name, positional argument: 'last'
programs in unexpected ways. Writing tests gives 'Janis Joplin')
you confidence that your code will work correctly as ------------------------------------------------
more people begin to use your programs. You can unittest.main() Ran 1 test in 0.001s
also add new features to your programs and know
that you haven't broken existing behavior. Running the test FAILED (errors=1)
Python reports on each unit test in the test case. The dot reports a
single passing test. Python informs us that it ran 1 test in less than Fixing the code
A unit test verifies that one specific aspect of your 0.001 seconds, and the OK lets us know that all unit tests in the When a test fails, the code needs to be modified until the test
code works as it's supposed to. A test case is a test case passed. passes again. (Don’t make the mistake of rewriting your tests to fit
collection of unit tests which verify your code's your new code.) Here we can make the middle name optional.
.
behavior in a wide variety of situations. --------------------------------------- def get_full_name(first, last, middle=''):
Ran 1 test in 0.000s """Return a full name."""
if middle:
OK
full_name = "{0} {1} {2}".format(first,
Python's unittest module provides tools for testing your middle, last)
code. To try it out, we’ll create a function that returns a full else:
name. We’ll use the function in a regular program, and then full_name = "{0} {1}".format(first,
build a test case for the function. Failing tests are important; they tell you that a change in the
last)
code has affected existing behavior. When a test fails, you
return full_name.title()
A function to test need to modify the code so the existing behavior still works.
Save this as full_names.py
Modifying the function Running the test
def get_full_name(first, last): Now the test should pass again, which means our original
We’ll modify get_full_name() so it handles middle names, but
functionality is still intact.
"""Return a full name.""" we’ll do it in a way that breaks existing behavior.
full_name = "{0} {1}".format(first, last) .
return full_name.title() def get_full_name(first, middle, last):
---------------------------------------
"""Return a full name."""
Ran 1 test in 0.000s
Using the function full_name = "{0} {1} {2}".format(first,
Save this as names.py middle, last)
OK
return full_name.title()
from full_names import get_full_name
Using the function
janis = get_full_name('janis', 'joplin')
from full_names import get_full_name
print(janis)
bob = get_full_name('bob', 'dylan') john = get_full_name('john', 'lee', 'hooker')
print(bob) print(john)
david = get_full_name('david', 'lee', 'roth')
print(david)
You can add as many unit tests to a test case as you need. Testing a class is similar to testing a function, since you’ll When testing a class, you usually have to make an instance
To write a new test, add a new method to your test case mostly be testing your methods. of the class. The setUp() method is run before every test.
class. Any instances you make in setUp() are available in every
A class to test test you write.
Testing middle names Save as accountant.py
We’ve shown that get_full_name() works for first and last Using setUp() to support multiple tests
names. Let’s test that it works for middle names as well. class Accountant():
The instance self.acccan be used in each new test.
"""Manage a bank account."""
import unittest import unittest
from full_names import get_full_name def __init__(self, balance=0): from accountant import Accountant
self.balance = balance
class NamesTestCase(unittest.TestCase): def deposit(self, amount): class TestAccountant(unittest.TestCase):
"""Tests for names.py.""" """Tests for the class Accountant."""
self.balance += amount
def test_first_last(self): def withdraw(self, amount): def setUp(self):
"""Test names like Janis Joplin.""" self.balance -= amount self.acc = Accountant()
full_name = get_full_name('janis', def test_initial_balance(self):
'joplin')
Building a testcase # Default balance should be 0.
self.assertEqual(full_name,
For the first test, we’ll make sure we can start out with different self.assertEqual(self.acc.balance, 0)
'Janis Joplin')
initial balances. Save this as test_accountant.py.
# Test non-default balance.
def test_middle(self): import unittest
"""Test names like David Lee Roth.""" acc = Accountant(100)
from accountant import Accountant
full_name = get_full_name('david', self.assertEqual(acc.balance, 100)
'roth', 'lee') class TestAccountant(unittest.TestCase): def test_deposit(self):
self.assertEqual(full_name, """Tests for the class Accountant."""
'David Lee Roth') # Test single deposit.
def test_initial_balance(self): self.acc.deposit(100)
unittest.main() # Default balance should be 0. self.assertEqual(self.acc.balance, 100)
acc = Accountant() # Test multiple deposits.
Running the tests self.assertEqual(acc.balance, 0)
The two dots represent two passing tests. self.acc.deposit(100)
self.acc.deposit(100)
.. # Test non-default balance. self.assertEqual(self.acc.balance, 300)
--------------------------------------- acc = Accountant(100)
def test_withdrawal(self):
Ran 2 tests in 0.000s self.assertEqual(acc.balance, 100)
# Test single withdrawal.
OK unittest.main() self.acc.deposit(1000)
self.acc.withdraw(100)
Running the test self.assertEqual(self.acc.balance, 900)
.
Python provides a number of assert methods you can use unittest.main()
to test your code. ---------------------------------------
Ran 1 test in 0.000s
Verify that a==b, or a != b
OK Running the tests
assertEqual(a, b)
assertNotEqual(a, b) ...
---------------------------------------
Verify that x is True, or x is False In general you shouldn’t modify a test once it’s written. Ran 3 tests in 0.001s
assertTrue(x) When a test fails it usually means new code you’ve written OK
assertFalse(x) has broken existing functionality, and you need to modify
the new code until all existing tests pass.
Verify an item is in a list, or not in a list If your original requirements have changed, it may be
appropriate to modify some tests. This usually happens in
assertIn(item, list) the early stages of a project when desired behavior is still
assertNotIn(item, list) being sorted out.
 The following code sets up an empty game window, and
starts an event loop and a loop that continually refreshes Useful rect attributes
the screen. Once you have a rect object, there are a number of attributes that
are useful when positioning objects and detecting relative positions
of objects. (You can find more attributes in the Pygame
An empty game window documentation.)
import sys
# Individual x and y values:
import pygame as pg
screen_rect.left, screen_rect.right
def run_game(): screen_rect.top, screen_rect.bottom
Pygame is a framework for making games using screen_rect.centerx, screen_rect.centery
Python. Making games is fun, and it’s a great way to # Initialize and set up screen.
screen_rect.width, screen_rect.height
expand your programming skills and knowledge. pg.init()
screen = pg.display.set_mode((1200, 800))
Pygame takes care of many of the lower-level tasks # Tuples
pg.display.set_caption("Alien Invasion")
in building games, which lets you focus on the screen_rect.center
aspects of your game that make it interesting. # Start main loop. screen_rect.size
while True: Creating a rect object
# Start event loop. You can create a rect object from scratch. For example a small rect
for event in pg.event.get(): object that’s filled in can represent a bullet in a game. The Rect()
Pygame runs on all systems, but setup is slightly different
if event.type == pg.QUIT: class takes the coordinates of the upper left corner, and the width
on each OS. The instructions here assume you’re using and height of the rect. The draw.rect() function takes a screen
Python 3, and provide a minimal installation of Pygame. If sys.exit()
object, a color, and a rect. This function fills the given rect with the
these instructions don’t work for your system, see the more # Refresh screen. given color.
detailed notes at http://ehmatthes.github.io/pcc/. pg.display.flip()
bullet_rect = pg.Rect(100, 100, 3, 15)
Pygame on Linux run_game() color = (100, 100, 100)
pg.draw.rect(screen, color, bullet_rect)
$ sudo apt-get install python3-dev mercurial
libsdl-image1.2-dev libsdl2-dev Setting a custom window size
libsdl-ttf2.0-dev The display.set_mode() function accepts a tuple that defines the
$ pip install --user screen size. Many objects in a game are images that are moved around
hg+http://bitbucket.org/pygame/pygame
screen_dim = (1200, 800) the screen. It’s easiest to use bitmap (.bmp) image files, but
you can also configure your system to work with jpg, png,
Pygame on OS X screen = pg.display.set_mode(screen_dim)
and gif files as well.
This assumes you’ve used Homebrew to install Python 3.
Setting a custom background color
$ brew install hg sdl sdl_image sdl_ttf Colors are defined as a tuple of red, green, and blue values. Each Loading an image
$ pip install --user value ranges from 0-255. ship = pg.image.load('images/ship.bmp')
hg+http://bitbucket.org/pygame/pygame bg_color = (230, 230, 230)
Getting the rect object from an image
Pygame on Windows screen.fill(bg_color)
Find an installer at ship_rect = ship.get_rect()
https://bitbucket.org/pygame/pygame/downloads/ or
http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame that matches Positioning an image
your version of Python. Run the installer file if it’s a .exe or .msi file. Many objects in a game can be treated as simple With rects, it’s easy to position an image wherever you want on the
If it’s a .whl file, use pip to install Pygame: rectangles, rather than their actual shape. This simplifies screen, or in relation to another object. The following code
positions a ship object at the bottom center of the screen.
code without noticeably affecting game play. Pygame has a
> python –m pip install --user
rect object that makes it easy to work with game objects. ship_rect.midbottom = screen_rect.midbottom
pygame-1.9.2a0-cp35-none-win32.whl

Testing your installation Getting the screen rect object

We already have a screen object; we can easily access the rect
To test your installation, open a terminal session and try to import
object associated with the screen.
Pygame. If you don’t get any error messages, your installation was
successful. screen_rect = screen.get_rect()
$ python Finding the center of the screen
>>> import pygame Rect objects have a center attribute which stores the center point.
>>>
screen_center = screen_rect.center
 Pygame’s event loop registers an event any time the
Drawing an image to the screen mouse moves, or a mouse button is pressed or released. Removing an item from a group
Once an image is loaded and positioned, you can draw it to the It’s important to delete elements that will never appear again in
screen with the blit() method. The blit() method acts on the screen Responding to the mouse button the game, so you don’t waste memory and resources.
object, and takes the image object and image rect as arguments.
for event in pg.event.get(): bullets.remove(bullet)
# Draw ship to screen. if event.type == pg.MOUSEBUTTONDOWN:
screen.blit(ship, ship_rect)
ship.fire_bullet()
The blitme() method Finding the mouse position You can detect when a single object collides with any
Game objects such as ships are often written as classes. Then a The mouse position is returned as a tuple. member of a group. You can also detect when any member
blitme() method is usually defined, which draws the object to the of one group collides with a member of another group.
screen. mouse_pos = pg.mouse.get_pos()
def blitme(self): Collisions between a single object and a group
Clicking a button The spritecollideany() function takes an object and a group, and
"""Draw ship at current location.""" You might want to know if the cursor is over an object such as a returns True if the object overlaps with any member of the group.
self.screen.blit(self.image, self.rect) button. The rect.collidepoint() method returns true when a point is
inside a rect object. if pg.sprite.spritecollideany(ship, aliens):
ships_left -= 1
if button_rect.collidepoint(mouse_pos):
Pygame watches for events such as key presses and start_game() Collisions between two groups
mouse actions. You can detect any event you care about in The sprite.groupcollide() function takes two groups, and two
Hiding the mouse booleans. The function returns a dictionary containing information
the event loop, and respond with any action that’s
about the members that have collided. The booleans tell Pygame
appropriate for your game. pg.mouse.set_visible(False) whether to delete the members of either group that have collided.
Responding to key presses collisions = pg.sprite.groupcollide(
Pygame’s main event loop registers a KEYDOWN event any time a bullets, aliens, True, True)
key is pressed. When this happens, you can check for specific Pygame has a Group class which makes working with a
keys. score += len(collisions) * alien_point_value
group of similar objects easier. A group is like a list, with
for event in pg.event.get(): some extra functionality that’s helpful when building games.
if event.type == pg.KEYDOWN:
if event.key == pg.K_RIGHT: Making and filling a group
An object that will be placed in a group must inherit from Sprite. You can use text for a variety of purposes in a game. For
ship_rect.x += 1
elif event.key == pg.K_LEFT: from pygame.sprite import Sprite, Group example you can share information with players, and you
can display a score.
ship_rect.x -= 1
elif event.key == pg.K_SPACE: def Bullet(Sprite): Displaying a message
ship.fire_bullet() ... The following code defines a message, then a color for the text and
elif event.key == pg.K_q: def draw_bullet(self): the background color for the message. A font is defined using the
sys.exit() ... default system font, with a font size of 48. The font.render()
def update(self): function is used to create an image of the message, and we get the
Responding to released keys rect object associated with the image. We then center the image
... on the screen and display it.
When the user releases a key, a KEYUP event is triggered.
bullets = Group()
if event.type == pg.KEYUP: msg = "Play again?"
if event.key == pg.K_RIGHT: new_bullet = Bullet() msg_color = (100, 100, 100)
ship.moving_right = False bullets.add(new_bullet) bg_color = (230, 230, 230)
f = pg.font.SysFont(None, 48)
Looping through the items in a group msg_image = f.render(msg, True, msg_color,
The Pygame documentation is really helpful when building The sprites() method returns all the members of a group. bg_color)
your own games. The home page for the Pygame project is for bullet in bullets.sprites(): msg_image_rect = msg_image.get_rect()
at http://pygame.org/, and the home page for the bullet.draw_bullet() msg_image_rect.center = screen_rect.center
documentation is at http://pygame.org/docs/. screen.blit(msg_image, msg_image_rect)
The most useful part of the documentation are the pages Calling update() on a group
about specific parts of Pygame, such as the Rect() class Calling update() on a group automatically calls update() on each
and the sprite module. You can find a list of these elements member of the group.
at the top of the help pages.
bullets.update()
 Making a scatter plot Emphasizing points
The scatter() function takes a list of x values and a list of y values, You can plot as much data as you want on one plot. Here we re-
and a variety of optional arguments. The s=10 argument controls plot the first and last points larger to emphasize them.
the size of each point.
import matplotlib.pyplot as plt
import matplotlib.pyplot as plt
x_values = list(range(1000))
x_values = list(range(1000)) squares = [x**2 for x in x_values]
squares = [x**2 for x in x_values] plt.scatter(x_values, squares, c=squares,
plt.scatter(x_values, squares, s=10) cmap=plt.cm.Blues, edgecolor='none',
s=10)
plt.show()
Data visualization involves exploring data through plt.scatter(x_values[0], squares[0], c='green',
visual representations. The matplotlib package helps
edgecolor='none', s=100)
you make visually appealing representations of the
Plots can be customized in a wide variety of ways. Just plt.scatter(x_values[-1], squares[-1], c='red',
data you’re working with. matplotlib is extremely edgecolor='none', s=100)
flexible; these examples will help you get started with about any element of a plot can be customized.
plt.title("Square Numbers", fontsize=24)
a few simple visualizations. Adding titles and labels, and scaling axes
--snip--
import matplotlib.pyplot as plt
Removing axes
matplotlib runs on all systems, but setup is slightly different x_values = list(range(1000)) You can customize or remove axes entirely. Here’s how to access
depending on your OS. If the minimal instructions here each axis, and hide it.
squares = [x**2 for x in x_values]
don’t work for you, see the more detailed instructions at plt.scatter(x_values, squares, s=10) plt.axes().get_xaxis().set_visible(False)
http://ehmatthes.github.io/pcc/. You should also consider plt.axes().get_yaxis().set_visible(False)
installing the Anaconda distrubution of Python from plt.title("Square Numbers", fontsize=24)
https://continuum.io/downloads/, which includes matplotlib. Setting a custom figure size
plt.xlabel("Value", fontsize=18)
You can make your plot as big or small as you want. Before
matplotlib on Linux plt.ylabel("Square of Value", fontsize=18) plotting your data, add the following code. The dpi argument is
plt.tick_params(axis='both', which='major', optional; if you don’t know your system’s resolution you can omit
$ sudo apt-get install python3-matplotlib labelsize=14) the argument and adjust the figsize argument accordingly.
plt.axis([0, 1100, 0, 1100000])
matplotlib on OS X plt.figure(dpi=128, figsize=(10, 6))
Start a terminal session and enter import matplotlib to see if it’s plt.show()
already installed on your system. If not, try this command: Saving a plot
$ pip install --user matplotlib Using a colormap The matplotlib viewer has an interactive save button, but you can
A colormap varies the point colors from one shade to another, also save your visualizations programmatically. To do so, replace
matplotlib on Windows based on a certain value for each point. The value used to plt.show() with plt.savefig(). The
You first need to install Visual Studio, which you can do from determine the color of each point is passed to the c argument, and bbox_inches='tight'
the cmap argument specifies which colormap to use. argument trims extra whitespace from the plot.
https://dev.windows.com/. The Community edition is free. Then go plt.savefig('squares.png', bbox_inches='tight')
to https://pypi.python.org/pypi/matplotlib/ or The edgecolor='none' argument removes the black outline
http://www.lfd.uic.edu/~gohlke/pythonlibs/#matplotlib and download from each point.
an appropriate installer file.
plt.scatter(x_values, squares, c=squares,
cmap=plt.cm.Blues, edgecolor='none', The matplotlib gallery and documentation are at
s=10) http://matplotlib.org/. Be sure to visit the examples, gallery,
and pyplot links.
Making a line graph
import matplotlib.pyplot as plt

x_values = [0, 1, 2, 3, 4, 5]
squares = [0, 1, 4, 9, 16, 25]
plt.plot(x_values, squares)
plt.show()
You can make as many plots as you want on one figure. You can include as many individual graphs in one figure as
When you make multiple plots, you can emphasize Datetime formatting arguments you want. This is useful, for example, when comparing
relationships in the data. For example you can fill the space The strftime() function generates a formatted string from a related datasets.
datetime object, and the strptime() function genereates a
between two sets of data.
datetime object from a string. The following codes let you work with
dates exactly as you need to.
Sharing an x-axis
Plotting two sets of data The following code plots a set of squares and a set of cubes on
Here we use plt.scatter() twice to plot square numbers and two separate graphs that share a common x-axis.
%A Weekday name, such as Monday
cubes on the same figure. The plt.subplots() function returns a figure object and a tuple
%B Month name, such as January of axes. Each set of axes corresponds to a separate plot in the
import matplotlib.pyplot as plt %m Month, as a number (01 to 12) figure. The first two arguments control the number of rows and
%d Day of the month, as a number (01 to 31) columns generated in the figure.
x_values = list(range(11)) %Y Four-digit year, such as 2016
%y Two-digit year, such as 16 import matplotlib.pyplot as plt
squares = [x**2 for x in x_values]
cubes = [x**3 for x in x_values] %H Hour, in 24-hour format (00 to 23)
x_vals = list(range(11))
%I Hour, in 12-hour format (01 to 12)
%p AM or PM squares = [x**2 for x in x_vals]
plt.scatter(x_values, squares, c='blue',
%M Minutes (00 to 59) cubes = [x**3 for x in x_vals]
edgecolor='none', s=20)
%S Seconds (00 to 61)
plt.scatter(x_values, cubes, c='red', fig, axarr = plt.subplots(2, 1, sharex=True)
edgecolor='none', s=20) Converting a string to a datetime object
plt.axis([0, 11, 0, 1100]) axarr[0].scatter(x_vals, squares)
new_years = dt.strptime('1/1/2017', '%m/%d/%Y')
plt.show() axarr[0].set_title('Squares')
Converting a datetime object to a string axarr[1].scatter(x_vals, cubes, c='red')
Filling the space between data sets ny_string = dt.strftime(new_years, '%B %d, %Y') axarr[1].set_title('Cubes')
The fill_between() method fills the space between two data
sets. It takes a series of x-values and two series of y-values. It also print(ny_string) plt.show()
takes a facecolor to use for the fill, and an optional alpha
argument that controls the color’s transparency. Plotting high temperatures
The following code creates a list of dates and a corresponding list
plt.fill_between(x_values, cubes, squares, of high temperatures. It then plots the high temperatures, with
Sharing a y-axis
To share a y-axis, we use the sharey=True argument.
facecolor='blue', alpha=0.25) the date labels displayed in a specific format.
from datetime import datetime as dt import matplotlib.pyplot as plt

import matplotlib.pyplot as plt x_vals = list(range(11))

Many interesting data sets have a date or time as the x- squares = [x**2 for x in x_vals]
value. Python’s datetime module helps you work with this from matplotlib import dates as mdates
cubes = [x**3 for x in x_vals]
kind of data. dates = [
dt(2016, 6, 21), dt(2016, 6, 22), fig, axarr = plt.subplots(1, 2, sharey=True)
Generating the current date
The datetime.now() function returns a datetime object dt(2016, 6, 23), dt(2016, 6, 24),
representing the current date and time. ] axarr[0].scatter(x_vals, squares)
highs = [57, 68, 64, 59] axarr[0].set_title('Squares')
from datetime import datetime as dt
axarr[1].scatter(x_vals, cubes, c='red')
today = dt.now() fig = plt.figure(dpi=128, figsize=(10,6)) axarr[1].set_title('Cubes')
plt.plot(dates, highs, c='red')
date_string = dt.strftime(today, '%m/%d/%Y') plt.show()
print(date_string) plt.title("Daily High Temps", fontsize=24)
plt.ylabel("Temp (F)", fontsize=16)
Generating a specific date x_axis = plt.axes().get_xaxis()
You can also generate a datetime object for any date and time you
want. The positional order of arguments is year, month, and day. x_axis.set_major_formatter(
The hour, minute, second, and microsecond arguments are mdates.DateFormatter('%B %d %Y')
optional. )
fig.autofmt_xdate()
from datetime import datetime as dt
plt.show()
new_years = dt(2017, 1, 1)
fall_equinox = dt(year=2016, month=9, day=22)
 You can add as much data as you want when making a
Making a scatter plot visualization.
The data for a scatter plot needs to be a list containing tuples of
the form (x, y). The stroke=False argument tells Pygal to make Plotting squares and cubes
an XY chart with no line connecting the points.
import pygal
import pygal
x_values = list(range(11))
squares = [
(0, 0), (1, 1), (2, 4), (3, 9), squares = [x**2 for x in x_values]
Data visualization involves exploring data through (4, 16), (5, 25), cubes = [x**3 for x in x_values]
visual representations. Pygal helps you make visually ]
appealing representations of the data you’re working chart = pygal.Line()
with. Pygal is particularly well suited for visualizations chart = pygal.XY(stroke=False) chart.force_uri_protocol = 'http'
that will be presented online, because it supports chart.force_uri_protocol = 'http' chart.title = "Squares and Cubes"
interactive elements. chart.add('x^2', squares) chart.x_labels = x_values
chart.render_to_file('squares.svg') chart.add('Squares', squares)
chart.add('Cubes', cubes)
Using a list comprehension for a scatter plot
A list comprehension can be used to effficiently make a dataset for chart.render_to_file('squares_cubes.svg')
Pygal can be installed using pip.
a scatter plot.
Pygal on Linux and OS X Filling the area under a data series
squares = [(x, x**2) for x in range(1000)] Pygal allows you to fill the area under or over each series of data.
$ pip install --user pygal The default is to fill from the x-axis up, but you can fill from any
Making a bar graph horizontal line using the zero argument.
Pygal on Windows A bar graph requires a list of values for the bar sizes. To label the
bars, pass a list of the same length to x_labels. chart = pygal.Line(fill=True, zero=0)
> python –m pip install --user pygal
import pygal

outcomes = [1, 2, 3, 4, 5, 6]
To make a plot with Pygal, you specify the kind of plot and frequencies = [18, 16, 18, 17, 18, 13]
then add the data.
chart = pygal.Bar()
Making a line graph chart.force_uri_protocol = 'http'
To view the output, open the file squares.svg in a browser. chart.x_labels = outcomes
import pygal chart.add('D6', frequencies)
chart.render_to_file('rolling_dice.svg')
x_values = [0, 1, 2, 3, 4, 5]
squares = [0, 1, 4, 9, 16, 25] Making a bar graph from a dictionary
Since each bar needs a label and a value, a dictionary is a great The documentation for Pygal is available at
way to store the data for a bar graph. The keys are used as the http://www.pygal.org/.
chart = pygal.Line() labels along the x-axis, and the values are used to determine the
chart.force_uri_protocol = 'http' height of each bar.
chart.add('x^2', squares)
chart.render_to_file('squares.svg') import pygal If you’re viewing svg output in a browser, Pygal needs to
render the output file in a specific way. The
Adding labels and a title results = { force_uri_protocol attribute for chart objects needs to
--snip--
1:18, 2:16, 3:18, be set to 'http'.
chart = pygal.Line() 4:17, 5:18, 6:13,
chart.force_uri_protocol = 'http' }
chart.title = "Squares"
chart.x_labels = x_values chart = pygal.Bar()
chart.x_title = "Value" chart.force_uri_protocol = 'http'
chart.y_title = "Square of Value" chart.x_labels = results.keys()
chart.add('x^2', squares) chart.add('D6', results.values())
chart.render_to_file('squares.svg') chart.render_to_file('rolling_dice.svg')
Pygal lets you customize many elements of a plot. There Pygal can generate world maps, and you can add any data
are some excellent default themes, and many options for Configuration settings you want to these maps. Data is indicated by coloring, by
styling individual plot elements. Some settings are controlled by a Config object. labels, and by tooltips that show data when users hover
my_config = pygal.Config() over each country on the map.
Using built-in styles my_config.show_y_guides = False
To use built-in styles, import the style and make an instance of the
my_config.width = 1000
Installing the world map module
style class. Then pass the style object with the style argument The world map module is not included by default in Pygal 2.0. It
when you make the chart object. my_config.dots_size = 5 can be installed with pip:
import pygal chart = pygal.Line(config=my_config) $ pip install --user pygal_maps_world
from pygal.style import LightGreenStyle --snip--
Making a world map
x_values = list(range(11)) The following code makes a simple world map showing the
Styling series countries of North America.
squares = [x**2 for x in x_values] You can give each series on a chart different style settings.
cubes = [x**3 for x in x_values] from pygal.maps.world import World
chart.add('Squares', squares, dots_size=2)
chart_style = LightGreenStyle() chart.add('Cubes', cubes, dots_size=3)
wm = World()
chart = pygal.Line(style=chart_style) Styling individual data points wm.force_uri_protocol = 'http'
chart.force_uri_protocol = 'http' You can style individual data points as well. To do so, write a wm.title = 'North America'
chart.title = "Squares and Cubes" dictionary for each data point you want to customize. A 'value' wm.add('North America', ['ca', 'mx', 'us'])
chart.x_labels = x_values key is required, and other properies are optional.
wm.render_to_file('north_america.svg')
import pygal
chart.add('Squares', squares)
chart.add('Cubes', cubes) repos = [ Showing all the country codes
In order to make maps, you need to know Pygal’s country codes.
chart.render_to_file('squares_cubes.svg') { The following example will print an alphabetical list of each country
'value': 20506, and its code.
Parametric built-in styles
Some built-in styles accept a custom color, then generate a theme 'color': '#3333CC',
from pygal.maps.world import COUNTRIES
based on that color. 'xlink': 'http://djangoproject.com/',
}, for code in sorted(COUNTRIES.keys()):
from pygal.style import LightenStyle 20054,
12607, print(code, COUNTRIES[code])
--snip--
chart_style = LightenStyle('#336688')
11827, Plotting numerical data on a world map
] To plot numerical data on a map, pass a dictionaryadd()
chart = pygal.Line(style=chart_style) to instead of a list.
chart = pygal.Bar()
--snip--
chart.force_uri_protocol = 'http' from pygal.maps.world import World
Customizing individual style properties chart.x_labels = [
Style objects have a number of properties you can set individually. 'django', 'requests', 'scikit-learn', populations = {
chart_style = LightenStyle('#336688') 'tornado', 'ca': 34126000,
chart_style.plot_background = '#CCCCCC' ] 'us': 309349000,
chart_style.major_label_font_size = 20 chart.y_title = 'Stars' 'mx': 113423000,
chart_style.label_font_size = 16 chart.add('Python Repos', repos) }
--snip-- chart.render_to_file('python_repos.svg')
wm = World()
Custom style class wm.force_uri_protocol = 'http'
You can start with a bare style class, and then set only the
wm.title = 'Population of North America'
properties you care about.
wm.add('North America', populations)
chart_style = Style() wm.render_to_file('na_populations.svg')
chart_style.colors = [
'#CCCCCC', '#AAAAAA', '#888888']
chart_style.plot_background = '#EEEEEE'
chart = pygal.Line(style=chart_style)
--snip--
 The data in a Django project is structured as a set of Users interact with a project through web pages, and a
models. project’s home page can start out as a simple page with no
data. A page usually needs a URL, a view, and a template.
Defining a model
To define the models for your app, modify the file models.py that Mapping a project’s URLs
was created in your app’s folder. The __str__() method tells The project’s main urls.py file tells Django where to find the urls.py
Django how to represent data objects based on this model. files associated with each app in the project.
from django.db import models from django.conf.urls import include, url
from django.contrib import admin
Django is a web framework which helps you build class Topic(models.Model):
interactive websites using Python. With Django you """A topic the user is learning about.""" urlpatterns = [
define the kind of data your site needs to work with, text = models.CharField(max_length=200) url(r'^admin/', include(admin.site.urls)),
and you define the ways your users can work with date_added = models.DateTimeField( url(r'', include('learning_logs.urls',
that data. auto_now_add=True) namespace='learning_logs')),
]
def __str__(self):
return self.text Mapping an app’s URLs
It’s usualy best to install Django to a virtual environment, An app’s urls.py file tells Django which view to use for each URL in
where your project can be isolated from your other Python Activating a model the app. You’ll need to make this file yourself, and save it in the
projects. Most commands assume you’re working in an To use a model the app must be added to the tuple app’s folder.
active virtual environment. INSTALLED_APPS, which is stored in the project’s settings.py file.
from django.conf.urls import url
Create a virtual environment INSTALLED_APPS = (
--snip-- from . import views
$ python –m venv ll_env 'django.contrib.staticfiles',
urlpatterns = [
Activate the environment (Linux and OS X)
# My apps url(r'^$', views.index, name='index'),
$ source ll_env/bin/activate 'learning_logs', ]
)
Activate the environment (Windows) Writing a simple view
Migrating the database A view takes information from a request and sends data to the
> ll_env\Scripts\activate browser, often through a template. View functions are stored in an
The database needs to be modified to store the kind of data that
the model represents. app’s views.py file. This simple view function doesn’t pull in any
Install Django to the active environment data, but it uses the template index.html to render the home page.
(ll_env)$ pip install Django $ python manage.py makemigrations learning_logs
$ python manage.py migrate from django.shortcuts import render

Creating a superuser def index(request):

A superuser is a user account that has access to all aspects of the """The home page for Learning Log."""
To start a project we’ll create a new project, create a project.
database, and start a development server. return render(request,
$ python manage.py createsuperuser 'learning_logs/index.html')
Create a new project
Registering a model
$ django-admin.py startproject learning_log . You can register your models with Django’s admin site, which
makes it easier to work with the data in your project. To do this,
Create a database modify the app’s admin.py file. View the admin site at The documentation for Django is available at
$ python manage.py migrate http://localhost:8000/admin/. http://docs.djangoproject.com/. The Django documentation
is thorough and user-friendly, so check it out!
from django.contrib import admin
View the project
After issuing this command, you can view the project at
http://localhost:8000/. from learning_logs.models import Topic
$ python manage.py runserver admin.site.register(Topic)
Create a new app
A Django project is made up of one or more apps.
$ python manage.py startapp learning_logs
 A new model can use an existing model. The ForeignKey
Writing a simple template attribute establishes a connection between instances of the Using data in a template
A template sets up the structure for a page. It’s a mix of html and two related models. Make sure to migrate the database The data in the view function’s context dictionary is available
template code, which is like Python but not as powerful. Make a within the template. This data is accessed using template
after adding a new model to your app.
folder called templates inside the project folder. Inside the variables, which are indicated by doubled curly braces.
templates folder make another folder with the same name as the The vertical line after a template variable indicates a filter. In this
app. This is where the template files should be saved. Defining a model with a foreign key case a filter called date formats date objects, and the filter
class Entry(models.Model): linebreaks renders paragraphs properly on a web page.
<p>Learning Log</p>
"""Learning log entries for a topic.""" {% extends 'learning_logs/base.html' %}
<p>Learning Log helps you keep track of your topic = models.ForeignKey(Topic)
text = models.TextField() {% block content %}
learning, for any topic you're learning
date_added = models.DateTimeField(
about.</p>
auto_now_add=True) <p>Topic: {{ topic }}</p>
def __str__(self):
<p>Entries:</p>
return self.text[:50] + "..."
Many elements of a web page are repeated on every page <ul>
in the site, or every page in a section of the site. By writing {% for entry in entries %}
one parent template for the site, and one for each section,
<li>
you can easily modify the look and feel of your entire site.
Most pages in a project need to present data that’s specific <p>
The parent template to the current user. {{ entry.date_added|date:'M d, Y H:i' }}
The parent template defines the elements common to a set of </p>
pages, and defines blocks that will be filled by individual pages. URL parameters <p>
A URL often needs to accept a parameter telling it which data to {{ entry.text|linebreaks }}
<p> access from the database. The second URL pattern shown here </p>
<a href="{% url 'learning_logs:index' %}"> looks for the ID of a specific topic and stores it in the parameter </li>
Learning Log topic_id.
{% empty %}
</a> urlpatterns = [ <li>There are no entries yet.</li>
</p> url(r'^$', views.index, name='index'), {% endfor %}
url(r'^topics/(?P<topic_id>\d+)/$', </ul>
{% block content %}{% endblock content %} views.topic, name='topic'),
{% endblock content %}
The child template ]
The child template uses the {% extends %} template tag to pull in
the structure of the parent template. It then defines the content for Using data in a view
any blocks defined in the parent template. The view uses a parameter from the URL to pull the correct data
from the database. In this example the view is sending a context
{% extends 'learning_logs/base.html' %} dictionary to the template, containing data that should be displayed You can explore the data in your project from the command
on the page. line. This is helpful for developing queries and testing code
{% block content %} snippets.
def topic(request, topic_id):
<p>
Learning Log helps you keep track
"""Show a topic and all its entries.""" Start a shell session
topic = Topics.objects.get(id=topic_id)
of your learning, for any topic you're entries = topic.entry_set.order_by( $ python manage.py shell
learning about. '-date_added')
</p> Access data from the project
context = {
{% endblock content %} 'topic': topic, >>> from learning_logs.models import Topic
'entries': entries, >>> Topic.objects.all()
} [<Topic: Chess>, <Topic: Rock Climbing>]
return render(request, >>> topic = Topic.objects.get(id=1)
'learning_logs/topic.html', context) >>> topic.text
'Chess'

Python code is usually indented by four spaces. In

templates you’ll often see two spaces used for indentation, If you make a change to your project and the change
because elements tend to be nested more deeply in doesn’t seem to have any effect, try restarting the server:
templates. $ python manage.py runserver
 Defining the URLs Showing the current login status
Users will need to be able to log in, log out, and register. Make a You can modify the base.html template to show whether the user is
new urls.py file in the users app folder. The login view is a default currently logged in, and to provide a link to the login and logout
view provided by Django. pages. Django makes a user object available to every template,
and this template takes advantage of this object.
from django.conf.urls import url The user.is_authenticated tag allows you to serve specific
from django.contrib.auth.views import login content to users depending on whether they have logged in or not.
The {{ user.username }} property allows you to greet users
from . import views who have logged in. Users who haven’t logged in see links to
register or log in.
urlpatterns = [ <p>
url(r'^login/$', login, <a href="{% url 'learning_logs:index' %}">
Most web applications need to let users create {'template_name': 'users/login.html'}, Learning Log
accounts. This lets users create and work with their name='login'), </a>
own data. Some of this data may be private, and url(r'^logout/$', views.logout_view, {% if user.is_authenticated %}
some may be public. Django’s forms allow users to name='logout'), Hello, {{ user.username }}.
enter and modify their data. url(r'^register/$', views.register, <a href="{% url 'users:logout' %}">
name='register'), log out
] </a>
{% else %}
User accounts are handled by a dedicated app called The login template
The login view is provided by default, but you need to provide your <a href="{% url 'users:register' %}">
users. Users need to be able to register, log in, and log own login template. The template shown here displays a simple register
out. Django automates much of this work for you. login form, and provides basic error messages. Make a templates </a> -
folder in the users folder, and then make a users folder in the
Making a users app templates folder. Save this file as login.html.
<a href="{% url 'users:login' %}">
After making the app, be sure to add'users' to INSTALLED_APPS log in
The tag {% csrf_token %} helps prevent a common type of
in the project’s settings.py file. attack with forms. The {{ form.as_p }} element displays the
</a>
default login form in paragraph format. The <input> element {% endif %}
$ python manage.py startapp users
named next redirects the user to the home page after a successful </p>
Including URLS for the users app login.
Add a line to the project’s urls.py file so theusers app’s URLs are {% block content %}{% endblock content %}
included in the project. {% extends "learning_logs/base.html" %}
The logout view
urlpatterns = [ {% block content %} The logout_view() function uses Django’s logout() function
url(r'^admin/', include(admin.site.urls)), and then redirects the user back to the home page. Since there is
{% if form.errors %} no logout page, there is no logout template. Make sure to write this
url(r'^users/', include('users.urls', <p>
namespace='users')), code in the views.py file that’s stored in the users app folder.
Your username and password didn't match.
url(r'', include('learning_logs.urls', Please try again. from django.http import HttpResponseRedirect
namespace='learning_logs')), </p> from django.core.urlresolvers import reverse
] {% endif %} from django.contrib.auth import logout
def logout_view(request):
<form method="post"
"""Log the user out."""
action="{% url 'users:login' %}">
logout(request)
{% csrf token %}
There are a number of ways to create forms and work with {{ form.as_p }}
return HttpResponseRedirect(
them. You can use Django’s defaults, or completely reverse('learning_logs:index'))
<button name="submit">log in</button>
customize your forms. For a simple way to let users enter
data based on your models, use a ModelForm. This creates
<input type="hidden" name="next"
a form that allows users to enter data that will populate the
fields on a model. value="{% url 'learning_logs:index' %}"/>
The register view on the back of this sheet shows a simple </form>
approach to form processing. If the view doesn’t receive
data from a form, it responds with a blank form. If it {% endblock content %}
receives POST data from a form, it validates the data and
then saves it to the database.
The register view The register template Restricting access to logged-in users
The register view needs to display a blank registration form when The register template displays the registration form in Some pages are only relevant to registered users. The views for
the page is first requested, and then process completed paragraph formats. these pages can be protected by the @login_required decorator.
registration forms. A successful registration logs the user in and Any view with this decorator will automatically redirect non-logged
redirects to the home page. {% extends 'learning_logs/base.html' %} in users to an appropriate page. Here’s an example views.py file.

from django.contrib.auth import login {% block content %} from django.contrib.auth.decorators import /

from django.contrib.auth import authenticate login_required
from django.contrib.auth.forms import \ <form method='post' --snip--
UserCreationForm
action="{% url 'users:register' %}">
@login_required
def register(request): {% csrf_token %} def topic(request, topic_id):
"""Register a new user.""" {{ form.as_p }} """Show a topic and all its entries."""
if request.method != 'POST':
<button name='submit'>register</button>
# Show blank registration form. Setting the redirect URL
form = UserCreationForm() <input type='hidden' name='next' The @login_required decorator sends unauthorized users to the
else: value="{% url 'learning_logs:index' %}"/> login page. Add the following line to your project’s settings.py file
so Django will know how to find your login page.
# Process completed form.
form = UserCreationForm( </form> LOGIN_URL = '/users/login/'
data=request.POST)
{% endblock content %} Preventing inadvertent access
if form.is_valid(): Some pages serve data based on a parameter in the URL. You
can check that the current user owns the requested data, and
new_user = form.save() return a 404 error if they don’t. Here’s an example view.
# Log in, redirect to home page.
pw = request.POST['password1'] Users will have data that belongs to them. Any model that should from django.http import Http404
authenticated_user = authenticate( be connected directly to a user needs a field connecting instances
username=new_user.username, of the model to a specific user. --snip--
password=pw def topic(request, topic_id):
Making a topic belong to a user """Show a topic and all its entries."""
) Only the highest-level data in a hierarchy needs to be directly
login(request, authenticated_user) connected to a user. To do this import the User model, and add it topic = Topics.objects.get(id=topic_id)
return HttpResponseRedirect( as a foreign key on the data model. if topic.owner != request.user:
reverse('learning_logs:index')) After modifying the model you’ll need to migrate the database. raise Http404
You’ll need to choose a user ID to connect each existing instance --snip--
context = {'form': form} to.
return render(request, from django.db import models
'users/register.html', context) from django.contrib.auth.models import User
If you provide some initial data, Django generates a form
class Topic(models.Model): with the user’s existing data. Users can then modify and
save their data.
"""A topic the user is learning about."""
The django-bootstrap3 app allows you to use the Bootstrap
library to make your project look visually appealing. The text = models.CharField(max_length=200) Creating a form with initial data
app provides tags that you can use in your templates to date_added = models.DateTimeField( The instance parameter allows you to specify initial data for a form.
style individual elements on a page. Learn more at auto_now_add=True)
form = EntryForm(instance=entry)
http://django-bootstrap3.readthedocs.io/. owner = models.ForeignKey(User)
def __str__(self): Modifying data before saving
return self.text The argument commit=False allows you to make changes before
writing data to the database.
Heroku lets you push your project to a live server, making it Querying data for the current user new_topic = form.save(commit=False)
available to anyone with an internet connection. Heroku In a view, the request object has a user attribute. You can use this new_topic.owner = request.user
offers a free service level, which lets you learn the attribute to query for the user’s data. The filter() function then
pulls the data that belongs to the current user. new_topic.save()
deployment process without any commitment. You’ll need
to install a set of heroku tools, and use git to track the state topics = Topic.objects.filter(
of your project. See http://devcenter.heroku.com/, and click
owner=request.user)
on the Python link.