Lecture 2

• Introduction
• Python
• Variables
• Formatting Strings
• Conditions
• Sequences
  • Strings
  • Lists
  • Tuples
  • Sets
  • Dictionaries
  • Loops
• Functions
• Modules
• Object-Oriented Programming
• Functional Programming
  • Decorators
  • 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!