IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 25

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

The final exam will be given on Thursday, December 19th from 11:30 - 2:30.

The exam will be given in this room.

It will consist of questions like those on the quizzes along with questions asking you to write short segments of Python code.

60% of the points on this exam will consist of questions from the Ungraded Class Quizzes.

Although classes do not end until Friday, December 13th, I do not have materials for a 29th class, and do not have the time to prepare them.

Instead, on day when the last class would normally be held, Thursday, December 12th I will have office hours from Noon to 6 PM.

You may come to my office at any time during this period, for help of any sort, without making an appointment.

Class 28, on Tuesday, December 10th, will be a review session.

You will only be responsible for the material in Class Notes 28 and the review for the Mid-term, which you will find here.

Although the time alloted for the exam is 3 hours, I would expect that most of you would not need that much time.

The final is a closed book exam.

To prevent cheating, certain rules will be enforced during the exam.

Course Evaluation

I will distribute the course evaluation in the last class.

The evaluations are very important.

They help me to realize what I have done right and what I have done wrong.

Please take the time to fill them out with your honest opinion of the course and my teaching.

Quiz 9

Let's review the answers to Quiz 9.

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 ...
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

Today's Topics

Review

New Material

Final Exam

Course Evaluation

Quiz 9

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

Attendance

The `tuple` Conversion Function