Lecture 2

 Introduction
 Python
 Variables
 Formatting Strings
 Conditions
 Sequences
o Strings
o Lists
o Tuples
o Sets
o Dictionaries
o Loops
 Functions
 Modules
 Object-Oriented Programming
 Functional Programming
o Decorators
o Lambda Functions
 Exceptions
Introduction
 So far, we’ve discussed how to build simple web pages using
HTML and CSS, and how to use Git and GitHub in order to keep
track of changes to our code and collaborate with others.
 Today, we’ll dive into Python, one of the two main
programming languages we’ll use throughout this course.
Python

 Python is a very powerful and widely-used language that will

allow us to quickly build fairly complicated web applications. In
this course, we’ll be using Python 3, although Python 2 is still in
use in some places. When looking at outside resources, be
careful to make sure they’re using the same version.
 Let’s start where we start with many programming languages:
Hello, world. This program, written in Python, would look like
this:
print("Hello, world!")
  To break down what’s going on in that line, there is
a print function built in to the python language, that takes
an argument in parentheses, and displays that argument on
the command line.
 To actually write and run this program on your computers,
you’ll first type this line into your text editor of choice, and
then save the file as something.py. Next, you’ll head over to your
terminal, navigate to the directory containing your file, and
type python something.py. In the case of the above program, the
words “Hello, world!” will then be displayed in the terminal.
 Depending on how your computer is set up, you may have to
type python3 instead of python before the file name, and you
may even have to download Python if you haven’t already.
After installing Python, we recommend that you also download
Pip, as you’ll need that later in the course.
 When you type python file.py in your terminal, a program called
an interpreter, which you downloaded together with Python,
reads through your file line by line, and executes each line of
the code. This is different than languages like C or Java, which
need to be compiled into machine code before they can be
run.
Variables
A key part of any programming language is the ability to create and
manipulate variables. In order to assign a value to a variable in Python,
the syntax looks like this:

a = 28
b = 1.5
c = "Hello!"
d = True
e = None
Each of these lines is taking the value to the right of the =, and storing it
in the variable name to the left.

Unlike in some other programming languages, Python variable types are

inferred, meaning that while each variable does have a type, we do not
have to explicitly state which type it is when we create the variable. Some
of the most common variable types are:

 int: An integer
 float: A decimal number
 chr: A single character
 str: A string, or sequence of characters
 bool: A value that is either True or False
 NoneType: A special value (None) indicating the absence of a
value.
Now, we’ll work on writing a more interesting program that can take input
from the user and say hello to that user. To do this, we’ll use another built
in function called input which displays a prompt to the user, and returns
whatever the user provides as input. For example, we can write the
following in a file called name.py:

name = input("Name: ")

print("Hello, " + name)
When run on the terminal, this is what the program looks like:

A couple of things to point out here:

 In the first line, instead of assigning the variable name to an

explicit value, we’re assigning it to whatever the input function
returns.
 In the second line, we’re using the + operator to combine,
or concatenate, two strings. In python, the + operator can be
used to add numbers or concatenate strings and lists.
Formatting Strings
 While we can use the + operator to combine strings as we did
above, in the latest versions of python, there are even easier
ways to work with strings, known as formatted strings, or f-
strings for short.
 To indicate that we’re using formatted strings, we simply add
an f before the quotation marks. For example, instead of
using "Hello, " + name as we did above, we could write f"Hello,
{name}" for the same result. We can even plug a function into
this string if we want, and turn our program above into the
single line:
print(f"Hello, {input("Name: ")}")
Conditions
 Just like in other programming languages, Python gives us the
ability to run different segments of code based on
different conditions. For example, in the program below, we’ll
change our output depending on the number a user types in:
num = input("Number: ")
if num > 0:
print("Number is positive")
elif num < 0:
print("Number is negative")
else:
print("Number is 0")
  Getting into how the above program works, conditionals in
python contain a keyword (if, elif, or else) and then (except in
the else case) a boolean expression, or an expression that
evaluates to either True or False. Then, all of the code we want
to run if a certain expression is true is indented directly below
the statement. Indentation is required as part of the Python
syntax.
 However, when we run this program, we run into
an exception that looks like this:

 An exception is what happens when an error occurs while we’re

running our python code, and over time you’ll get better and
better at interpreting these errors, which is a very valuable skill
to have.
 Let’s look a bit more closely at this specific exception: If we
look at the bottom, we’ll see that we ran into a TypeError, which
generally means Python expected a certain variable to be of
one type, but found it to be of another type. In this case, the
exception tells us that we cannot use the > symbol to compare
a str and int, and then above we can see that this comparison
occurs in line 2.
 In this case, it’s obvious that 0 is an integer, so it must be the
case that our num variable is a string. This is happening
because it turns out that the input function always returns a
string, and we have to specify that it should be turned into
(or cast into) an integer using the int function. This means our
first line would now look like:
num = int(input("Number: "))

 Now, the program will work just as we intended!

Sequences
One of the most powerful parts of the Python language is its ability to
work with sequences of data in addition to individual variables.

There are several types of sequences that are similar in some ways, but
different in others. When explaining those differences, we’ll use the
terms mutable/immutable and ordered/unordered. Mutable means
that once a sequence has been defined, we can change individual
elements of that sequence, and ordered means that the order of the
objects matters.

Strings

: Ordered: Yes
Mutable: No
We’ve already looked at strings a little bit, but instead of just
variables, we can think of a string as a sequence of characters. This
means we can access individual elements within the string! For
example:
name = "Harry"
print(name[0])
print(name[1])
prints out the first (or index-0) character in the string, which in this case
happens to be H, and then prints out the second (or index-1) character,
which is a.

Lists

: Ordered: Yes
Mutable: Yes
A Python list allows you to store any variable types. We create a list
using square brackets and commas, as shown below. Similarly to
strings, we can print an entire list, or some individual elements. We
can also add elements to a list using append, and sort a list using sort
# This is a Python comment
names = ["Harry", "Ron", "Hermione"]
# Print the entire list:
print(names)
# Print the second element of the list:
print(names[1])
# Add a new name to the list:
names.append("Draco")
# Sort the list:
names.sort()
# Print the new list:
print(names)

Tuples

: Ordered: Yes
Mutable: No
Tuples are generally used when you need to store just two or three
values together, such as the x and y values for a point. In Python
code, we use parentheses:
point = (12.5, 10.6)
Sets

: Ordered: No
Mutable: N/A
Sets are different from lists and tuples in that they are unordered.
They are also different because while you can have two or more of
the same elements within a list/tuple, a set will only store each
value once. We can define an empty set using the set function. We
can then use add and remove to add and remove elements from that
set, and the len function to find the set’s size. Note that
the len function works on all sequences in python. Also note that
despite adding 4 and 3 to the set twice, each item can only appear
once in a set.
# Create an empty set:
s = set()

# Add some elements:

s.add(1)
s.add(2)
s.add(3)
s.add(4)
s.add(3)
s.add(1)

# Remove 2 from the set

s.remove(2)

# Print the set:

print(s)

# Find the size of the set:

print(f"The set has {len(s)} elements.")

""" This is a python multi-line comment:

Output:
{1, 3, 4}
The set has 3 elements.
"""
Dictionaries

: Ordered: No
Mutable: Yes
Python Dictionaries or dicts, will be especially useful in this course. A
dictionary is a set of key-value pairs, where each key has a
corresponding value, just like in a dictionary, each word (the key)
has a corresponding definition (the value). In Python, we use curly
brackets to contain a dictionary, and colons to indicate keys and
values. For example:
# Define a dictionary
houses = {"Harry": "Gryffindor", "Draco": "Slytherin"}
# Print out Harry's house
print(houses["Harry"])
# Adding values to a dictionary:
houses["Hermione"] = "Gryffindor"
# Print out Hermione's House:
print(houses["Hermione"])

""" Output:
Gryffindor
Gryffindor
"""
Loops

Loops are an incredibly important part of any programming language, and

in Python, they come in two main forms: for loops and while loops. For
now, we’ll focus on For Loops.

 For loops are used to iterate over a sequence of elements,

performing some block of code (indented below) for each
element in a sequence. For example, the following code will
print out the numbers from 0 to 5:
for i in [0, 1, 2, 3, 4, 5]:
print(i)

""" Output:
0
1
2
3
4
5
"""

 We can condense this code using the python range function,

which allows us to easily get a sequence of numbers. The
following code gives the exact same result as our code from
above:
for i in range(6):
print(i)

""" Output:
0
1
2
3
4
5
"""

 This type of loop can work for any sequence! For example, if
we wish to print each name in a list, we could write the code
below:
# Create a list:
names = ["Harry", "Ron", "Hermione"]

# Print each name:

for name in names:
print(name)
""" Output:
Harry
Ron
Hermione
"""

 We can get even more specific if we want, and loop through

each character in a single name!
name = "Harry"
for char in name:
print(char)

""" Output:
H
a
r
r
y
"""
Functions
We’ve already seen a few python functions such as print and input, but
now we’re going to dive into writing our own functions. To get started,
we’ll write a function that takes in a number and squares it:

def square(x):
return x * x
Notice how we use the def keyword to indicate we’re defining a function,
that we’re taking in a single input called x and that we use
the return keyword to indicate what the function’s output should be.

We can then “call” this function just as we’ve called other ones: using
parentheses:

for i in range(10):
print(f"The square of {i} is {square(i)}")

""" Output:
The square of 0 is 0
The square of 1 is 1
The square of 2 is 4
The square of 3 is 9
The square of 4 is 16
The square of 5 is 25
The square of 6 is 36
The square of 7 is 49
The square of 8 is 64
The square of 9 is 81
"""
Modules
As our projects get larger and larger, it will become useful to be able to
write functions in one file and run them in another. In the case above, we
could create create one file called functions.py with the code:
def square(x):
return x * x
And another file called square.py with the code:

for i in range(10):
print(f"The square of {i} is {square(i)}")
However, when we try to run square.py, we run into the following error:

We run into this problem because by default, Python files don’t know
about each other, so we have to explicitly import the square function from
the functions module we just wrote. Now, when square.py looks like this:

from functions import square

for i in range(10):
print(f"The square of {i} is {square(i)}")
Alternatively, we can choose to import the entire functions module and
then use dot notation to access the square function:

import functions

for i in range(10):
print(f"The square of {i} is {functions.square(i)}")
There are many built-in Python modules we can import such
as math or csv that give us access to even more functions. Additionally, we
can download even more Modules to access even more functionality! We’ll
spend a lot of time using the Django Module, which we’ll discuss in the
next lecture.

Object-Oriented Programming
Object Oriented Programming is a programming paradigm, or a way of
thinking about programming, that is centered around objects that can
store information and perform actions.

 Classes: We’ve already seen a few different types of variables

in python, but what if we want to create our own type?
A Python Class is essentially a template for a new type of
object that can store information and perform actions. Here’s a
class that defines a two-dimensional point:
class Point():
# A method defining how to create a point:
def __init__(self, x, y):
 self.x = x
self.y = y

 Note that in the above code, we use the keyword self to

represent the object we are currently working with. self should
be the first argument for any method within a Python class.
Now, let’s see how we can actually use the class from above to create an
object:

p = Point(2, 8)
print(p.x)
print(p.y)

""" Output:
2
8
"""
Now, let’s look at a more interesting example where instead of storing just
the coordinates of a Point, we create a class that represents an airline
flight:

class Flight():
# Method to create new flight with given capacity
def __init__(self, capacity):
self.capacity = capacity
self.passengers = []

# Method to add a passenger to the flight:

def add_passenger(self, name):
self.passengers.append(name)
However, this class is flawed because while we set a capacity, we could
still add too many passengers. Let’s augment it so that before adding a
passenger, we check to see if there is room on the flight:

class Flight():
# Method to create new flight with given capacity
def __init__(self, capacity):
self.capacity = capacity
self.passengers = []

# Method to add a passenger to the flight:

def add_passenger(self, name):
if not self.open_seats():
return False
self.passengers.append(name)
return True

# Method to return number of open seats

def open_seats(self):
return self.capacity - len(self.passengers)
Note that above, we use the line if not self.open_seats() to determine
whether or not there are open seats. This works because in Python, the
number 0 can be interpretted as meaning False, and we can also use the
keyword not to signify the opposite of the following statement so not
True is False and not False is True. Therefore, if open_seats returns 0, the
entire expression will evaluate to True

Now, let’s try out the class we’ve created by instantiating some objects:

# Create a new flight with o=up to 3 passengers

flight = Flight(3)

# Create a list of people

people = ["Harry", "Ron", "Hermione", "Ginny"]

# Attempt to add each person in the list to a flight

for person in people:
if flight.add_passenger(person):
print(f"Added {person} to flight successfully")
else:
print(f"No available seats for {person}")

""" Output:
Added Harry to flight successfully
Added Ron to flight successfully
Added Hermione to flight successfully
No available seats for Ginny
"""
Functional Programming
In addition to supporting Object-Oriented Programming, Python also
supports the Functional Programming Paradigm, in which functions are
treated as values just like any other variable.

Decorators

One thing made possible by functional programming is the idea of a

decorator, which is a higher-order function that can modify another
function. For example, let’s write a decorator that announces when a
function is about to begin, and when it ends. We can then apply this
decorator using an @ symbol.

def announce(f):
def wrapper():
print("About to run the function")
f()
print("Done with the function")
return wrapper

@announce
def hello():
print("Hello, world!")

hello()

""" Output:
About to run the function
Hello, world!
Done with the function
"""
Lambda Functions

Lambda functions provide another way to create functions in python. For

example, if we want to define the same square function we did earlier, we
can write:

square = lambda x: x * x
Where the input is to the left of the : and the output is on the right.

This can be useful when we don’t want to write a whole separate function
for a single, small use. For example, if we want to sort some objects where
it’s not clear at first how to sort them. Imagine we have a list of people,
but with names and houses instead of just names that we wish to sort:

people = [
{"name": "Harry", "house": "Gryffindor"},
{"name": "Cho", "house": "Ravenclaw"},
{"name": "Draco", "house": "Slytherin"}
]

people.sort()

print(people)
This, however, leaves us with the error:

Which occurs because Python doesn’t know how to compare two

Dictionaries to check if one is less than the other.

We can solve this problem by including a key argument to the sort

function, which specifies which part of the dictionary we wish to use to
sort:

people = [
{"name": "Harry", "house": "Gryffindor"},
{"name": "Cho", "house": "Ravenclaw"},
{"name": "Draco", "house": "Slytherin"}
]

def f(person):
return person["name"]

people.sort(key=f)

print(people)

""" Output:
[{'name': 'Cho', 'house': 'Ravenclaw'}, {'name': 'Draco', 'house': 'Slytherin'}, {'name':
'Harry', 'house': 'Gryffindor'}]
"""
While this does work, we’ve had to write an entire function that we’re only
using once, we can make our code more readable by using a lambda
function:

people = [
{"name": "Harry", "house": "Gryffindor"},
{"name": "Cho", "house": "Ravenclaw"},
{"name": "Draco", "house": "Slytherin"}
]

people.sort(key=lambda person: person["name"])

print(people)

""" Output:
[{'name': 'Cho', 'house': 'Ravenclaw'}, {'name': 'Draco', 'house': 'Slytherin'}, {'name':
'Harry', 'house': 'Gryffindor'}]
"""
Exceptions
During this lecture, we’ve run into a few different exceptions, so now we’ll
look into some new ways of dealing with them.

In the following chunk of code, we’ll take two integers from the user, and
attempt to divide them:

x = int(input("x: "))
y = int(input("y: "))

result = x / y

print(f"{x} / {y} = {result}")

In many cases, this program works well:

However, we’ll run into problems when we attempt to divide by 0:

We can deal with this messy error using Exception Handling. In the
following block of code, we will try to divide the two numbers, except when
we get a ZeroDivisionError:

import sys

x = int(input("x: "))
y = int(input("y: "))

try:
result = x / y
except ZeroDivisionError:
print("Error: Cannot divide by 0.")
# Exit the program
sys.exit(1)

print(f"{x} / {y} = {result}")

In this case, when we try it again:

However, we still run into an error when the user enters non-numbers for
x and y:

We can solve this problem in a similar manner!

import sys
try:
x = int(input("x: "))
y = int(input("y: "))
except ValueError:
print("Error: Invalid input")
sys.exit(1)

try:
result = x / y
except ZeroDivisionError:
print("Error: Cannot divide by 0.")
# Exit the program
sys.exit(1)

print(f"{x} / {y} = {result}")

That’s all for this lecture! Next time, we’ll use Python’s Django Module to
build some applications!