Today's Topics

Review

• Time for Computer Operations
• Reading a File into a List
• Advantages of Using Lists with Files
• Problems with Copying Objects
• Copying Lists
• Functions That Return Lists
• Functions That Return Objects
• Functions That Work with Lists
• Functions That Change Lists

New Material

• List Elements
• Two-Dimensional Lists
• Solving Problems with Two-Dimensional Lists
• Tuples
• The tuple Conversion Function
• Why Use Tuples?
• Tic-Tac-Toe
• Tic-Tac-Toe - Step 1
• Tic-Tac-Toe - Step 2
• Tic-Tac-Toe - Step 3
• Tic-Tac-Toe - Step 4
• Tic-Tac-Toe - Step 5
• Tic-Tac-Toe - Step 6
• Tic-Tac-Toe - Step 7

Final Exam

TBA

Review

Time for Computer Operations

• Computers are very fast
• But different computer operations take different amounts of time
• There are three time scales for accessing data
  • Getting data from a user
  • Getting data from a file
  • Getting data from memory

Reading a File into a List

• When we first talked about files, I showed you a script to find the average temperature
• Then I showed you another script to find the days above average
• The second script required reading the file twice
• This is inefficient
• Instead, I can read a file and create a list
• I can then work on the data in the list
• Reading data from a file takes time
• It is much faster to read data from memory
• Here is the algorithm for creating a list from a file

  create an empty list
  for each line in the file:
      append the line to the empty list

• Using this algorithm we can write the following

  file = open('numbs.txt', 'r')
  numbers = []
  for line in file:
      numbers.append(int(line))
  
  total = 0
  for num in numbers:
      total += num
  
  average = round(total/len(numbers))
  
  above_average = 0
  for num in numbers:
      if num > average:
          above_average += 1
  
  print(above_average)

• I did not have to count the entries because I could use len
• Actually this code is not efficient
• It uses 3 for loops
  1. Read in the file to create the list
  2. Loop through the list to create the total
  3. Loop through the list to get the entries above average
• We can combined the first two loops into a single for loop

  file = open('numbs.txt', 'r')
  total = 0
  numbers = []
  for line in file:
      num = int(line)
      numbers.append(num)
      total += num
  
  average = round(total/len(numbers))
  
  above_average = 0
  for num in numbers:
      if num > average:
          above_average += 1
  
  print(above_average)

Advantages of Using Lists with Files

• Reading a file into a list has a number of advantages
• We do not have to count the number of entries in the file
• We can get this value using len on the list object
• Once we have read the values from a file into a list we can use the max function
• We can also use min to get the minimum value
• We can sort the file values in ascending order using the list sort method
• We can sort the values in descending order using sort and reverse

Problems with Copying Objects

• To make a copy of a variable holding a number we use an assignment statement

  >>> number_1 = 5
  >>> number_2 = number_1
  >>> number_2
  5

• If you then change number_1 the value of number_2 remains unchanged

  >>> number_1 = 6
  >>> number_1
  6
  >>> number_2
  5

• This not true for objects, such as lists
• Let's say we create a list object and store it's location in the variable list_1

  >>> list_1 = [1,2,3,4,5,6,7]
  >>> list_1
  [1, 2, 3, 4, 5, 6, 7]

• What happens if we copy this list variable?
• You can create a new variable list_2 by assigning it the value of list_1

  >>> list_2 = list_1
  >>> list_2
  [1, 2, 3, 4, 5, 6, 7]

• But when you change something in list_1 the same change appears in list_2

  >>> list_1[6] = 8
  >>> list_1
  [1, 2, 3, 4, 5, 6, 8]
  >>> list_2
  [1, 2, 3, 4, 5, 6, 8]

• Let's look at what is happening in memory
• When we first created list_1 we have this

• When we copy list_1 to list_2 we have this

• list_1 and list_2 point to the same object
• When we make a change using list_1, it's the same as using list_2 to make the change

  >>>  list_1[6] = 8

• Using an assignment statement to create a new list variable does not work
• It merely creates a new variable referring to the same list
• This is true for all objects
• Creating two variables that point to the same object is a very bad idea

Copying Lists

• To copy a list you need to create a new list
• We can do this using concatenation and the empty list

  >>> list_1
  [1, 2, 3, 4, 5, 6, 7]
  >>> list_2 = [] + list_1
  >>> list_2
  [1, 2, 3, 4, 5, 6, 7]

• Here is the picture in memory

• Now when you change one list the other remains unchanged

  >>> list_1[6] = 8
  >>> list_1
  [1, 2, 3, 4, 5, 6, 8]
  >>> list_2
  [1, 2, 3, 4, 5, 6, 7]

• In memory, it looks like this

• You can also copy a list using a slice

  >>> list_1 = [1,2,3,4,5,6,7]
  >>> list_2 = list_1[:]
  >>> list_1[6] = 10
  >>> list_1
  [1, 2, 3, 4, 5, 6, 10]
  >>> list_2
  [1, 2, 3, 4, 5, 6, 7]

Functions That Return Lists

• Functions can return objects as well as values
• Here is the algorithm for creating a list from a fie

  use the filename to create a file object
  create an empty list
  for each line in the file:
      convert the line into a number
      add the number to the empty list
  return a variable pointing to the list

• This gives us the following code

  #! /usr/bin/python3
  # reads a text file containing integers
  # and prints it
  
  # reads a text file of integers
  # and stores them in a list which is returned
  def read_integers_into_list(filename):
      file = open(filename, "r")
      new_list = []
      for line in file:
          number = int(line)
          new_list.append(number)
      file.close()
      return new_list
  
  number_list = read_integers_into_list("temperatures.txt")
  print("List:", number_list)

Functions That Return Objects

• The function above returns a pointer to a list it creates
• But where is the list?
• When a function runs it gets it's own chunk of memory
• All the variable's functions live inside this memory
• The variables disappear when the function ends
• This brings up two questions
  • Why doesn't the list disappear when the function ends?
  • What's the point of returning the list variable?
• The list remains after the function ends because it was not created in the functions memory space
• Objects are created in the memory space for the script
• This memory space does not get wiped when the function ends
• When a function returns a variable it returns the value of that variable
• The value of new_list is the memory address of the list
• And that memory address is outside the function's memory space

Functions That Work with Lists

• Functions can work on the values contained in a list
• When we use such a function we give it a list variable as an argument
• The function uses the memory address of the list to access the list
• Here is an algorithm for a function that returns the average of a list of numbers

  set an accumulator to zero
  loop through the list using the list address:
      add each number to the accumulator
  return the accumulator divided by the length of the list

• Here is the function

  def average_list(list):
      total = 0
      for index in range(len(list)):
          total += list[index]
      return total/len(list)

Functions That Change Lists

• Lists are mutable
• Here is a function that doubles all the elements in a list of numbers

  >>> def double_list(list):
  ...    for index in range(len(list)):
  ...       list[index] =  2 * list[index]
  ... 
  >>> numbers = [1,2,3,4,5]
  >>> double_list(numbers)
  >>> numbers
  [2, 4, 6, 8, 10]

• Notice that the function did not return a value
• It doesn't have to
• The code that called the function already has a variable pointing the the list

New Material

List Elements

• The elements of a list can be anything

  >>> list_1 = [1 , 2.5, True, "foo"]
  >>> for index in range(len(list_1)):
  ...    print(list_1[index], type(list_1[index]))
  ... 
  1 <class 'int'>
  2.5 <class 'float'>
  True <class 'bool'>
  foo <class 'str'>

• The elements of a list can even be another list

  >>> list_2 = [ 1, 2, 3, 4, [5, 6, 7,]]
  >>> for index in range(len(list_2)):
  ...    print(list_2[index], type(list_2[index]))
  ... 
  1 <class 'int'>
  2 <class 'int'>
  3 <class 'int'>
  4 <class 'int'>
  [5, 6, 7] <class 'list'>

Two-Dimensional Lists

• When all the elements of a list are lists, we have a two-dimensional list

  >>> two_d_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 
  >>> two_d_list
  [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

• Each element of two_d_list is also a list

  >>> for element in two_d_list:
  ...     print(element)
  ... 
  [1, 2, 3]
  [4, 5, 6]
  [7, 8, 9]

• We can use indexing to get each sublist

  >>> two_d_list[0]
  [1, 2, 3]
  >>> two_d_list[1]
  [4, 5, 6]
  >>> two_d_list[2]
  [7, 8, 9]

• How do we get each element within the sublist?
• With another [ ]

  >>> two_d_list[0][0]
  1
  >>> two_d_list[0][1]
  2
  >>> two_d_list[0][2]
  3
  

• We can think of this two-dimensional list as a square

  1 2 3
  4 5 6
  7 8 9

• Here is a script that prints each number individually

  for row in range(len(two_d_list)):
  ...     for column in range(len(two_d_list[row])):
  ...         print(two_d_list[row][column], end=" ")
  ...     print()
  ... 
  1 2 3 
  4 5 6 
  7 8 9 

• Notice that when I print a number I don't move down to the next line
• But when I finish a row I have to call print to start a new line

Solving Problems with Two-Dimensional Lists

• We can use a two-dimensional list to process a file with many fields on each line
• A file such as this with dates and temperatures

  2017-06-01 67
  2017-06-02 71
  2017-06-03 69
  ...

• Here is the algorithm to create the two-dimensional list

  create an empty list
      for each line in the file:
          turn the line into a list using split
          convert the temperature into an integer
          add this new list to the two-dimensional list

• And here is the code to implement it

  entries = []
  for line in file:
      entry = line.split()
      entry[1] = int(entry[1])
      entries.append(entry)

• The algorithm to find the date of highest temperature is

  set a variable for the index of the entry with the highest temperature to 0
  set a variable for the highest temperature to a low value
  for each index in the two-dimensional list:
      get the temperature for that date
      if the temperature is greater than the highest temperature:
          set the highest temperature to the current temperature
          set the highest index to the current index
  return the date of the entry with the highest index

• And here is the code that implements the algorithm

  def higest_temp_date(entries):
      highest_index = 0
      max_temp      = -500
      for index in range(len(entries)):
          temp = entries[index][1]
          if temp > max_temp:
              max_temp = temp
              highest_index = index
      return entries[highest_index][0]

Tuples

• A tuple is a sequence of values that cannot be changed
• You create a tuple literal by enclosing comma separated values inside parentheses

  >>> tuple_1 = (1, 2, 3, 4, 5)
  >>> tuple_1
  (1, 2, 3, 4, 5)

• Just as with lists tuples can contain elements of any type

  >>> tuple_2 = (1, 2.5, False, "Sam")
  >>> tuple_2
  (1, 2.5, False, 'Sam')

• You can access the elements of a tuple with an index

  >>> tuple_1[0]
  1

• You can use a for loop to print all the elements

  >>> for number in tuple_1:
  ...     print(number)
  ... 
  1
  2
  3
  4
  5

• You can use the concatenation operator

  >>> tuple_3 = tuple_1 + tuple_2
  >>> tuple_3
  (1, 2, 3, 4, 5, 1, 2.5, False, 'Sam')

• the repetition operator

  >>> tuple_4 = tuple_1 * 3
  >>> tuple_4
  (1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5)

• and the in operator

  >>> "Sam" in tuple_2
  True

• The len function works with tuples

  >>> tuple_1
  (1, 2, 3, 4, 5)
  >>> len(tuple_1)
  5

• as does min

  >>> min(tuple_1)
  1

• max

  >>> max(tuple_1)
  5

• and the index method

  >>> tuple_1.index(3)
  2

• But you cannot use the following methods
  • append
  • pop
  • insert
  • sort
  • reverse
  ...
• because they change a sequence and tuples cannot be changed
• Slices also work with tuples

  >>> tuple_1
  (1, 2, 3, 4, 5)
  >>> tuple_1[1:3]
  (2, 3)
  >>> tuple_1[:3]
  (1, 2, 3)
  >>> tuple_1[1:]
  (2, 3, 4, 5)
  >>> tuple_1[:]
  (1, 2, 3, 4, 5)

• One of the idiosyncrasies of tuples is the way a tuple literal with one entry is created
• If you try the obvious

  >>> tuple_5 = (1)

• something strange happens

  >>> tuple_5
  1

• which is confirmed when you use the type function

  type(tuple_5)
  <class 'int'>

• You must always use as comma, , when creating a tuple
• So here the correct way to do this

  >>> tuple_5 = (1,)
  >>> tuple_5
  (1,)
  >>> type(tuple_5)
  <class 'tuple'>
  >>> tuple_5[0]
  1

• Python lets you create an empty tuple

  >>> empty_tuple = ()
  >>> empty_tuple
  ()

• It is a perfectly good tuple

  >>> type(empty_tuple)
  <class 'tuple'>

The tuple Conversion Function

• Every one of the basic data types in Python has a conversion function
  • int
  • float
  • str
  • bool
  • list
• The conversion function for tuples is tuple
• It will work on strings

  >>> name = 'Glenn'
  >>> tuple(name)
  ('G', 'l', 'e', 'n', 'n')

• and lists

  >>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
  >>>  tuple(digits)
  (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)

• But not on integers

  >>> tuple(1)
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: 'int' object is not iterable

• or booleans

  >>> tuple(True)
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: 'bool' object is not iterable

• An iterable object is one that can be used in a for loop

Why Use Tuples?

• Lists and tuples are similar
• But tuples have many limitations
• So why should we use tuples?
• There are two reasons
  • Performance
  • Security
• Tuples are simpler that lists
• So a list takes more memory than a tuple of the same size
• The smaller size makes them somewhat faster to work with
• The savings can be significant when working with big data sets
• Consider the data collected by the European Gaia satellite
• It measured the position and movement of 1.7 billion stars
• You would not want to use lists for that data set
• Tuples cannot be changed
• So any data you put in a tuple cannot be modified or corrupted
• This can be important in team projects where many people work with the same data

Tic-Tac-Toe

• Two-dimensional lists can be used for many things
• For example, we can use it to represent a game of tic-tak-toe
• It is a game for two players on a 3 by 3 square
• One player marks with an "X"
• The other with an "O"
• The goal is to get three in a row
• Either across, down or diagonally
• Like this

• We can represent the board with a two-dimensional array

  board = [["O", "X", "X"], ["X", "0", "O"], ["X", "0", "O"]]

• as we can see by printing the elements

  >>> for row in range(len(game)):
  ...     for column in range(len(game[row])):
  ...         print(game[row][column], end=" ")
  ...     print()
  ... 
  O X X 
  X 0 O 
  X 0 O 

• Let's write a Python script for the game
• A player will make moves against the computer
• Once again we will use incremental development

Tic-Tac-Toe - Step 1

• We need to define the board and print it
• The board is a 3 by 3 square two-dimensional list
• In the beginning each square is empty

  board = [[' ', ' ', ' '],[' ', ' ', ' '],[' ', ' ', ' ']]

• To print the board you might think a simple for loop would be good enough
• But you would be wrong

  >>> board = [[' ', ' ', ' '],[' ', ' ', ' '],[' ', ' ', ' ']]
  >>> for row in board:
  ...     print(row)
  ... 
  [' ', ' ', ' ']
  [' ', ' ', ' ']
  [' ', ' ', ' ']

• I want to see the lines between each entry and each row
• So an empty board should look like this

   | | 
  -----
   | | 
  -----
   | | 

• Before I can print the board, I need to print a row
• The row will have the contents of each square
• With a vertical bar | between them
• Here is the function print_row

  def print_row(row):
      print(row[0] + '|' + row[1] + '|' + row[2])

• When I print the first row I get

   | | 

Tic-Tac-Toe - Step 2

• Now we need to print the entire board
• We need to call print_row for each row
• And print a line of dashes after each row
• Here is print_board

  def print_board():
      print_row(board[0])
      print('-----')
      print_row(board[1])
      print('-----')
      print_row(board[2])

• When I run this I get

   | | 
  -----
   | | 
  -----
   | | 

Tic-Tac-Toe - Step 3

• Now we need a function that asks the user for a move
• It should prompt the user for two integers
• One for row and one for column
• The rows and columns will have numbers from 1 to 3
• But the function has to check that the entry is valid
• It has to check that
  • There are two values
  • Both values are integers
  • Both values are between 1 and 3
• To validate the data we need a while loop
• The loop will keep running until the user enters a good value
• Checking that there are two values means look at the length of the list returned by split
• Checking that the value are integers mean converted each value to integer inside a try/except statement
• To check that the values are between 1 and 3 we create the following constant list

  GOOD_VALUES = [1,2,3]

• Then we check that each number is contained in GOOD_VALUES
• The loop will keep running until the user entry is correct
• Then it will return the values
• Here is the function user_move

  def user_move():
      while True:
          reply = input('Next move (row col): ')
          fields = reply.split()
          if len(fields) < 2:
              print('Need a row number and a column number')
              continue
          row, col = fields
          try:
              row = int(row)
              col = int(col)
          except:
              print(row, 'or', col, 'is not a number')
              continue
          if row not in GOOD_VALUES or col not in GOOD_VALUES:
              print('Row and column values must be 1, 2, or 3')
              continue
          return row, col

Tic-Tac-Toe - Step 4

• There is one thing that user_move does not test for
• It needs to be sure that the square is empty
• To do this we need another global variable

  prev_moves = []

• Before returning the move user_move needs to check prev_moves
• If the move has been taken is should print an error mesaage and keep looping
• Otherwise it should add the move to prev_moves before returning the move
• Here is the new version of user_move

  def user_move():
      while True:
          reply = input('Next move (row col): ')
          fields = reply.split()
          if len(fields) < 2:
              print('Need a row number and a column number')
              continue
          row, col = fields
          try:
              row = int(row)
              col = int(col)
          except:
              print(row, 'or', col, 'is not a number')
              continue
          if row not in GOOD_VALUES or col not in GOOD_VALUES:
              print('Row and column values must be 1, 2, or 3')
              continue
          if (row, col) in prev_moves:
              print(row, col, 'is already taken')
              continue
          else:
              prev_moves.append((row, col))
              return row, col

Tic-Tac-Toe - Step 5

• Now we need to create the function mark_square to actually make a move
• It is a very simple function

  def mark_square(row, col, mark):
      board[row - 1][col - 1] = mark

• To make things a little clearer, I define two constants

  USER_MARK    = 'X'
  MACHINE_MARK = 'O'

• We need a while loop to run the game
• Eventually this loop will stop when the game is over
• For now I just need a loop that will call user_move
• Then call mark_square

  print_board()
  print()
  while True:
      row, col = user_move()
      mark_square(row, col, USER_MARK)
      print_board()
      print()

Tic-Tac-Toe - Step 6

• Now we need to write machine_move
• We can use randint to create the integers
• And we can specify that they must be between 1 and 3
• The only data validation we need is to check that the space is free
• The moves have to be created inside a while loop

  def machine_move():
      while True:
          row = random.randint(1,3)
          col = random.randint(1,3)
          if (row, col) not in prev_moves:
              prev_moves.append((row, col))
              return row, col
          else:
              continue

• Now we can call machine_move inside the game loop

  print_board()
  print()
  while True:
      row, col = user_move()
      mark_square(row, col, USER_MARK)
      print_board()
      print()
      row, col = machine_move()
      mark_square(row, col, MACHINE_MARK)
      print_board()
      print()

Tic-Tac-Toe - Step 7

• To jump out of the game loop and end play we need to know when someone has won
• We will create the function game_over to do this
• The code will be complicated
• We can make the problem simpler if we only check if a specific player has won
• Each time a player makes a move we call game_over for that mark
• There are three ways a player can win
  • The player's mark fills a row
  • The player's mark fills a column
  • The player's mark fills a diagonal
• But each possibility can be satisfied in more than one way
• We have to check each row for the correct mark
• There are three rows, so there are are three possible ways to win
• We have the same situation for each column
• But there are only two diagonals
• We are going to need a for loop to check the rows and columns
• And two separate if statements for the diagonals
• Each loop will have an inner loop which checks each square in the row or column
• To make things a little cleaner I will define the helper function cell_match
• It returns true if the mark is found in a specific square

  def cell_match(row, col, mark):
      return board[row][col] == mark

• Each for loop checks three squares
• If one square does not match it returns False
• If it gets to the end of the inner loop it prints a win message
• And returns true
• Here is game_over

  def game_over(mark):
      # check rows
      for row in [0,1,2]:
          for col in [0,1,2]:
              if not cell_match(row, col, mark):
                  break
              if cell_match(row, 0, mark) and cell_match(row, 1, mark) and cell_match(row, 2, mark):
                  print(mark , 'wins!')
                  return True
      # check columns
      for col in [0,1,2]:
          for row in [0,1,2]:
              cell_mark = board[row][col]
              if not cell_match(row, col, mark):
                  break
              if cell_match(0, col, mark) and cell_match(1, col, mark) and cell_match(2, col, mark):
                  print(mark , 'wins!')
                  return True
      # check diagonals
      if cell_match(0, 0, mark) and cell_match(1, 1, mark) and cell_match(2, 2, mark):
          print(mark , 'wins!')
          return True
      if cell_match(0, 2, mark) and cell_match(1, 1, mark) and cell_match(2, 0, mark):
          print(mark , 'wins!')
          return True
      return False

• Now I need to modify the game loop to call this function
• The call needs to happen after each player makes a move

  print_board()
  print()
  while True:
      row, col = user_move()
      mark_square(row, col, USER_MARK)
      print_board()
      if game_over(USER_MARK):
          break
      print()
      row, col = machine_move()
      mark_square(row, col, MACHINE_MARK)
      print_board()
      if game_over(MACHINE_MARK):
          break
      print()

• You will find the complete script here

Attendance