1. Branching and Iteration

Branching

if <condition>:
    <expression>
    ...
    

if <condition>:
    <expression>
    <expression>
    ...
else:
    <expression>
    <expression>
    ...
    

if <condition>:
    <expression>
    <expression>
    ...
elif <condition>:
    <expression>
    <expression>
    ...
else:
    <expression>
    <expression>
    ...
    

• <condition> has value True or False
• Block runs if <condition> is True

INDENTATION

x = float(input("Enter a number for x: "))
y = float(input("Enter a number for y: "))

if x == y:
    print("x and y are equal")
    if y != 0:
        print("therefore, x / y is", x / y)
elif x < y:
    print("x is smaller")
else:
    print("y is smaller")

print("thanks!")
  

== versus =

x = float(input("Enter a number for x: "))
y = float(input("Enter a number for y: "))

if x == y:
    print("x and y are equal")
    if y != 0:
        print("therefore, x / y is", x / y)
elif x < y:
    print("x is smaller")
else:
    print("y is smaller")

print("thanks!")
  

What if using x = y in Line #4?

→ Get SyntaxError

Interation: while loops

while <condition>:
    <expression>
    <expression>
    ...
  

while LOOP EXAMPLE

Question: What does this program do?

password = ""
while password != "python":
    password = input("Enter the password: ")

print("Access granted!")
  

Iteration: for LOOPS

for <variable> in range(<some_num>):
    <expression>
    <expression>
    ...
  

for LOOP EXAMPLE

Question: What does this program do?

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print("I like", fruit)
  

while versus for LOOPS

Iterate through numbers in a sequence:

• More complicated with while loop

  
  n = 0
  while n < 5:
      print(n)
      n = n + 1
    

• Shortcut with for loop

  
  for n in range(5):
      print(n)
    

range(start, stop, step)

• Default values:
  • start = 0 and step = 1 (both optional)
• Loop runs until value reaches stop - 1

mysum = 0
for i in range(7, 10):
    mysum += i
print(mysum)
  

mysum = 0
for i in range(5, 11, 2):
    mysum += i
print(mysum)
  

break STATEMENT

• Immediately exits whatever loop it is in
• Skips remaining expressions in the code block
• Exits only the innermost loop

while <condition_1>:
    while <condition_2>:
        <expression_a>
        break
        <expression_b>
    <expression_c>
  

break STATEMENT

Question: What happens in this program?

mysum = 0

for i in range(5, 11, 2):
    mysum += i
    if mysum == 5:
        break
    mysum += 1

print(mysum)
  

continue Statement

• Skip rest of current iteration
• Jump to next loop cycle
• Works in for & while

for i in range(5):
    if i == 2:            
        continue
    print(i)
  

for vs while loops

2. Strings

STRINGS

• Think of string as a sequence of case-sensitive characters
• Can compare strings with ==, >, <, etc.
• len() is used to retrieve the length of the string

>>> s = "abc"
>>> len(s)
3
  

STRINGS

• Square brackets are used for indexing to access characters at a position

s = "abc"

# indexes:   0   1   2
# indexes:  -3  -2  -1

s[0]   # "a"
s[1]   # "b"
s[2]   # "c"
s[3]   # error (out of bounds)
s[-1]  # "c"
s[-2]  # "b"
s[-3]  # "a"
  

STRINGS

• Can slice strings using [start:stop:step]
• If given two numbers, [start:stop]
  • step = 1 by default
• You can omit numbers and leave just colons

s = "abcdefgh"

s[3:6]     # "def", same as s[3:6:1]
s[3:6:2]   # "df"
s[::]      # "abcdefgh", same as s[0:len(s):1]
s[::-1]    # "hgfedcba", same as s[-1:-(len(s)+1):-1]
s[4:1:-2]  # "ec"
  

STRINGS

STRINGS AND LOOPS

• A for loop can iterate over the characters in a string
• These two code snippets do the same thing
• The bottom one is more “pythonic”

s = "abcdefgh"

for index in range(len(s)):
    if s[index] == 'i' or s[index] == 'u':
        print("There is an i or u")
  

for char in s:
    if char == 'i' or char == 'u':
        print("There is an i or u")
  

3. Tuples

TUPLES

te = ()                # empty tuple
t = (2, "uet", 3)      # tuple with 3 elements
t[0]                   # 2 # first element
(2, "uet", 3) + (5, 6) # (2, "uet", 3, 5, 6)
t[1:2]                 # ("uet",)   # extra comma → tuple with one element
t[1:3]                 # ("uet", 3)
len(t)                 # 3
t[1] = 4               # ❌ error, cannot modify tuple elements
  

TUPLES

• Conveniently used to swap variable values

x = y
y = x
      

temp = x
x = y
y = temp
      

(x, y) = (y, x)
      

• Used to return multiple values from a function (presented next week)

4. Lists

LISTS

• Ordered sequence of information
• Accessible by index
• Denoted by square brackets [ ]
• Contains elements
  • Usually homogeneous (e.g., all integers)
  • Can contain mixed types (not common)
• List elements can be changed → list is mutable

INDICES AND ORDERING

a_list = []         # empty list
L = [2, 'a', 4, [1, 2]]

len(L)              # 4
L[0]                # 2
L[2] + 1            # 5
L[3]                # [1, 2], another list!
L[4]                # ❌ error (index out of range)

i = 2
L[i-1]              # 'a' since L[1] = 'a'
  

CHANGING ELEMENTS

• Lists are mutable!
• Assigning to an element changes its value

>>> L = [2, 1, 3]
>>> L[1] = 5
>>> L
[2, 5, 3]
  

→ It’s the same object L, only modified in place.

Iterating Over a List

• Compute the sum of elements in a list
• Two common patterns

total = 0
for i in range(len(L)):
    total += L[i]
print(total)
      

total = 0
for x in L:
    total += x
print(total)
      

• List indices run from 0 to len(L)-1
• range(n) yields 0 to n-1

Operations on Lists — Add

>>> L = [2, 1, 3]
>>> L.append(5)
>>> L
[2, 1, 3, 5]
  

Operations on Lists — Combine

• Concatenate with + to make a new list
• Extend in place with L.extend(some_list) (mutates)

L1 = [2, 1, 3]
L2 = [4, 5, 6]
L3 = L1 + L2  # L3 == [2, 1, 3, 4, 5, 6]; L1, L2 unchanged
  

L1 = [2, 1, 3]
L1.extend([0, 6])  # L1 == [2, 1, 3, 0, 6]  (mutated)
  

Operations on Lists — Remove

• Delete at a specific index with del L[i]
• Remove last element with L.pop() (returns it)
• Remove a specific element with L.remove(x)
  • Removes first occurrence
  • Gives error if not found

L = [2, 1, 3, 6, 3, 7, 0]

L.remove(2)   # L == [1, 3, 6, 3, 7, 0]
L.remove(3)   # L == [1, 6, 3, 7, 0]
del L[1]      # L == [1, 3, 7, 0]
L.pop()       # returns 0, L == [1, 3, 7]
  

Convert Lists ↔ Strings

• list(s) → string to list of chars

  
  >>> s = "I<3 cs"
  >>> list(s)
  ['I', '<', '3', ' ', 'c', 's']
  

• s.split(sep) → string to list on separator (defaults to space)

  
  >>> s.split('<')
  ['I', '3 cs']
  

• ''.join(L) → list of strings to string

  
  >>> L = ['a', 'b', 'cde']
  >>> ''.join(L)
  'abcde'
  >>> '_'.join(L)
  'a_b_cde'
  

Other List Operations

• sorted(L) → returns sorted list, does not mutate
• L.sort() → sorts in place, mutates
• L.reverse() → reverses in place, mutates

L = [9, 6, 0, 3]

sorted(L)   # [0, 3, 6, 9], L unchanged
L.sort()    # L == [0, 3, 6, 9]
L.reverse() # L == [9, 6, 3, 0]
  

→ Check Official Python Tutorial for many more!

Mutation
Aliasing
Cloning

Lists in Memory

• Lists are mutable
• Behave differently from immutable types
• Each list is an object in memory
• Variable name points to that object
• Any variable pointing to the same object is affected
• Key phrase: side effects

An Analogy

• A person has attributes
  • Albert Einstein → scientist, genius
• He is known by many names: Dr. Einstein, Professor Einstein
• All nicknames point to the same person
• Add a new attribute to one nickname
  • Albert Einstein → scientist, genius, curious
• All nicknames refer to old AND new attributes
  • Dr. Einstein → scientist, genius, curious
  • Professor Einstein → scientist, genius, curious

Aliases

• hot is an alias for warm → changing one changes the other
• append() has a side effect

>>> a = 1
>>> b = a
>>> warm = ['red', 'yellow', 'orange']
>>> hot = warm
>>> hot.append('pink')
>>> print(warm)
['red', 'yellow', 'orange', 'pink']
  

Cloning a List

• Create a new list and copy every element with slicing

>>> cool = ['blue', 'green', 'grey']
>>> chill = cool[:]          # clone
>>> chill.append('black')
>>> print(chill)
['blue', 'green', 'grey', 'black']
>>> print(cool)
['blue', 'green', 'grey']
  

Sorting Lists

• L.sort() → mutates the list, returns None
• sorted(L) → does not mutate, returns a new sorted list

>>> warm = ['red', 'yellow', 'orange']
>>> sortedwarm = warm.sort()
>>> print(warm)
['orange', 'red', 'yellow']
>>> print(sortedwarm)
None
>>> cool = ['grey', 'green', 'blue']
>>> sortedcool = sorted(cool)
>>> print(cool)
['grey', 'green', 'blue']
>>> print(sortedcool)
['blue', 'green', 'grey']
  

Lists of Lists of Lists of ...

• Lists can be nested
• Mutations can still cause side effects

>>> warm = ['yellow', 'orange']
>>> hot = ['red']
>>> brightcolors = [warm]
>>> brightcolors.append(hot)
>>> print(brightcolors)
[['yellow', 'orange'], ['red']]
>>> hot.append('pink')
>>> print(hot)
['red', 'pink']
>>> print(brightcolors)
[['yellow', 'orange'], ['red', 'pink']]
  

Mutation and Iteration

⚠️ Avoid mutating a list while iterating over it!

• Python uses an internal counter for iteration
• Mutating changes list length but not the counter

Mutation and Iteration

def remove_dups(L1, L2):
    for e in L1:
        if e in L2:
            L1.remove(e)
      

def remove_dups(L1, L2):
    L1_copy = L1[:]
    for e in L1_copy:
        if e in L2:
            L1.remove(e)
      

5. Sets

Sets

Sets

6. Dictionaries

HOW TO STORE STUDENT INFO

• So far, can store using separate lists for every info (names, grade, course)
  • a separate list for each item
  • each list must have the same length
  • info stored across lists at same index — each index refers to info for a different person

  
  names  = ['Phong', 'Việt Anh', 'Huỳnh', 'Du']
  grade  = [3.5, 3.8, 3.2, 3.9]
  course = ['DSE2049', 'AI3054', 'AI3056', 'DSE3154']
    

How to Update/Retrieve Student Info

def get_grade(student, name_list, grade_list, course_list):
    i = name_list.index(student)
    grade = grade_list[i]
    course = course_list[i]
    return (course, grade)
  

A Better, Cleaner Way —
A Dictionary

A Python Dictionary

• Stores pairs of data: key → value.

# empty dict
my_dict = {}

# a simple grade book
grades = {
  'Phong': 3.5,
  'Việt Anh': 3.8,
  'Huỳnh': 3.2,
  'Du': 3.9
}
    

Dictionary Lookup

>>> grades = {'Phong': 3.5, 'Việt Anh': 3.8, 'Huỳnh': 3.2, 'Du': 3.9}
>>> grades['Phong']
3.5
>>> grades['An']
KeyError: 'An'
  

Dictionary Operations

>>> grades = {'Phong': 3.5, 'Việt Anh': 3.8, 'Huỳnh': 3.2, 'Du': 3.9}
  

>>> grades['An'] = 4.0
  

>>> 'Phong' in grades
True
>>> 'Long' in grades
False
  

>>> del(grades['Du'])
  

Dictionary Operations

>>> grades = {'Phong': 3.5, 'Việt Anh': 3.8, 'Huỳnh': 3.2, 'Du': 3.9}

>>> grades.keys()    
dict_keys(['Phong', 'Việt Anh', 'Huỳnh', 'Du'])

>>> grades.values()
dict_values([3.5, 3.8, 3.2, 3.9])
  

Dictionary Keys and Values

• Values
  • Can be any type (immutable or mutable)
  • Values can be duplicates
  • Values can even be lists or other dictionaries
• Keys
  • Must be unique
  • Must be an immutable type: int, float, string, tuple, bool
    • Prescisely, the key must be hashable
  • Be careful when using float as a key

list vs dict