• functions
• recursion

• introduce new compound data types
  • tuples
  • lists

• Tuples are an ordered sequence of elements, can mix element types
• cannot change element values, immutable
• represented with parentheses

te = ()   # an empty tuple
t = (2, "mit", 3)   # a tuple with three elements
t

## (2, 'mit', 3)

t = (1, 2, 3, 4, "burkay", "genc")
t[3]

## 4

t[2:4]

## (3, 4)

t[3:4]

## (4,)

• The last one returns a tuple with one element.
  • The “,” is included to make it a tuple.
• Be very careful
  • t[3] and t[3:4] are not the same

• concatenate and multiply

t1 = (1, 2, 3)
t2 = ("a", "b", "c")
t3 = t1 + t2
t3

## (1, 2, 3, 'a', 'b', 'c')

3 * t1

## (1, 2, 3, 1, 2, 3, 1, 2, 3)

• can only concatenate tuples to tuples

t1 + 4

## TypeError: can only concatenate tuple (not "int") to tuple

• can nest tuples

t1 = ("burkay", "genc", 41)
t2 = (t1, "married", 2)
t2

## (('burkay', 'genc', 41), 'married', 2)

t2[0][1]

## 'genc'

• Like strings, tuples are immutable
  • Immutable: Cannot be changed

t = ("dr", "burkay", "genc")
t[0] = "prof."

## TypeError: 'tuple' object does not support item assignment

• You should construct a new tuple as follows:

t = ("dr", "burkay", "genc")
t2 = ("prof",) + t[1:3]
t2

## ('prof', 'burkay', 'genc')

• Tuples can be used as arguments and return values of functions

def foo(t):
  return 2*t

foo((1,2,3)) 

## (1, 2, 3, 1, 2, 3)

• Write a function that takes a tuple and returns the maximum element within the tuple.

• Write a function that takes a tuple and returns the maximum element within the tuple.

def max(t):
  maximum = t[0]
  for item in t:
    if item > maximum:
      maximum = item
  return maximum

tup = (3, -2, 5, 7, 8, -4, 1, 3, 1, -5)
max(tup)

## 8

• Write a function that takes a tuple and computes the sum of items in the tuple.

• Write a function that takes a tuple and computes the sum of items in the tuple.

def sum(t):
  curSum = 0
  for item in t:
    curSum = curSum + item
  return curSum

tup = (3, -2, 5, 7, 8, -4, 1, 3, 1, -5)
sum(tup)

## 17

• Write a function that returns the mean of a tuple of numbers.
  • mean: the sum of items divided by the number of items

• Write a function that returns the mean of a tuple of numbers.
  • mean: the sum of items divided by the number of items

def mean(t):
  return sum(t) / len(t)   # Reusing sum() from previous exercise

tup = (3, -2, 5, 7, 8, -4, 1, 3, 1, -5)
mean(tup)

## 1.7

• Write a function that returns the sum of two rationals.
  • The rationals are provided as tupples

def sumRational(r1, r2):
  ....


sumRational( (3, 5), (2, 4) )

## (22,20)

• ordered sequence of information, accessible by index
• a list is denoted by square brackets, []
• a list contains elements
  • usually homogeneous (ie, all integers)
  • can contain mixed types (not common, use tuples)
• list elements can be changed so a list is mutable
  • main difference between tuples and lists

a_list = []
L = [2, 'a', 4, [1,2]]
len(L)                    # evaluates to 4

## 4

L[0]                      # evaluates to 2

## 2

L[2]+1                    # evaluates to 5

## 5

L[3]                      # evaluates to [1,2], another list!

## [1, 2]

i = 2
L[i-1]                    # evaluates to ‘a’ since L[1]='a' above

## 'a'

li1 = [1,2,3]
li2 = [4,5,6]
li1 + li2

## [1, 2, 3, 4, 5, 6]

3 * li1

## [1, 2, 3, 1, 2, 3, 1, 2, 3]

• Elements of a list can be changed

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

## [2, 5, 3]

• Write a function that takes a list and returns the maximum element within the list.

• Write a function that takes a list and returns the maximum element within the list.

def max(li):
  maximum = li[0]
  for item in li:
    if item > maximum:
      maximum = item
  return maximum

li = [3, -2, 5, 7, 8, -4, 1, 3, 1, -5]
max(li)

## 8

• Write a function that takes a list of numbers and replaces all occurrences of the maximum value with -1.

• Write a function that takes a list of numbers and replaces all occurrences of the maximum value with -1.

def replaceMax(li):
  maxVal = max(li)     # reusing the function from the previous slide
  for i in range(len(li)):
    if li[i] == maxVal:
      li[i] = -1       # because lists are mutable, we can do this
  return li

myList = [4, 9, 3, 2, 0, 5, 4, 9, 8, 5, 1, 7, 9]
replaceMax(myList)

## [4, -1, 3, 2, 0, 5, 4, -1, 8, 5, 1, 7, -1]

• Write a function that takes a list of numbers and computes the value \(3x^2-2x+1\) for each \(x\) in the list and finally returns all computed values as a list.

• Write a function that takes a list of numbers and computes the value \(3x^2-2x+1\) for each \(x\) in the list and finally returns all computed values as a list.

def foo(li):
  result = []
  for num in li:
    result = result + [3 * num ** 2 - 2 * num + 1]
  return result

foo([1,2,3,4,5,6,7,8,9,10])

## [2, 9, 22, 41, 66, 97, 134, 177, 226, 281]

• In Python, some structures are called Objects
  • We will later learn more about them
• Objects store some data in them
• They also have special functions in them
  • You can use those functions using the dot (.) notation:

  object.function()

• append an object to the end of the list

li1 = [1, 2, 3]
li2 = [4, 5, 6]
li1.append(li2)
li1

## [1, 2, 3, [4, 5, 6]]

• extend a list with elements from another list

li1 = [1, 2, 3]
li2 = [4, 5, 6]
li1.extend(li2)
li1

## [1, 2, 3, 4, 5, 6]

• count an element in a list

li1 = [1, 2, 3, 4, 2, 4, 1, 3, 2, 5]
item = 2
li1.count(item)

## 3

• insert an object into a list at a specific position

li1 = [1, 2, 3]
item = 4
li1.insert(1, item)
li1

## [1, 4, 2, 3]

• remove the first occurrence of an item

li1 = [1, 2, 3, 2, 3, 1]
item = 3
li1.remove(item)
li1

## [1, 2, 2, 3, 1]

• find the index of the first occurence of an item

li1 = [1, 2, 3, 4, 2, 4, 1, 3, 2, 5]
item = 4
li1.index(item)

## 3

• pop the item at a specific position
  • If no position is given, then pops the last item

li1 = [1, 2, 3, 4, 5]
li1.pop(3)

## 4

li1.pop()

## 5

li1

## [1, 2, 3]

• sort the list

li1 = [4, 2, 3, 1, 3, 5]
li1.sort()
li1

## [1, 2, 3, 3, 4, 5]

• use sorted to not mutate the list and return a new list

li1 = [4, 2, 3, 1, 3, 5]
sorted(li1)

## [1, 2, 3, 3, 4, 5]

li1

## [4, 2, 3, 1, 3, 5]

• reverse the list

li1 = [1, 2, 3, 4, 2, 4, 1, 3, 2, 5]
li1.reverse()
li1

## [5, 2, 3, 1, 4, 2, 4, 3, 2, 1]

• Given lists l1 and l2, return a list of their common items

• Given lists l1 and l2, return a list of their common items

• strategy

  • Initialize result as an empty list
  • Iterate over the items in the first list
    • For each item, check if it exists in the second list
      • If so, then add it to the result
  • return result

• Given lists l1 and l2, return a list of their common items

def intersect(l1, l2):
  l3 = []
  for item in l1:
    if l2.count(item) > 0:
      l3.extend(item)
  return l3

• Is this a correct solution?
  • Do we need to refine this code?
  • Let’s test

• Given lists l1 and l2, return a list of their common items

def intersect(l1, l2):
  l3 = []
  for item in l1:
    if l2.count(item) > 0:
      l3.append(item)
  return l3

l1 = [1,2,3,4,5,6,1,2,3,4,1,2,3]
l2 = [2,3,4]
intersect(l1, l2)

## [2, 3, 4, 2, 3, 4, 2, 3]

• How to fix this?
  • Each item must appear only once

• Given lists l1 and l2, return a list of their common items

def intersect(l1, l2):
  l3 = []
  for item in l1:
    if l2.count(item) > 0 and l3.count(item) == 0:
      l3.append(item)
  return l3

l1 = [1,2,3,4,5,6,1,2,3,4,1,2,3]
l2 = [2,3,4]
intersect(l1, l2)

## [2, 3, 4]

• Write a function to compute the median element in a given list. The median is the middle item in a sorted list.
  • Strategy : sort the list, find the index of the middle item, return it
• Write a function that takes the top-left and bottom-right coordinates of a rectangle as two tuples. The function then returns the area of the rectangle.
  • Strategy : Find the width, find the height, multiply.
• [Difficult] Write a function (or more) that returns the most frequent character in a string.
  • Strategy : Use a second list that keeps binary tuples, each tuple is a char, frequency pair. You store the char frequencies in the corresponding tuple.
  • This exercise prepares the student to the dictionary concept of the next week.

• Write a phone book application.
  • The phone book is basically a list of tuples.
  • Each tuple in the list is (name, surname, phonenumber)
• You will write the following functions:
  • addContact(pb, contact): adds contact tuple into pb phonebook
  • removeContact(pb, contact): finds and removes contact from pb
  • checkNumber(pb, (name, surname)): checks the provided (name,surname) in the pb and outputs the corresponding phone number if found in pb. If the (name, surname) tuple is not found in the phone book, then the application outputs name surname not found.

• BONUS exercise
  • Make sure addContact does not add duplicate contact information
  • Make sure removeContact does not crash, if the contact does not exist in the phonebook
• DOUBLE BONUS exercise
  • Can you modify your program so that one (name, surname) tuple can have multiple phone numbers? Modify addContact, removeContact, checkNumber accordingly.

These slides are a direct adaptation of the slides used for MIT 6.0001 course present (as of February 2020) on MIT OCW web site.

Original work by:

Ana Bell, Eric Grimson, and John Guttag. 6.0001 Introduction to Computer Science and Programming in Python. Fall 2016. Massachusetts Institute of Technology: MIT OpenCourseWare. License: Creative Commons BY-NC-SA.

Adapted by and for:

Assoc. Prof. Dr. Burkay Genç. MUH101 Introduction to Programming, Spring 2020. Hacettepe University, Computer Engineering Department.