IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 16

Today's Topics

Reading Assignment

You should read Chapter 6, Files and Exceptions, from our textbook, Starting Out with Python, before next week's class.

Homework 7

I have posted homework 7 here.

It is due the Sunday at 11:59 PM.

Tips and Examples

Scripts and Functions Need Comments

You must have a comment at the top of every script
The comment should describe what the script does
This comment say something more than "This is the script for homework 5"
You must use the hash character # to begin a comment
Every function must have a comment that comes before the function header
There should not be a blank line between the comment and the function header
These and other rules are listed here
You will lose points if you do not follow these rules

Don't Comment the Obvious

Every script and every function should have a comment that describe what it does
Comments should also be used when the code does something usual
You don't need to write comment for every line of code

The comments below are unneeded

for cels in range(min, max): #for loop range from 1 to 20 
    fah = 0
    fah = cels * 9/5 + 32 #the formula to convert cels to fah
    print(cels, "\t",round(fah))

Review

Default Values for Parameters

Some functions have many parameters
Normally, you have to provide an argument for each parameter when you call the function
Sometimes a particular parameter almost always has the same value
When this happens, its a good idea to give this parameter a default value value
A default is a value that is used unless the user supplies one

This is done in the function header

def  FUNCTION_NAME([PARAMETER, ...], PARAMETER_NAME=DEFAULT_VALUE [, PARAMETER_NAME=DEFAULT_VALUE]):
    STATEMENT
    ...

Here is an example

def convert(feet, inches, units='inches'):

Default values must come at the end of the parameter list

Global Variables

Variables created outside of the functions in a script are called global variables
Functions can use global variable in their code

Here is an example

def cheer():
    print('Go ' +  team) + '!')

team = 'Red Sox'
cheer()

In this example, team is a global variable
Global variables can make the code hard to read and cause other problems
Don't use global variables unless you have a very good reason

Global Constants

The value of a a global variable cannot be changed inside a function
Unless you use a special feature of Python
This makes them useful for storing values that do not change
Variables that do not change are called constants
Here are some examples of constants
- The number of days in the week
- The number of months in a year
- The first date of the year
- The ration of the circumference of a circle to its diameter (π)
Python does not have true constants
But you can use global variables to hold a constant value
It is customary to write the names of constants in ALL_CAPITALS
Global variables used this way should be declared once at the top of the program
And never changed

Functions that Return Values

Functions that return values can be used in assignment statements
```
>>> result = round(8.765) 
>>> result
9
```
A function returns a value using a return statement
```
return  EXPRESSION
```
return is a Python keyword
A return statement does two things
- It ends the execution of the function
- It sends a value back to the function call
A return statement always causes the function to quit
So any code after the return statement will never be executed

Returning Multiple Values

A Python return statement can return more than one value
To do this use multiple expressions separated by commas
```
return EXPRESION, EXPRESSION [, EXPRESSION, ...]
```

Using this feature I can write a function to get both the first and last name

>>> def get_full_name():
...     first_name = input("Please enter your first name: ")
...     last_name = input("Please enter your last name: ")
...     return first_name, last_name
...

When this function is called it will ask for two values

And return each to a separate variable

>>> fname, lname = get_full_name()
Please enter your first name: Glenn
Please enter your last name: Hoffman

Assigning more that one variable a value with a single assignment statement is called multiple assignment
You must have one variable on the left side for each value returned by the funtion

Standard Library Functions

Some functions are part of the Python interpreter
- print
- int
- float
- input
- range
All of these are built-in functions
But Python also has other useful functions collected into modules
And many of these modules aare copied to each machine that installs Python
These modules are called the standard library
You can use any of the functions and variables stored in a module
But first you must import them using the import keyword
```
import random
```
When using a function or variable in a module, you must use dot notation
You write the name of the module followed by a dot, .

Then by the name of the function or variable

>>> math.cos(math.pi)
-1.0
>>> math.ceil(4.3)

Creating Random Numbers

When writing programs, we often want to use random numbers
We need them in writing
- Games
- Simulations
But nothing a computer does is random
There is a great need for random numbers in computing
So mathematicians have developed algorithms that produce pseudorandom numbers
Pseudorandom numbers are numbers that occurs in a sequence that eventually repeats
But the distance between repetitions is so long that they are "random enough"
The functions that create these pseudorandom sequences are called pseudorandom number generators
Or simply random number generators

The random Module

One of the modules in the standard library is random
It contains several several functions that can create pseudorandom numbers
The function randint takes two integers as arguments
They specify the maximum and minimum numbers the function can create
We can call this function several times

And each time it will return a different number

$ cat random_1.py 
# demonstrates the use of the randint function of the random module

import random

for i in range(10):
    print(random.randint(1,100))

$ python3 random_1.py 
89
98
93
73
32
40
63
100
76
80

$ python3 random_1.py 
66
49
1
29
63
17
91
3
70
5

If we called randint long enough it would eventually repeat the sequence of values
But we would have to call it a very large number of times

Other random Functions

The random module has other functions to generate pseudorandom numbers
Each of them has advantages in different situations
The randrange function also returns an integer
But it can take 1, 2 or 3 arguments
The arguments work just like the range function
If you want a decimal number, use random

It generates a random number between 0.0 and 1.0

$ cat random_5.py 
# demonstrates the use of the random function of the random module

import random

for i in range(5):
    print(random.random())

$ python3 random_5.py 
0.3366683809865726
0.6243291094221154
0.47182435685723234
0.3079697111617222
0.5048399470937616

uniform takes two arguements

The arguments specify the range of decimal values

$ cat random_6.py 
# demonstrates the use of the uniform function of the random module

import random

for i in range(5):
    print(random.uniform(1, 5))

$ python3 random_6.py 
3.987702460027857
2.776217942732739
2.890534381287354
1.5377836190792888
3.1461905324732022

Random Number Seeds

The algorithm that generates pseudorandom numbers require a starting value
This starting value is called seed
Using the same seed each time will give you the same sequence of numbers
To prevent this from happening the functions in random use a trick
A computer keeps track of the time by counting seconds
The functions in random use this number as the seed
But what if we wanted the sequence of numbers to be the same?

You can set your own starting value using the seed function

$ cat random_6.py 
# demonstrates the use of the seed function in the random module
# to generate the same series of numbers each time the program is run

import random

random.seed(67)
for i in range(5):
    print(random.randint(1, 100))

$ python3 random_6.py 
10
15
99
53
60

$ python3 random_6.py 
10
15
99
53
60

New Material

Returning Values That Are Not Numbers

The value returned by a function can be anything
round returns either an integer or a float
input returns a string
Functions can return anything that Python can create
Functions can return also return boolean values

Boolean Functions and Data Validation

Boolean functions are useful when performing data validation
Say you need the user to enter a a couple of numbers within a certain range
You will need to write a while loop which needs a boolean expression

The cleanest way to do this is to write a function that tests for the correct value

def in_range(min, max, value):
    if value < min:
        return False
    elif value > max:
        return False
    else:
        return True

This function is actually longer than it needs to be
We want this function to return True if the value is greater or equal to the minimum
And less than or equal to the maximum

We can write this as

def in_range(min, max, value):
    return value >= min and value <= max

We can go one step further

Python allows us to rewrite

value >= min and value <= max

min <= value <= max

This last expression seems simpler to me though you may disagree

Now that we have the function, we can use it in a data validation loop

$ cat in_range_3.py
# demonstrates the use of a boolean data validation function

def in_range(min, max, value):
    return min <= value <= max

done = False
while not done:
    number = int(input('Number: '))
    if in_range(1, 5, number):
        print(number)
        done = True

$ python3 in_range_3.py
Number: 0
Number: 7
Number: 3
3

Storing Functions in Modules

When you run ls -l on a directory it will list the contents alphabetically

This can cause a problem with files that have numbers in them

$ ls -l
total 328
-rwxr-xr-x  1 glenn  staff  6577 Jun 28 14:11 ex10.sh
-rwxr-xr-x  1 glenn  staff  7780 Jun 28 14:11 ex11.sh
-rwxr-xr-x  1 glenn  staff  4053 Jun 28 14:11 ex12.sh
-rwxr-xr-x  1 glenn  staff  6208 Jun 28 14:11 ex13.sh
-rwxr-xr-x  1 glenn  staff  9415 Jun 28 14:11 ex16.sh
-rwxr-xr-x  1 glenn  staff   765 Jun 28 14:11 ex17.sh
-rwxr-xr-x  1 glenn  staff  6653 Jun 28 14:11 ex18.sh
-rwxr-xr-x  1 glenn  staff  8997 Jun 28 14:11 ex19.sh
-rwxr-xr-x  1 glenn  staff   212 Jun 28 14:11 ex2.sh
-rwxr-xr-x  1 glenn  staff  2075 Jun 28 14:11 ex20.sh
...

I always use two digit numbers when naming directories

This way the files will sort properly

$ ls -l
total 328
-rwxr-xr-x  1 glenn  staff   212 Jun 28 14:08 ex02.sh
-rwxr-xr-x  1 glenn  staff   466 Jun 28 14:08 ex03.sh
-rwxr-xr-x  1 glenn  staff   595 Jun 28 14:08 ex04.sh
-rwxr-xr-x  1 glenn  staff  5474 Jun 28 14:08 ex05.sh
-rwxr-xr-x  1 glenn  staff  7428 Jun 28 14:08 ex06.sh
-rwxr-xr-x  1 glenn  staff  4182 Jun 28 14:08 ex07.sh
-rwxr-xr-x  1 glenn  staff  8919 Jun 28 14:08 ex08.sh
-rwxr-xr-x  1 glenn  staff  2407 Jun 28 14:08 ex09.sh
-rwxr-xr-x  1 glenn  staff  6577 Jun 28 14:08 ex10.sh
...

But this convention means I sometime have to convert a string like '5' into '05'
I have a script to do this called pad_number in my module utilities.py
```
>>> import utilities
>>> utilities.pad_number('5')
'05'
```

It's not a very complicated function

# adds a '0' to a single digit and makes it a string            
def pad_number(number):
    number = int(number)
    if number < 10:
        return '0' + str(number)

but it saves me time and aggravation
Of course sometimes I need to go the other way
And remove a leading zero from a number string
For this I have strip_zero
```
>>> utilities.strip_zero('05')
'5'
```

Incremental Development

I use an approach to writing code called incremental development
The idea is to write a little bit of code and test it
If there is an error you fix it
You keep doing this until the script is complete
When I first taught a programming course at UMB it was in Java
This was a painful experience for many reasons
That is why I developed this course and IT 117
But I noticed that students were having a hard time with the homework assignments
One problem was that they tried to write all the code before testing it
When they tried to run the code, they got many errors
Sometimes they became so frustrated that they created more errors
You can avoid this vicious cycle by using incremental development
It has a number of advantages
You only add a few lines of code with each iteration
So it's easy to find and fix any bugs that appear
Another advantage is more subtle
If you write a lot of code all at once it's likely that you will create many errors
Because there many new lines of code, it can be very hard to find the errors
This can be very discouraging and can lead to a loss of confidence
With incremental development you only write a bit of code before testing
This makes is much easier to find bugs
This leads to improved self-confidence
If you don't have confidence in your ability to do something
You are more likely to fail

An Example of Incremental Development

Let's demonstrate incremental development by writing a program that plays a game of rock paper scissors
Here is how the game is played
- The user chooses one of the three items
- The computer chooses an item
- The winner is chosen as follows
  - Paper covers rock so it wins
  - Rock smashes scissors so it wins
  - Scissors cuts paper so it wins
  - When the same item is chosen by both, the result is a tie
The game continues until there is a winner
For out first attempt, let's write a function that asks the user to chose an item
It keeps looping until it gets a valid choice

A line of test code at the bottom calls the function and prints the results

# first attempt at a game of rock paper scissors

# asks the user for their move, checks that it is valid
# and returns valid move
def get_user_move():
    move = input('Please chose rock (r), paper (p) or scissors (s): ')
    while move != 'r' and move != 'p' and move != 's':
        print(move, 'is not a valid choice')
        move = input('Please chose rock (r), paper (p) or scissors (s): ')
    return move

print('You entered', get_user_move())

When I run this code I get

Please chose rock (r), paper (p) or scissors (s): q
q is not a valid choice
Please chose rock (r), paper (p) or scissors (s): r
You entered r

I need to run this several time to check all legal values and several illegal ones
Once I am convinced that the code works I can add more code
Now I need to create a function that chooses a move for the computer
I will need to use randint to create some randomness
There are three possible moves for each player
So I will get the remainder when the random number is divided by three
This will give me only three possible values 0, 1 or 2
Each value will correspond to one of the three items

Here is the new function

# generates a move for the computer
def get_computer_move():
    move = random.randint(1,10000)
    if move % 3 == 1:
        return 'r'
    elif move % 3 == 2:
        return 'p'
    else:
        return 's'

To test this I need to call this function many times in a loop

I want to make sure that the choices look random

for i in range(30):
    print(get_computer_move())

Running this I get

$ python3 rock_paper_scissors_2.py 
s
r
p
p
s
s
s
s
p
...

I decided to have this function create one character for each item choice
A single character is what the user enters
It's simpler if both the user and computer use the same values when chosing
But when we print the game, we want words, not single letters

We need a function to change letters into the corresponding words

# turns a move represented by a letter into the appropriate word
def move_letter_to_word(letter):
    if letter == 'r':
        return 'rock'
    elif letter == 'p':
        return 'paper'
    elif letter == 's':
        return 'scissors'
    else:
        return ''

Notice that if I don't get one of the three letters I return a space
A function should return some harmless value, when it gets input it cannot handle

Now we need to change the test code

for i in range(30):
    print(letter_to_word(get_computer_move()))

and run the test

$ python3 rock_paper_scissors_3.py 
paper
paper
scissors
rock
...

After each player makes a choice, we need a function to decide who wins
This function will be given two parameters
TThe user's move and the computer's move
There are three possible results
- The user wins
- The computer wins
- No one wins
I need to decide how to represent each possible outcome
The simplest technique is just to return a string naming the winner
If there is no winner, the function will return "Tie"

I need to consider every possibility

# returns the name of the winner
def winner(user_move, computer_move):
    if user_move == computer_move:
        return "Tie"
    elif user_move == 'p' and computer_move == 'r':
        return "User"
    elif user_move == 'r' and computer_move == 'p':
        return "Computer"
    elif user_move == 'r' and computer_move == 's':
        return "User"
    elif user_move == 's' and computer_move == 'r':
        return "Computer"
    elif user_move == 's' and computer_move == 'p':
        return "User"
    elif user_move == 'p' and computer_move == 's':
        return "Computer"

We need code to test every possibility

print('r', 'r', winner('r', 'r'))
print('p', 'p', winner('p', 'p'))
print('s', 's', winner('s', 's'))

print('p', 'r', winner('p', 'r'))
print('r', 'p', winner('r', 'p'))

print('r', 's', winner('r', 's'))
print('s', 'r', winner('s', 'r'))

print('s', 'p', winner('s', 'p'))
print('p', 's', winner('p', 's'))

When we run this we get

$ python3 rock_paper_scissors_4.py 
r r Tie
p p Tie
s s Tie
p r User
r p Computer
r s User
s r Computer
s p User
p s Computer

Now we can complete the code for the game
We need to keep playing the game until there is a winner
We don't know how many rounds of the game will be run
So we will use a while loop
If the function winner returns "Tie" we need to play another round
So the loop will run as long as the result of the last game is "Tie"
Inside the loop we first ask the user for their move and print the results
Then the computer moves and we print the result

Now we call winner and take appropriate action

result = "Tie"
while result == "Tie":
    user_move = get_user_move()
    computer_move = get_computer_move()
    print('User chooses', letter_to_word(user_move))
    print('Computer chooses', letter_to_word(computer_move))
    result = winner(user_move, computer_move)
    if result != "Tie":
        print(result, 'wins')
    else:
        print("Tie")

Now we can play the game

Please chose rock (r), paper (p) or scissors (s): p
User chooses paper
Computer chooses paper
Tie
Please chose rock (r), paper (p) or scissors (s): r
User chooses rock
Computer chooses paper
Computer wins

You can see the complete code here

Refactoring

When writing programs the most important thing is to get it to work
After we have it working we can go back and improve it
Here we do not change what the program does but we improve it in some important way
This is called refactoring
Looking at the code, I see that we needed two identical calls to input
```
input('Please chose rock (r), paper (p) or scissors: ')
```
The string used in the prompt is long and complicated
And we might want to change it later
It would be better to write a function to ask for input

That way we can change the prompt in only one place

# asks the user for a move
def get_move():
    choice = input('Please chose rock (r), paper (p) or scissors (s): ')
    return choice

Using this function in get_move makes the code cleaner

def get_user_move():
    move = get_move()
    while move != 'r' and move != 'p' and move != 's':
        print(move, 'is not a valid choice')
        move = get_move()
    return move

The boolean expression used in the while loop is long and complicated

It would be easier to read if we put this logic in a boolean function

# returns true if the input from the user specifying a move is valid
def is_valid_move(move):
    return move == 'r' or move == 'p' or move == 's'

The code in get_move is now easy to understand

def get_user_move():
    move = get_move()
    while not is_valid_move(move):
        print(move, 'is not a valid choice')
        move = get_move()
    return move

You will find the final version of the code here