What You’ll Learn in This Course

Lists and Dictionaries

Loops

Functions
Brush up on the basics in
Try Python!
Files

Modules
 The Spam Van
At the end of this course, we want to create a basic sales system for our circus food truck —
the Spam Van.

o u i n
e e y
n't s
a v e KS !
H O N
Y

e e r i o !
p, C h p l y
Pip Pi s h i n g , s i m
S m a G !
A S H I N
S M

y !
e e k
C h

… But first, we will start with a list of British slang to inspire our
menu.
 Level 1

Slanguage
Section 1 – Lists
A List Is a Container of Things
Lists in Python are containers that can store anything
[1, 2, 3, …]
you want.

# an empty list # list of numbers

empty = [] nums = [10, 20, 30, 40.5]

# list of strings
words = ['cheerio', 'cheers', 'watcha', 'hiya']

# list of mixed items

anything = [10, 'hello', 'ahoy', 123.45]

Note: A Python list is called an array in

other languages, like JavaScript.
An Item’s Index Is Its Position
List items are ordered starting with index (or position) 0.

greetings = ['cheers', 'cheerio', 'watcha', 'hiya']

index [0] [1] [2] [3]

>>> greetings[0] 'cheers'

>>> greetings[3] 'hiya'

>>> greetings[1:3] ['cheerio', 'watcha']

You can also slice a list to get a

sub-section of the list.
Creating a List and Adding Items
Let’s create a list of British sayings.

slang = ['cheerio', 'pip pip', 'smashing'] Can create the list with british = []
print(slang) elements in it already,
or empty

['cheerio', 'pip pip', 'smashing']

We can add items as we need.

slang.append('cheeky') append() adds new items to
slang.append('yonks') the end of our list.
print(slang) list_name.append(item)

['cheerio', 'pip pip', 'smashing', 'cheeky', 'yonks']

Removing Elements
We can remove items from our list by using the value or the index.

slang = ['cheerio', 'pip pip', 'smashing', 'cheeky', 'yonks']

[0] [1] [2] [3] [4]

slang.remove('cheeky') Either OR del slang[3]

depending on whether
you know the value or the index
print(slang)

['cheerio', 'pip pip', 'smashing', 'yonks']

We can also delete a slice.

slang = ['cheerio', 'pip pip', 'smashing', 'yonks']

del slang[:2]
print(slang)

['smashing', 'yonks']
 Level 1

Slanguage
Section 2 – Dictionaries
Maintaining Two Lists
What if we also wanted a list to keep track of the American definitions of our British slang list?
If we do anything to one of our lists, we have to duplicate the operation in the other list.

slang = ['cheerio', 'pip pip', 'smashing', 'yonks', 'knackered']

translation = ['goodbye', 'goodbye', 'terrific', 'ages', 'tired']
[0] [1] [2] [3] [4]

del slang[0] If we add or delete from one list…

del translation[0] we have to do the same thing in the other list.

print(slang)
print(translation)

['pip pip', 'smashing', 'yonks', 'knackered']

['goodbye', 'terrific', 'ages', 'tired']

We can improve upon this with dictionaries…

A Dictionary Maps Keys to Values
A dictionary is similar to a list, but you look up values by using a key instead of an index.

key value
Great for our slang translator —
'cheerio' 'goodbye'
we can look up the definition of a word with the word!
'knackered' 'tired'

slang = {'cheerio':'goodbye', 'knackered':'tired', 'yonks':'ages'}

Key Assign to Value Each item is known as

a “key-value pair”
To look up a value in a dictionary,
we send in a key
print(slang['cheerio'])
( instead of index in a list ).

'goodbye'
Dictionaries Can Hold Anything
Dictionaries, like lists, can hold anything you want: numbers, strings, a mix of both, and other
objects.

Dictionary of strings to strings

slang = {'cheerio':'goodbye', 'rubbish':'trash'}

Dictionary of strings to numbers

A menu item’s name is the key,
menu = {'spam meal':15, 'spam with fries':10}
and its price is the value.

Dictionary of anything

anything = {10:'hello', 2:123.45}

Creating a Dictionary and Adding Values
Create an empty dictionary:

slang = {}

Adding dictionary items:

slang['cheerio'] = 'goodbye' This is how you add key-value pairs,

slang['smashing'] = 'terrific' and also how you can update values.
slang['knackered'] = 'tired'
print(slang)

{'cheerio': 'goodbye', 'smashing': 'terrific', 'knackered': 'tired'}

Updating Values in Our Dictionary
Our current dictionary:

print(slang)

{'cheerio': 'goodbye', 'smashing': 'terrific', 'knackered': 'tired'}

Let’s update the value for smashing...

slang['smashing'] = 'awesome'

… and look up and print the same value.

print(slang['smashing'])

awesome
Removing Dictionary Items
You can delete an item from a dictionary by looking up its key.

slang = {'cheerio':'goodbye', 'knackered':'tired', 'smashing':'terrific'}

del slang['cheerio'] del will delete the key-value pair

from the dictionary
print(slang)

{'smashing': 'terrific', 'knackered': 'tired'}

Get an Item That Might Not Be There
Trying to access a key that doesn’t exist will cause an error.

slang['bloody']

KeyError: 'bloody'

If you want to check if a word is in the dictionary, use get().

# Get a value that might not be there

result = slang.get('bloody') Using get() is a best practice because
print(result) it won’t crash your program.

If the word WAS NOT None is a type that represents

None
in the dictionary the absence of a value.
 None Type
None represents the absence of a value, and also evaluates to False in a conditional.

Result equals None because slang = {'cheerio':'goodbye', 'knackered':'tired'}

the key doesn’t exist result = slang.get('bloody')

If exists… if result:
print(result)
Other wise else:
print('Key doesn't exist')

Key doesn't exist

Using a Dictionary to Translate a Sentence
Let’s translate each slang word in a sentence:

slang = {'mate':'buddy', 'knackered':'tired', 'cheeky':'offensive'}

sentence = 'Sorry, my ' + 'mate' + "'s a bit " + 'cheeky' + '!'

translation = 'Sorry, my ' + slang.get('mate') + "'s a bit " +

slang.get('cheeky') + '!'

print(sentence)
print(translation)

Sorry, my mate's a bit cheeky!

Sorry, my buddy's a bit offensive!
 Level 1

Slanguage
Section 3 – Comparing and Combining
Lists and Dictionaries
Comparing Lists
How do we check if two lists are equal?

my_list = [1, 2, 3, 4]
your_list = [4, 3, 2, 1]
his_list = [1, 2, 3, 4]

print(my_list == your_list) False

print(my_list == his_list) True

Two lists need to have the same values

in the same order to be equal.
Comparing Dictionaries
How do we check if two dictionaries are equal?

my_dict = {1:1, 2:2, 3:3, 4:4}

your_dict = {4:4, 3:3, 2:2, 1:1}

print(my_dict == your_dict) True

Since dictionaries aren’t ordered, they only

need to have the same key-value pairs
to be equal.
Breakfast, Lunch, and Dinner Menus
Let’s say we have three separate menu lists: Breakfast, Lunch, Dinner…
How would we combine these into one list?

breakfast = ['Spam n Eggs', 'Spam n Jam', 'Spam n Ham']

lunch = ['SLT (Spam-Lettuce-Tomato)', 'PB&S (PB&Spam)']

dinner = ['Spalad', 'Spamghetti', 'Spam noodle soup']

One list?
A List of Lists
You can have a container of containers — Menus is a list of menus, and each menu is a list of foods.

list of lists

menus = [ ['Spam n Eggs', 'Spam n Jam', 'Spam n Ham'],

['SLT (Spam-Lettuce-Tomato)', 'PB&S (PB&Spam)'],
['Spalad', 'Spamghetti', 'Spam noodle soup'] ]

print('Breakfast Menu:\t', menus[0])

print('Lunch Menu:\t', menus[1])
print('Dinner Menu:\t', menus[2])

Breakfast Menu: ['Spam n Eggs', 'Spam n Jam', 'Spam n Ham']

Lunch Menu: ['SLT (Spam-Lettuce-Tomato)', 'PB&S (PB&Spam)']
Dinner Menu: ['Spalad', 'Spamghetti', 'Spam noodle soup']
Getting an Item From a Two-dimensional List
You can use two indexes to get an individual item.

How would you get this item?

menus = [ ['Spam n Eggs', 'Spam n Jam', 'Spam n Ham'],

['SLT (Spam-Lettuce-Tomato)', 'PB&S (PB&Spam)'],
['Spalad', 'Spamghetti', 'Spam noodle soup'] ]

print(menus[0]) The list at index 0 in the outer list

['Spam n Eggs', 'Spam n Jam', 'Spam n Ham']

A good start! Now we just need to get the second item in this list.
Getting an Item From a Two-dimensional List
You can use two indexes to get an individual item.

How would you get this item?

menus = [ ['Spam n Eggs', 'Spam n Jam', 'Spam n Ham'],

['SLT (Spam-Lettuce-Tomato)', 'PB&S (PB&Spam)'],
['Spalad', 'Spamghetti', 'Spam noodle soup'] ]

print(menus[0][1] ) The list at index 0 in the outer list,

the item at index 1 in the inner list

'Spam n Jam' It would be better if we didn’t have to know

breakfast was at index 0, lunch at 1, etc.
A Dictionary of Lists
We can use a dictionary with keys for Breakfast, Lunch, and Dinner.

Dictionary where… each value is a list

menus = {'Breakfast': ['Spam n Eggs', 'Spam n Jam', 'Spam n Ham'],

'Lunch': ['SLT (Spam-Lettuce-Tomato)', 'PB&S (PB&Spam)'],
'Dinner': ['Spalad', 'Spamghetti', 'Spam noodle soup'] }

print('Breakfast Menu:\t', menus['Breakfast'])

print('Lunch Menu:\t', menus['Lunch'])
print('Dinner Menu:\t', menus['Dinner'])

Breakfast Menu: ['Spam n Eggs', 'Spam n Jam', 'Spam n Ham']

Lunch Menu: ['SLT (Spam-Lettuce-Tomato)', 'PB&S (PB&Spam)']
Dinner Menu: ['Spalad', 'Spamghetti', 'Spam noodle soup']
 Level 2

Loopty Loops
Section 1 – For Loops and range()
 The Spam Van
At the end of this course, we want to create a basic sales system for our circus food truck —
the Spam Van.

Let’s calculate the average price of our menu so

that we can prove we deserve a single $$$$
rating on sites like Yelp.

To do this, we’ll use a loop to look

at each price in our price list.
for Loop: For Each item in Our List, Do This
prices = [2.50, 3.50, 4.50] Like saying “do this”
for each number price in our list prices
for price in prices:
price is a temporary print('Price is', price) The loop runs one time for
variable that holds one each price in the list.
of the prices in the list
for each run.

price Loop Output

1st loop 2.50 Price is 2.5

2nd loop 3.50 Price is 3.5
3rd loop 4.50 Price is 4.5
 Using a for Loop to Sum Our Prices
Let’s look at our for loop for summing the prices in action.

# Average price
total = 0
prices = [2.50, 3.50, 4.50]

We can add to for price in prices: price is 2.5

total = 0 + 2.5
our total print('Price is', price) total is 2.5
and print total total = total + price price is 3.5
to see it print('total is', total) total = 2.5 + 3.5
total is 6
changing.
price is 4.5
total is 10.5 total = 6 + 4.5
Averaging the Prices After the Loop Ends

# Average price
total = 0
prices = [2.50, 3.50, 4.50]

for price in prices: The print statements were just so that

total = total + price we could “see” what was happening, so
we can remove them now.
average = total/len(prices)
print('avg is', average)
After the loop,
we compute the average.

avg is 3.5
 Generating Raffle Tickets
We also want to do something fun for our customers — with each purchase, they get a raffle
ticket, and then we draw 10 random ticket numbers at the end of the day and give out prizes.

We’ll need to:

(1) Generate a random ticket number
(2) Repeat that 10 times — we can use a loop to do
this!
Generating a Random Ticket Number
First, how do we get a single random number?

import random
r1 = random.random() Gives us a random number from [0.0, 1.0)
print(r1)

0.80945

r2 = random.choice([1,2,3,4,5]) Gives us a random choice from a list

print(r2)

r3 = random.randint(1, 1000) Gives us a random number in this range

print(r3)
This will allow us to pick a random raffle ticket
from 1 to 1,000
902
Now we just need to do that 10 times…
Generating 10 Random Raffle Tickets

import random What do we put here if

we don’t have a list?
for i in ???:
ticket = random.randint(1, 1000)
print(ticket)

How do we iterate through the

for loop 10 times?

range(10)

range(count) generates a list of [0, …, count-1] behind the scenes.

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Using range() in Our for Loop
import random
for i in range(10) :
ticket = random.randint(1, 1000)
print(ticket)

698
689
328
113 We don’t have to use i in our loop,
707 but we can if we want to…
958
440
297
189
899
Getting More Specific With range()
We’ve held our circus in Orlando, Florida, every other year since 2005 until now — 2016.
How would we list the years?
start stop step

for i in range(2005, 2016, 2): We can also call range() with more
print(i) parameters: start, stop, and step.

2005 Add 2
2007
2009
2011
2013
2015 Stop before
2016
 Level 2

Loopty Loops
Section 2 – The Spam Van Menu
 The Spam Van
At the end of this course, we want to create a basic sales system for our circus food truck —
the Spam Van.

… Let’s start creating the menu with for loops The Spam Van
Menu
 Create Our Monty Python Restaurant Menu
For each British slang word, let’s create a menu item made with Spam.

slang = ['Knackered ', 'Pip pip', 'Squidgy', 'Smashing']

menu = []

for word in slang: For each slang word in our list,

menu.append(word + ' Spam') we’ll concatenate Spam to it,
and we’ll add that to our menu list.
print(menu)

['Knackered Spam', 'Pip pip Spam', 'Squidgy Spam', 'Smashing Spam']

 Assigning Prices to Our Menu Items
For each of our menu items, let’s assign prices and use a dictionary to store them.

menu = ['Knackered Spam', 'Pip pip Spam', 'Squidgy Spam', 'Smashing Spam']

$0.50 $1.50 $2.50 $3.50

# Let's store the menu items with their prices in a dictionary

menu_prices = {}
price = 0.50
for item in menu:
menu_prices[item] = price The item is the key — for example,
price = price + 1 'Knackered Spam' is the key
and $0.50 is the value.
print(menu_prices)

{'Pip pip Spam' : 1.50, 'Squidgy Spam': 2.50,

'Smashing Spam': 3.50, 'Knackered Spam': 0.50}
 Printing Our Menu Items
Now the following dictionary we created is stored in memory.

menu_prices = {'Knackered Spam': 0.50, 'Pip pip Spam': 1.50,

'Squidgy Spam': 2.50, 'Smashing Spam': 3.50}

Could we print out each item in our dictionary in a loop like a list?

for item in menu_prices: This will default to

print(item) just printing the keys in
a dictionary.

Pip pip Spam

Squidgy Spam
Smashing Spam
Knackered Spam
 Using a Dictionary’s Key and Value in a for Loop

menu_prices = {'Knackered Spam': 0.50, 'Pip pip Spam': 1.50,

'Squidgy Spam': 2.50, 'Smashing Spam': 3.50}

for name, price in menu_prices.items():

print(name, ': $', price) Now the loop has access to
both the key and the value
here — name and price.

Pip pip Spam : $ 0.5 We’d like to format this

Squidgy Spam : $ 1.5
better, though, by getting
Smashing Spam : $ 2.5
rid of these spaces…
Knackered Spam : $ 3.5

Note: To get a list of the keys in a dictionary, use dict_name.keys()

and to get a list of the values in a dictionary, use dict_name.values()
 Formatting Our Menu Items
Let’s get rid of the unnecessary spaces in our output.

menu_prices = {'Knackered Spam': 0.50, 'Pip pip Spam': 1.50,

'Squidgy Spam': 2.50, 'Smashing Spam': 3.50}

for name, price in menu_prices.items(): print() defaults to having a space to

print(name, ': $', price, sep='') separate each word. We can override this by
setting sep = empty string.

Pip pip Spam: $0.5

Squidgy Spam: $1.5
Looking better — now we
Smashing Spam: $2.5
just need to add rounding to
Knackered Spam: $3.5
t wo decimal places.
 Rounding a Float to a Certain Number of Decimal Places
Since $1.5 doesn’t look as nice as $1.50, we’ll need to round to two decimal places.

menu_prices = {'Knackered Spam': 0.50, 'Pip pip Spam': 1.50,

'Squidgy Spam': 2.50, 'Smashing Spam': 3.50}

for name, price in menu_prices.items():

print(name, ': $', format(price, '.2f') , sep='') We can format our price
float to t wo decimal
places using the built-in
2 decimal places,
format() function.
f for float format

Pip pip Spam: $0.50

Squidgy Spam: $1.50
Looks great!
Smashing Spam: $2.50
Knackered Spam: $3.50
 Level 2

Loopty Loops
Section 3 – While Loops
Interface for Ordering Menu Items
We want to let customers order and add as many menu items as they want. A for loop wouldn’t
be good for this because we don’t know how many times to loop…

The Cheeky Spam,

please!
… And a Squidgy Spam!
A Simple while Loop Example
A while loop would be better since while loops continue looping while a condition is True.

Like saying “do this”

x = 1
as long as x does not equal 3
while x != 3:
print('x is', x)
The loop would run forever unless
x = x + 1
we changed x so the conditional
could eventually be false.

x Loop Output

1st loop 1 x is 1
2nd loop 2 x is 2
3rd loop 3 loop is done running
Let’s Create Our Interface for Ordering From a Menu
We’ll use a while loop to let customers order and add as many menu items as they want.

orders = []
order = input("What would you like to order? (Q to Quit)")

while (order.upper() != 'Q'):

# Find the order and add it to the list if it exists
# See if the customer wants to order anything else

The Cheeky Spam,

please!
… And a Squidgy Spam!
Adding Menu Items to the Orders List
We only want to add the customer’s order if it exists on the menu. I left the order of the red arrows
and code in the green box
because the instructor had it
set up that way. Let me know if
it needs to be different!
orders = []
order = input("What would you like to order? (Q to Quit)")

while (order.upper() != 'Q'):

# Find the order and add it to the list if it exists

found = menu.get(order) Try to get() the menu item

if found:
orders.append(order) If it exists, add it to the list
else:
print("Menu item doesn't exist") If not, let the customer
know
# See if the customer wants to order anything else

If we don’t change “order” in the

loop, it will never be “Q” and the
loop will never stop running.
Asking the Customer if They Want to Order More
We want to let customers order and add as many menu items as they want.

orders = []
order = input("What would you like to order? (Q to Quit)")

while (order.upper() != 'Q'):

# Find the order and add it to the list if it exists
found = menu.get(order)
if found:
orders.append(order)
else:
print("Menu item doesn't exist")

# See if the customer wants to order anything else

order = input("Anything else? (Q to Quit)")
Wasn’t letting me put print
(orders) with the rest of the
print(orders) code above it.
Ordering Interface in Action
Another Way to Break Out of the Loop
A break statement will exit the loop immediately and continue running the program.

orders = []
order = input("What would you like to order? (Q to Quit)")

while (order.upper() != 'Q'): (True): Always run the loop forever...

if order.upper() == 'Q': … unless the user types “Q ,”
break then break out of the loop.
# Find the order and add it to the list if it exists
…

# See if the customer wants to order anything else

order = input("Anything else? (Q to Quit)")

print(orders)
Using Continue for Special Cases in the Loop
We have a problem — we ran out of Cheeky Spam! We’ll need to let customers know…

orders = []
order = input("What would you like to order? (Q to Quit)")

while (True):
if order == 'Cheeky Spam': If the order is Cheeky Spam,
print('Sorry, we're all out of that!') skip the rest of the code in the loop one time,
continue go to the top, and start running again.
if order.upper() == 'Q':
break

# Find the order and add it to the list if it exists

…
# See if the customer wants to order anything else
order = input("Anything else? (Q to Quit)")

print(orders)
Infinite Loops Are Bad

Oops, we accidentally
created an infinite loop!

If this happens to you:

Stay calm
Press Ctrl+C
 Fixing our Infinite Loop
We need to get the customer’s order at the top of our loop now so they can change their order.

…
while (True):
# See if the customer wants to order anything else Move the ordering
order = input("Can I take your order? (Q to Quit)") to the top of the loop.

if order == 'Cheeky Spam':

Now if they order
print("Sorry, we're all out of that!")
Cheeky Spam,
continue
they can order
elif order.upper() == 'Q':
again.
break

# Find the order and add it to the list if it exists

…

print(orders)
Ordering Interface Demo
 Level 3

Functions in Flight
Section 1 – Introduction to Functions
Problem: We’re Repeating a Lot of Code
And we also want to
We’ve got this code that And this code that gets the
write code to calculate
gets the average price average daily customers
average daily sales…
# Average price # Average daily customers
total = 0 total = 0
prices = [2.50, 3, 4.50, 5] customers = [29, 21, 55, 5
10, 14, 12]
for price in prices:
total = total + price for cust in customers:
total = total + cust
average = total/len(prices)
average = total/len(customers)

Wouldn’t it be great to just have one piece of code that can average anything we ask it to?
Functions Perform Specific Tasks
Functions are like mini programs that allow us to perform a specific task.

Menu item prices Average of prices

go in comes out

Daily customers Average of daily

go in customers comes out
Code calculates the
average

The code performing these

calculations is a function.
 Some Functions We’ve Used Before
We’ve been using functions print('Welcome to the Spam Van!')
all along, like print():

The String Output to the

'Welcome to the console
Spam Van!'
print()

Another function we’ve seen before, range(): my_list = range(10)

The number 10 Return a list from

0 to 9
range()
Making Our Own Function
We need to define three things to make our own function.

1 What is the
function name?

What data do we What data comes

2 send into the out of the 3
function? function?
Step One: Naming the Function
The name of the function here is “average.”

Name:
The name of the function is
how we’ll run it later.

Every function def average():

starts with ...
def. Colon :
A colon marks the
beginning of the
function’s code.
Step Two: Declaring Function Parameters
These parameters are variables that can be used in the function.

Parameters:
Any variables
we need the
def average(prices): function to use
...
 Step Three: Return Data From the Function

def average(prices):
...

return avg
Indented:
The code inside of the
function is indented.
Return value:
Functions may or may not return values —
this function returns the value of a
variable called avg.

Returning data from a function is optional.

Putting Code in the average() Function
We could take our average price code from Level 2 and make that its own function.

Our code from Level 2 Parameter

# Average price def average(prices ):

total = 0 total = 0
prices = [29, 21, 55, 10]
for price in prices: for price in prices:
total = total + price total = total + price

avg = total/len(prices) avg = total/len(prices)

print(avg) return avg
Indented

Return value
Calling the average() Function
Functions don’t run until you call them.

numbers = [1,2,3,4,5] Function call

Assignment my_average = average(numbers)
print(my_average) Our parameter is a
list of numbers.
3
I think average(numbers)
my_average now contains the value 3 — should animate first and
the result of calling the average function then my_average =
Generalizing Our average() Function
We want to use our function for getting the average for other lists of numbers, not just prices.
Before After Change the name of
def average(prices): def average(numbers): the parameter to be
total = 0 total = 0 more general.

for price in prices: for num in numbers:

total = total + price total = total + num

avg = total/len(prices) avg = total/len(numbers)

return avg return avg

Notice how this general average function can average the numbers in any list!
For example, we can use it here…
The variable name of our list
daily_sales = [10,14,8] doesn’t have to match what it’s
result = average(daily_sales) called in the function.
How Our Function Executes Code
This is our file with our function defined, followed by our main program where we use our function.

def average(numbers): But inside the function,

total = 0 that data is accessed in a
for num in numbers: variable named numbers.
total = total + num

avg = total/len(numbers)
return avg

# Use our function on prices

Program starts here: prices = [2.50, 3, 4.50, 5]
The prices array is sent as
result = average(prices) an input to the function.

print(result)

3.75
 Level 3

Functions in Flight
Section 2 – main()
 main() and Calling main()
A best practice is to organize our main program code into a function called… main().

Before After
def average(numbers): def average(numbers):
total = 0 total = 0
for num in numbers: for num in list:
total = total + num total = total + num

avg = total/len(numbers) avg = total/len(numbers)

return avg return avg

# main def main():

prices = [29, 21, 55, 10] Organize our main prices = [29, 21, 55, 10]
code into a main
The main part result = average(prices)
result = average(prices) function.
of our program
where all of the print(result)
print(result)
execution starts main()
Still need to call
main() to execute
our program.
Order of Execution
Let’s look at the order that each line of our program gets run in.

def average(numbers):
* The average() total = 0
function will only for num in list:
run when it gets total = total + num
called.
avg = total/len(numbers)
Since these are
return avg
functions, they don’t
get run until they're
def main(): called.
2 Then runs all of the prices = [29, 21, 55, 10]
result =* average(prices)
code in main()

print(result)
main()
1 All of the execution
starts here!
Understanding Local Scope
def average(numbers):
total = 0 Local scope
for num in list:
total = total + num The variables declared in
the average function only
exist within the function.
avg = total/len(numbers)
return avg Their scope is local
to this function.
def main():
prices = [29, 21, 55, 10]
result = average(prices)
print(total) If we try to access
print(result) total in main(),
we get this error…
main()

NameError: name 'total' is not defined

Understanding Global Scope
def average(numbers):
total = 0
for num in list:
total = total + num

avg = total/len(numbers)
return avg

def main():
prices = [29, 21, 55, 10]
If we try to access
result = average(prices)
print(order_goal) order_goal in main(),
NO errors…
print(result)

order_goal = 25 Global scope The variables declared outside of a

main() function have global scope, so they
can be accessed in another function.
25
28.75
Order Matters With Variable Declaration
def average(numbers):
total = 0
for num in list:
total = total + num

avg = total/len(numbers)
return avg

def main():
prices = [29, 21, 55, 10]
result = average(prices) At this point, order_goal
print(order_goal) hasn’t been declared yet!
print(result) So we'll get an error here…

main() We’re calling main() before

order_goal = 25 order_goal is declared…

NameError: name 'order_goal' is not defined

 Level 3

Functions in Flight
Section 3 – Spam Van Functions
When to Create Functions?
Functions should be used for any chunk of code that has a specific purpose. For instance, here
are all of the things we want to implement in our Food Truck Order System:

1 Print the menu

These are all pretty self-contained tasks,
so it makes sense that we would create
2 Take an order
separate functions for them.

We have a plan for the Spam Van —

3 Calculate the total bill
let’s get started!

The Cheeky Spam,

please!
 1 Writing a Function to Print Our Menu
menu = {'Knackered Spam': 0.50, 'Pip pip Spam': 1.50, …}

def function(parameters…):
parameters:
we need the menu to
def print_menu(menu): be able to print it
for name, price in menu.items():
print(name, ': $', format(price, '.2f'), sep='')

Indented: Return value:

Contents of the Functions can return values —
function are this function doesn’t need to The code to print
indented. because it’s just printing. the menu that
we already had
 2 Moving the Order Loop to a Function

Function
def get_order(menu):
definition Parameters
orders = []
We need the
Indented order = input("What would you like to order? (Q to Quit)")
menu to add
the item to
while (order.upper() != 'Q'):
the order.
# find the order
found = menu.get(order)
if found:
orders.append(order)
else:
print("Menu item doesn't exist")
The code to get
order = input("Anything else? (Q to Quit)") an order that we
already wrote
Return return orders
value
How the main() Function Executes
def get_order(menu):
…

def print_menu(menu):
…

def main():
menu = {'Knackered Spam': 0.50, 'Pip pip Spam': 1.50, …}
print_menu(menu)
order = get_order(menu)
print("You ordered:",order)

main()
3 Calculating the Total Bill
Finally, we want to calculate the customer’s total bill.

menu
orders
cheeky spam 1.0
cheeky spam cheerio spam 2.0 Could have added this
line… :-/

pip pip spam pip pip spam 3.0 if order in list(menu.keys()):, or

used get()
knackered spam knackered spam 4.0

Parameters
def bill_total(orders, menu): We need the list of orders and
total = 0 the menu to look up the price.

for order in orders: Program logic

total += menu[order] For each order in our orders list,
we want to add the price to our total.
return total Return the total
bill_total() After the First Order
First loop:
order: 'cheeky spam'
orders menu
total = 0 + 1.0 = 1.0
cheeky spam 1.0
cheeky spam Add the price to the total
cheerio spam 2.0
pip pip spam
pip pip spam 3.0
knackered spam
knackered spam 4.0

Take each order Look up its price in the menu

def bill_total(orders, menu):

total = 0 We look up the price of the
item in the menu using the
for order in orders: order name as a key.
total += menu[order]

return total
bill_total() After the Second Order
First loop:
order: 'cheeky spam'
orders menu
total = 0 + 1.0 = 1.0
cheeky spam 1.0
cheeky spam order: 'pip pip spam'
cheerio spam 2.0
pip pip spam total = 1.0 + 3.0 = 4.0
pip pip spam 3.0
knackered spam
knackered spam 4.0 Add the price to the total

Take each order Look up its price in the menu

def bill_total(orders, menu):

total = 0

for order in orders:

total += menu[order]

return total
bill_total() After the Third Order
First loop:
order: 'cheeky spam'
orders menu
total = 0 + 1.0 = 1.0
cheeky spam 1.0
cheeky spam order: 'pip pip spam'
cheerio spam 2.0
pip pip spam total = 1.0 + 3.0 = 4.0
pip pip spam 3.0
knackered spam
knackered spam 4.0 order: 'knackered spam'
total = 4.0 + 4.0 = 8.0
Take each order Look up its price in the menu return total

def bill_total(orders, menu):

total = 0

for order in orders:

total += menu[order]

return total
Putting It All Together
spam_van.py

def print_menu(menu):
…
def get_order(menu):
…
def total_bill(orders, menu):
…
def main():
menu = {'Knackered Spam': 0.50, 'Pip pip Spam': 1.50, …}
print_menu(menu)
orders = get_order(menu)
total = bill_total(orders, menu)
print("You ordered:", order,
"Your total is: $", format(total,'.2f'), sep='')

main()
Demo of the Spam Van
 Level 4

Spam Van Data

Section 1 – Writing Files
Problem: Our Orders Disappear When We Quit
Let’s say we have a short program that gets a dictionary of orders from a customer. As soon as
the program ends, the dictionary is not in memory anymore…

s a le s .t x t

Squidgy Spam .50

Smashing Spam 1.50

We can save orders by writing

our sales to a file.
How to Write to a File
Here are the steps to write to a file.

File name Mode

1 Open sales_log = open('spam_orders.txt', 'w') 'w' for write

'r' for read
sales_log.write('The Spam Van') 'a' for append
2 Write sales_log.write('Sales Log')

3 Close sales_log.close()

The Spam VanSales Log If the file doesn’t exist for a

write or an append, Python will
automatically create the file.

We also need to add our own

newlines.
Writing a Newline to a File
Unlike print(), when we use write(), we need to add newlines.

1 Open sales_log = open('spam_orders.txt', 'w')

sales_log.write('The Spam Van\n')

2 Write sales_log.write('Sales Log')
Newline
3 Close sales_log.close()

The Spam Van

Sales Log
Newline
 We Need to Build a Customer Sales Log
After we get a customer’s order, it would be great if we could record each sale to a sales.txt file.

One single order comes in as a dictionary of menu items and their price.
s a le s .tx t
Customer 1 order = {'Cheeky Spam': 1.0, 'Chips Spam': 4.0}
Cheeky Spam 1.00

Yonks Spam 4.00

total = 5.00

Knackered Spam 1.00
 Customer 2 order = {'Knackered Spam': 1.0}

total = 1.00

Cheerio Spam 1.00


Smashing Spam 3.00

total = 4.00
Customer 3 order = {'Cheerio Spam': 1.0, 'Smashing Spam': 3.0}
The Steps to Write to Our Sales Log
One single order

order = {'Cheeky Spam': 1.0, 'Yonks Spam': 4.0}

s a le s .tx t
def write_sales_log(order):
# open the file Cheeky Spam 1.00

1 Open Yonks Spam 4.00

file = open('sales.txt', 'w') total = 5.00

# write each item to the file

2 Write
# write the total to the file

# close the file

3 Close
file.close()
Writing Out Each Order
def write_sales_log(order):
file = open('sales.txt', 'w')
s a l e s .t x t
Need order.items() to
for order in order:
get the key and value Cheeky Spam 

file.write(order+'\n')
Yonks Spam 

file.close()

def main():
order = {'Cheeky Spam': 1.0, 'Yonks Spam': 4.0}
write_sales_log(order)

We’ll call our write_sales_log()

function from our main() function.
Writing Out the Price
def write_sales_log(order):
file = open('sales.txt', 'w') s a le s .tx t

for item, price in order.items(): Cheeky Spam 1.00


file.write(item + ' ' + format(price, '.2f') + '\n' ) Yonks Spam 4.00


file.close()

We also want the order total

def main():
order = {'Cheeky Spam': 1.0, 'Yonks Spam': 4.0}
write_sales_log(order)
 Writing Out the Order Total
def write_sales_log(order):
file = open('sales.txt', 'w')
Create
s a le s .tx t
the total total = 0
for item, price in order.items(): Cheeky Spam 1.00

file.write(item + ' ' + format(price, '.2f') + '\n') Yonks Spam 4.00

total = 5.00
Add to it total += price

Write it file.write('total = ' + format(total, '.2f') + '\n')

file.close()
Now our sales log has the
total of all orders
def main():
order = {'Cheeky Spam': 1.0, 'Yonks Spam': 4.0}
write_sales_log(order)
We Don’t Want to Overwrite Our File
def write_sales_log(order):
file = open('sales.txt', 'w') Change this to 'a' for append s a le s .tx t

Cheeky Spam 1.00


total = 0 Yonks Spam 4.00

for item, price in order.items(): total = 5.00
file.write(item + ' ' + format(price, '.2f') + '\n')
total += price
s a le s .tx t
file.write('total = ' + format(total, '.2f') + '\n')
Cheerio Spam 1.00

file.close() Smashing Spam 3.00

total = 4.00

def main():
order = {'Cheeky Spam': 1.0, 'Yonks Spam': 4.0}
write_sales_log(order ) We over write the file…
order = {'Cheerio Spam': 1.0, 'Smashing Spam': 3.0} Instead, we want to append.
write_sales_log(order)
Appending Orders to Our File
def write_sales_log(order):
file = open('sales.txt', 'a' ) 'a' for append s a le s .tx t
Cheeky Spam 1.00

total = 0 Yonks Spam 4.00

for item, price in order.items(): total = 5.00
file.write(item + ' ' + format(price, '.2f') + '\n') Cheerio Spam 1.00

total += price Smashing Spam 3.00

total = 4.00
file.write('total = ' + format(total, '.2f') + '\n')
file.close()

def main():
order = {'Cheeky Spam': 1.0, 'Yonks Spam': 4.0}
write_sales_log(order )
order = {'Cheerio Spam': 1.0, 'Smashing Spam': 3.0}
write_sales_log(order)
Adding a Newline Between Orders
def write_sales_log(order):
file = open('sales.txt', 'a' )
s a le s .tx t
total = 0 Cheeky Spam 1.00

for item, price in order.items(): Yonks Spam 4.00

file.write(item + ' ' + format(price, '.2f') + '\n') total = 5.00
total += price Cheerio Spam 1.00

Smashing Spam 3.00

file.write('total = ' + format(total, '.2f') + '\n\n') total = 4.00
file.close()

def main():
order = {'Cheeky Spam': 1.0, 'Yonks Spam': 4.0}
write_sales_log(order )
order = {'Cheerio Spam': 1.0, 'Smashing Spam': 3.0}
write_sales_log(order)
 Level 4

Spam Van Data

Section 2 – Reading Files
The Spam Van Has a Value Menu
Every day, the boss sends us a file of dollar menu items. We want to read this file into a list so our
program can use it.

Today's
dollar menu!

l l a r _me n u .t x t
do

cheeky spam
cheerio spam
pip pip spam ['Cheeky Spam', 'Cheerio Spam', 'Pip Pip Spam']
Reading the Entire Contents of a File
file_name.read() will return a string containing the entire contents of the file.
file name mode
l l a r _m e n u .t x t
do
1 open dollar_spam = open('dollar_menu.txt', 'r')
cheeky spam 'r' for read
cheerio spam 2 read print(dollar_spam.read())
pip pip spam
3 close dollar_spam.close()

cheeky spam
cheerio spam
pip pip spam
 Reading an Individual Line From a File
file_name.readline() will return a string for the next single line in the file.

l l a r _m e n u .t x t
do def read_dollar_menu():
dollar_spam = open('dollar_menu.txt', 'r')
cheeky spam print('1st line:', dollar_spam.readline())
cheerio spam readline() will read print('2nd line:', dollar_spam.readline())
pip pip spam until a newline '\n' dollar_spam.close()

1st line: cheeky spam

2nd line: cheerio spam
Reading the Dollar Menu as a List of Lines
We can read all of the lines individually in a loop, which will be convenient to add each item to a list.

l l a r _m e n u .t x t def read_dollar_menu():
do
dollar_spam = open('dollar_menu.txt', 'r')
cheeky spam
for line in dollar_spam: Now, instead of
cheerio spam
print(line) printing each line,
pip pip spam
let’s add them to a list.
dollar_spam.close()

Cheerio Spam

Pip Pip Spam

Knackered Spam

Cheeky Spam
Reading the Dollar Menu Into a List
We can add each line item to a list inside of our for loop.

def read_dollar_menu():
l l a r _m e n u .t x t dollar_spam = open('dollar_menu.txt', 'r')
do

cheeky spam dollar_menu = []

cheerio spam for line in dollar_spam:
dollar_menu.append(line) This will combine all
pip pip spam
items into a list.
print(dollar_menu)
dollar_spam.close()

['Cheerio Spam\n', 'Pip Pip Spam\n', 'Knackered Spam\n', 'Cheeky Spam']

We want to get rid of

the newlines \n.
Stripping Leading or Trailing Whitespace
Since each line has the newline character at the end, we want to strip that off.

def read_dollar_menu():
_ m aern_u
m .texntu .t x t dollar_spam = open('dollar_menu.txt', 'r')
do l l adro l l

cheeky spam dollar_menu = []

cheerio spam for line in dollar_spam: str.strip() removes any
pip pip spam line = line.strip() leading or trailing
dollar_menu.append(line) whitespace.

print(dollar_menu)
dollar_spam.close()

['Cheerio Spam', 'Pip Pip Spam', 'Knackered Spam', 'Cheeky Spam']

Newlines are gone!

 Level 4

Spam Van Data

Section 3 – Try, Except
Problem: The Program Crashes When an Error Happens
What happens if we try to open a file that doesn’t exist?

my_file = open('name.txt', 'r')

FileNotFoundError: No such file or directory: 'name.txt'

This error will cause our program to crash…

It would be great if we could recover and

continue our program even if we get an error!
Using Try, Except to Recover From Errors
Try, except blocks catch errors so that we can avoid a program crash.

try: Like saying “try this”

file = open('sales.txt', 'r') and if you get an error…
print(file.read())
except:
print('File doesn't exist') Go here and print this error message

And then continue with the program

File doesn't exist

Program prints your error message,

telling the user what the problem was.
 Types of Exceptions
Python has 60-plus types of exceptions. Here are some of the ones we’ve seen before:

FileNotFoundError File doesn’t exist

IndexError Index out of bounds

KeyError Key doesn’t exist

NameError Variable name doesn’t exist in local or global scope

ValueError Value is the wrong type

Let’s look at specifically handling this value error next…

You can find all of the types of

Python 3 exceptions here: http://go.codeschool.com/python-exceptions
Try, Except in Other Situations
We can also use try, except in other situations that might have unexpected problems…
like casting user input to a number.

price = input("Enter the price: ")

try:
price = float(price)
print('Price =', price)
except ValueError: We can also look for a
print('Not a number!') specific type of error.

Enter the price: 25 Enter the price: oops

Price = 25.0 Not a number!

The user enters a number so there’s no error. Program prints the exception,
telling the user what the problem was,
then continues.
Storing the Exception’s Error Message
We can also save the exception’s error message in a variable for printing.

price = input("Enter the price: ")

try:
price = float(price)
print('Price =', price)
except ValueError as err: Create a variable 'e rr'
print(err) to hold the error message.

Enter the price: yo

could not convert string to float: 'yo'

We can just print out the exact same

error the Python interpreter gives us.
 Level 5

Help Me Help You

Section 1 – Using Modules
 The Spam Van Franchise
The Spam Van is now a franchise, and each of the vans download the daily menu from a website.

Headquarters
Menu
To do this, we need
the Python requests module.
Introducing Modules
Modules are code libraries that contain functions we can call from our code. They make our lives
easier by implementing the hard stuff for us.

Instead of rewriting complicated code,

Reuse code instead of reinventing the wheel!
it’s already been done for us!

import random import math

ticket = random.randint(1, 1000) answer = math.sqrt(3)

print(ticket) print(answer)

Modules — another tool

for the toolbox!
 Installing Modules With Pip
The requests module does not come pre-installed with Python, so we’ll have to install it. Pip is a
package manager that will install modules for us.

pip install Name of the module

installs python modules

>>> pip install requests

Collecting requests
downloading …100%
Installing collected packages: requests
Successfully installed requests-2.8.1

pip is a package manager that comes pre-installed with Python 3.4.

For earlier versions, you can install pip with: python get-pip.py

Check out all available Python packages: http://go.codeschool.com/pypi

The HTTP Request Response Cycle

Our request for data from

the ser ver is called an
HTTP request.

spam_van.py The server responds with

data in a format called JSON.
Web Ser ver
 Using JSON to Format and Share Data
JSON is a standard way to format and share data.
JSON uses a collection of keys and values, which
look just like Python dictionaries …
[.
{/
"price": "3.00",
"name": "Omelet",
"desc": "Yummy"
},
{?
Dictionary "price": "5.75",
{'key': 'value', 'key': 'value'} "name": "Burrito",
"desc": "Breakfast Burrito"
},
{;
"price": "4.50",
"name": "Waffles",
"desc": "Belgian waffles with syrup"
},
]'
 JSON Looks Like Dictionaries and Lists
JSON uses a collection of keys and values, which
look just like Python dictionaries and lists
[.
List {/
[…] "price": "3.00",
"name": "Omelet",
"desc": "Yummy"
},
{?
Dictionary "price": "5.75",
{'key': 'value', 'key': 'value'} "name": "Burrito",
"desc": "Breakfast Burrito"
},
{;
"price": "4.50",
"name": "Waffles",
"desc": "Belgian waffles with syrup"
},
]'
How Would JSON Be Used to Store Our Menu?
What if we wanted to store more information about a menu item — its name, description, and
price? We could do this with a dictionary that has keys for name, description, and price.

first_item = {'name': 'Spam n Eggs',

'description': 'Two eggs with Spam',
'price':2.50}

second_item = {'name': 'Spam n Jam',

'description': 'Biscuit with Jam with Spam',
'price':3.50}

print(first_item['name'], first_item['price'])
print(second_item['name'], second_item['price'])

Spam n Eggs 2.5

Spam n Jam 3.5
A List of Dictionaries
first_item = {'name': 'Spam n Eggs',
'description': 'Two eggs with Spam',
'price':2.50}

second_item = {'name': 'Spam n Jam',

'description': 'Biscuit with Jam with Spam',
'price':3.50}

menu_items = [first_item, second_item]

Remember: first access the outer list,
then access the dictionary key.
print(menu_items[0]['name'], menu_items[0]['price'], menu_items[0]['desc'])
print(menu_items[1]['name'], menu_items[1]['price'], menu_items[1]['desc'])

Spam n Eggs 2.5 Two eggs & Spam

Spam n Jam 3.5 Biscuit, Jam & Spam
Spam n Ham 4.5 Ham & Spam
 A List of Dictionaries That Looks Like JSON
menu_items = [{'name': 'Spam n Eggs',
'desc': 'Two eggs & Spam', menu_items[0]
'price':2.50},
m a t t a {'name': 'Spam n Jam',
f o r d a
o ur S O N .
w h e J e s t 'desc': 'Biscuit, Jam & Spam', menu_items[1]
No a s t r e q u
me o u r 'price':3.50},
e s a o m
h r
is t l l ge t f {'name': 'Spam n Ham',
w e ’ 'desc': 'Ham & Spam',
menu_items[2]
'price':4.50}]

Instead of hard-coding this menu, let’s get it from our HTTP request.
Getting Today’s Menu
Requesting and printing today’s menu.

Import the module so we can use it for requests

import requests
Call requests.get() with our URL
my_request = requests.get('http://go.codeschool.com/spamvanmenu')

menu_list = my_request.json() Get the response in JSON format

print(menu_list)

[{"price": "3.00", "name": "Omelet", "desc": "Yummy"},

{"price": "5.75", "name": "Burrito", "desc": "Breakfast Burrito"},
{"price": "4.50", "name": "Waffles", "desc": "Belgian waffles with syrup"}]
Printing Out the Menu
Requesting and printing today’s menu.

import requests

my_request = requests.get('http://go.codeschool.com/spamvanmenu')

menu_list = my_request.json()

print("Today's Menu:")
for item in menu_list:
print(item['name'], item['desc'], item['price'])

Today's Menu:
Omelet Yummy 3.00
Burrito Breakfast Burrito 5.75
Waffles Belgian waffles with syrup 4.50
Formatting the Menu
Requesting and printing today’s menu.

import requests

my_request = requests.get('http://go.codeschool.com/spamvanmenu')

menu_list = my_request.json()

print("Today's Menu:")
for item in menu_list:
print(item['name'], ': ', item['desc'].title(), ', $',
item['price'], sep='' )

Today's Menu:
Omelet: Yummy, $3.00
Burrito: Breakfast Burrito, $5.75
Waffles: Belgian waffles with syrup, $4.50
Demo
 Level 5

Help Me Help You

Section 2 – Creating Modules
Lots of Code in One File Is a Problem
If we put all of our code in one file, it’s going to get really hard to read and maintain.

spam_van.py Right now, this one

script is responsible for:

printing the menu

taking orders
sales reports
accessing the menu
from the network
Creating Modules for Organization
A script containing definitions is a module and can be imported by a script or another module.

spam_van.py orders.py menu.py sales.py

import orders
import menu
import sales

Module Module Module

Script

same As long as all of these files are in the same directory, we can import
directory them into spam_van.py by writing import module_name.
 Figuring Out What Goes in the Orders Module
spam_van.py orders.py

def print_menu(menu):
We want to move …
these definitions def get_order(menu):
into a separate …
orders.py file. def total_bill(orders, menu):
…
Module
Need to figure out
how to use orders
def main(): functionality in
Our main menu = {'Cheerio Spam': 0.50,…} here
functionality stays print_menu(menu) spam_van.py
in our spam_van.py orders = get_order(menu)
script. total = bill_total(orders, menu)
print('You ordered:', order, 'Total:', total)

main()

Script
 The Result of Splitting Orders Into a Module
orders.py
def print_menu(menu):
…
def get_order(menu):
…
def total_bill(orders, menu):
…
spam_van.py
def main():
menu = {'Cheerio Spam': 0.50,…}
print_menu(menu)
orders = get_order(menu)
total = bill_total(orders, menu)
print('You ordered:', order, 'Total:', total)

When we run main()

spam_van.py, we get
this error. NameError: name 'print_menu' is not defined
Importing the Orders Module
orders.py
def print_menu(menu):
…
def get_order(menu):
…
def total_bill(orders, menu):
…
spam_van.py
import orders This import will find our orders.py file if it’s in the same directory.

def main():
menu = {'Cheerio Spam': 0.50,…}
print_menu(menu)
orders = get_order(menu)
total = bill_total(orders, menu)
Wait — this is print('You ordered:', order, 'Total:', total)
still generating main()
an error.
NameError: name 'print_menu' is not defined
Using the Module Name to Access the Functions
orders.py
def print_menu(menu):
…
def get_order(menu):
…
def total_bill(orders, menu):
…
spam_van.py
We need to add import orders
the module name def main():
orders. menu = {'Cheerio Spam': 0.50,…}
before our orders.print_menu(menu)
function calls orders = orders.get_order(menu)
total = orders.bill_total(orders, menu)
print('You ordered:', order, 'Total:', total)
main()
Now our program
will run!
Demo: The App Running