IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 16

Microphone

Questions

Are there any questions before I begin?

Homework 7

I have posted homework 7 here.

It is due this Sunday at 11:59 PM.

Graded Quiz Next Week

There will be a graded quiz next week.

It will cover the material we will discuss today, and the material from Class 13.

Midterm

I have started scoring the Midterm.

I hope to be finished by Monday.

Tips and Examples

Do Not Change the Test Code in Homework Scripts

From now on, all homework assignments will ask you write functions
Your homework scripts will not work unless there is code to call the functions
For each of these new assignments I will provide test code
This code must be added to the bottom of your scripts
The test code will call the functions
The test code is written to produce consistant output for all functions ...
so I know what to expect when running your script
NEVER change the test code given for each homework assignment
If you do, your script will not produce the output I expect
This will make it harder for me to score your script
If you change the test code you will lose 10 points on the assignment

Scripts and Functions Need Comments

You must have a comment at the top of every script
The comment should describe what the script does
It should be descriptive
I will not accept a comment like this
```
# This is the script for homework 5
```
Because it does not say what the script does
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 needs a comment
The comment describe what it does
Other comments a 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))

`return` vs. `print` in Functions

Functions are a very important part of programming
But there are a number of important concepts involved in functions
So I decided to first talk about functions that did not return a value ...
before talking about the return statement
The textbook calls functions that do not return a value "void functions"

When discussing these void functions I used examples like cheer

>>> def cheer(team):
...     print("Go", team)
...
>>>  cheer("Red Sox")
Go Red Sox

This function prints a result that can be seen on the command line ...

but it does not return a value

>>> result = cheer("Red Sox")
Go Red Sox
>>> result
>>>

In a previous class I discussed the return statement ...
which functions use to return a value to the calling statement

To show how this works, I created a new version of cheer

>>> def new_cheer(team):
...     return "Go " + team
...

This new version returns a string

>>> result = new_cheer("Red Sox")
>>> result
'Go Red Sox'

print does not return a value
It simply causes something to be printed
return does not print anything ...
but it returns a value ...
which can then be printed

Review

Default Values for Parameters

Some functions have many parameters
All of which need values
But sometimes the value given to one parameter is always the same
When this happens, you can give this parameter a default value value
A default is a value that is used when the user does not supply one

You can give a parameter a default value in the function header

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

Here is an example
```
def convert(ft, in, 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 except for constats

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 ratio 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
This marks them as constants whose value should never be changed
Global variables used this way should be declared at the top of the program
Like this
```
DAYS_IN_WEEK = 7
```
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 running 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 function

Standard Library Functions

Some functions are part of the Python interpreter
- print
- int
- float
- input
- range
The are called built-in functions
But Python also has other useful functions collected into modules
Many modules are distributed along with Python
They are copied to your machine when you install 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, . , ...
followed by the name of the function or variable
```
>>> math.cos(math.pi)
-1.0
```

Creating Random Numbers

We sometimes need random numbers when writing programs
We need them in
- Games
- Simulations
But nothing a computer does is random
Mathematicians have developed algorithms that produce pseudorandom numbers
Pseudorandom numbers are numbers that occurs in a sequence ...
that eventually repeats
So they are not really random
But the distance between repetitions is so long ...
that they are "random enough"
Functions that create these 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 same 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 have different advantages ...
which are useful in particular 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 arguments
The arguments specify the range of decimal values

The minimum and maximum possible 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 algorithms that generates pseudorandom numbers require a starting value
This starting value is called a 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

Attendance

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 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 couple of numbers within a certain range
You will need to write a while loop ...
which needs a boolean expression in its header

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
The function must 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

We can now use this function 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

Running ls -l on a directory lists the contents in alphabetical order
This can cause a problem with files or directories ...

whose name begins with a number

$ 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 in these situations
This way everthing will sort properly ...

when I list the directory contents

$ 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 function 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'
```
I have a number of functions like this ...
that speed up a number of routine task
This makes me more efficient ...
and eliminates a lot of boring, repetitive work

Incremental Development

I use an approach to writing code called incremental development
The idea is to write a little bit of code ...
and then test it
If there is an error, you fix it ...
and then add some more code
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
I noticed that students had a hard time with 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 step
So its 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
This can be very discouraging ...
and 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 ...
which 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 me show you how incremental development works
I'll use it to write a program that plays a game of rock paper scissors
Here is how the game is played
- The user chooses either rock, paper or scissors
- The computer chooses from the same list
- 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 choices are the same, the result is a tie
The game continues until there is a winner

Rock, Paper, Scissors - Step 1

I need a simple task to start this work
I'll write a function that asks the user to make a choice
Each choice is represented by a single letter
The function will keep looping until it gets a valid choice
To test the script, I need a line of code at the bottom
It calls the function and prints the results

Here is the code

# 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 times
To check all legal values and several illegal ones
Once I am convinced that the code works ...
I can add more code

Rock, Paper, Scissors - Step 2

Now I need to create a function for the computer's move
It will use randint to create some randomness
There are three possible moves for each player
The function will get the remainder ...
when the random number is divided by three
This will give only three possible values 0, 1 or 2
Each value will correspond to one of the three choices

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

Rock, Paper, Scissors - Step 3

Inside the program, a choice is as single letter
But when we print a move we need words

We need a function to change letters into the corresponding words

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

Notice that if the function does not get a valid letter ...
it returns the empty string
When a function gets a value it cannot handle ...
it should return a harmless value
We need to change the test code

To test this latest function

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

Now I need to run the text

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

Rock, Paper, Scissors - Step 4

Now we need a function to decide who wins
This function will be given two parameters
The 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"

The function needs 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"

The test code needs to try each 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

Rock, Paper, Scissors - Step 5

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
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 makes its move ...
and we print the result
Then the code calls winner ...

and takes 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")

The loop will keep running until there is a winner

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
We don't change what the program does ...
but we make certain parts of it better
The best way to do this is to make a change to one small part ...
test it to see that the code still works ...
then pick another small part to improve
This technique 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

Responsibility of IT Professionals