IT 117: Intermediate Scripting

IT 117: Intermediate Scripting
Class 3

Python Review

Microphone

Trouble? Questions?

Has anyone had any trouble doing something for this class or have any questions?

Homework 2

I have posted homework 2 here.

It is due this coming Sunday at 11:59 PM.

Today's Class

Today I will continue the review of the material covered in IT 116.

General Advice

Do You Have Enough Time to Do the Work for This Course?

Many of you work, either part or full time
This cuts down on the time you have to study
Technical courses are filled with details where accuracy is very important
They also introduce concepts which may take some time to fully understand
Such courses require a significant amount of study time ...
to learn the material and do well in class
This studying should not be done on one day ...
but spread out over the days of the week
You should not be taking this course ...
if you can't study several hours a week for it
Too many students rush to finish a degree ...
without doing the work to really learn the material
These people are setting themselves up for professional failure
If you try to do too much ...
If you try to do too much ...
you may end up accomplishing too little
Today is the last day of Add/Drop ...
when dropping the class won't mean losing money
Be honest with yourself
Looking at all your other commitments ...
do you have enough time for the work I will demand of you?

Course Work

Class Quizzes

From now on, each class will have a Class Quiz
The Class Quiz is ungraded
It is designed to help you remember the material covered in class
Here is how it works
Go to the listing of Class Quizzes you will find here
Click on the link for the day's quiz
Get a blank piece of paper
Write the answers to the questions on the paper
Go to the listing of Class Quiz Answers you will find here
Check your answers
Do not give me the paper with your answers
Class quizzes are not graded
They are designed to help you learn the material covered in class

First Graded Quiz

The first Graded Quiz will be given on Tuesday next week
I will pass out the exam papers after my lecture
Questions on the Graded Quiz come from the Class Quizes
Usually the quizzes from the previous week
Unless I tell you otherwise ...
you should expect a Graded Quiz each week on Tuesday
You will be able to see your scores on Gradescope

Tips and Examples

Class Exercises

There is a Class Exercise for every class ...
except the review sessions for the Midterm and final exams
Each Class Exercise must be in a separate directory inside the ex directory
The ex directory must be inside your it117 directory
If you do not finish the script in class you can finish it later
All Class Exercises must be finished before the following Sunday at 11:59 PM
I check your Class Exercises 4 times a week
The last check is on the weekend after they are due
If there is a problem with your script, or it is missing ...
I will send an email to your UMB email address
If the exercise is not complete or it has an error ...
you will lose points
I have have written test scripts for each of the Class Exercises
I use these scripts to test your code
You can run these scripts to test what you have written
But you have to connect to pe15.cs.umb.edu to do this
At the bottom of every Class Exercise is the command you run to test your script
When you run this command you will be asked for your username
After you enter this and hit return, the tests will run

Here is how it looks for ex2.py

$ ~ghoffman/it117_test/ex02.sh
Unix username: ghoffman
ghoffman 		 Glenn Hoffman
++++++++++++++++++++++++++++++++++
Is file executable?
----------------------------------
ex2.py is executable
----------------------------------
++++++++++++++++++++++++++++++++++
Looking for hashbang
----------------------------------
#! /usr/bin/python3
----------------------------------
++++++++++++++++++++++++++++++++++
Error 
----------------------------------
----------------------------------
Next? 
++++++++++++++++++++++++++++++++++
Looking for:
2017-06-01 67
2017-06-02 71
2017-06-03 69
2017-06-04 88
2017-06-05 74
----------------------------------
2017-06-01 67
2017-06-02 71
2017-06-03 69
2017-06-04 88
2017-06-05 74
----------------------------------
ghoffman 		 Glenn Hoffman
-20 5
Class Exercise 2

The Error check section looks for syntax errors in your code
If you see nothing between the two dashed lines ...
no syntax errors were detected
If the output of your script is missing something ...
or produces incorrect output ...
you will hear a beep and see an error message

Getting Help

This course makes you do things that you may not have done before
Whenever you do something new there is always a good chance you will make a mistake
When this happens, the first thing you should do is reread the instructions
Mistakes often happen when we read too fast
If you cannot fix the problem in a reasonable amount of time, ask for help
There are a number of ways you can do this
- Post a question in the class discussion area
- Ask other students in the class
- Come to Zoom Office Hours
DO NOT EMAIL ME with your question
I have close to 100 student each semester
With that workload I must be very careful how I spend my time
I would rather respond to your question on Piazza than in an email
Only one student will see an email response
But an answer on Piazza can be seen by the entire class
Only send me an email when you have an issue that affects you and you alone
Like being out of the country due to a family emergency

Describing a Problem

You can't get help with a problem unless you describe it well
Statements like the following are useless when asking for help
- It does not work
- I get an error when I run the code
You have to describe the specific circumstances that caused the problem
The best way to do this is with the actual text from the IDLE window
Copy the error message

Something like this

Traceback (most recent call last):
  File "/Users/glenn/Documents/hello.py", line 1, in 
    prin("Hello world!")
NameError: name 'prin' is not defined. Did you mean: 'print'?

Also, be sure you upload your code to the correct directory on pe15.cs.umb.edu
That way I can make a copy of the code ...
and use various debugging techniques

Don't Use Screenshots in Piazza

Many students paste screenshots of code into Piazza
This is not a good idea
I have a hard time reading some of the screen shots
And I can't copy the code into the Python interpreter to test it
Instead, copy the code to your class directory on pe15.cs.umb.edu ...
and type the name of your file into your Piazza entry

Making Script Executable

All scripts submitted for this course must be executable
If your scripts are not executable you will lose points
You make a file executable by doing two things
- Using the hashbang line
- Giving all uses read and execute permissions
The hashbang line must be the very first line of the script
The first two characters of this first line must be #!
This must be followed by the absolute address of the Python 3 interpreter
For this course the hashbang line must be
```
#! /usr/bin/python3
```
You can make a file executable by running the following Unix command on it
```
chmod 755 FILENAME
```
FILENAME is a placeholder
You replace this with the name of the file you are making executable
If I wanted to make the file hw2.py executable ...
I would would write the following on the Unix command line
```
chmod  755  hw2.py
```
In FileZilla you can give execute permission by right clicking on the script file ...
selecting "Permissions" from the menu ...
and entering "755" in the box provided

Login Failure

If you enter the wrong password when connecting to pe15 ...
you will be blocked from logging in for 10 minutes
Wait 10 minutes and try again
If you have forgotten or misremembered your password, you can change it
Go to https://portal.cs.umb.edu/password/
If you have trouble with your account send an email to operator@cs.umb.edu

Attendance

Python Review

`for` Loops

The counted loop in Python is the for loop

It has the following format

for VARIABLE_NAME in LIST_OF_SOME_SORT:
    STATEMENT
    STATEMENT
    ...

The for keyword is followed by a variable
Next comes the in keyword followed by a list of values
The first value in the list is assigned to the loop variable
The loop variable keeps that value as it runs through the code block
After the last statement in the code block ...
the loop variable gets the next value in the list
The loop stops when every value in the list has been used

The `range` Function

Python's range function makes it easy to create a list of integers ...

that can be used in a for loop

>>> for number in range(10):
...   print(number)
... 
0
1
2
3
4
5
6
7
8
9

Notice that the sequence of numbers started with 0 ...
and ended with one less than the value of the argument
You can also give the range function two arguments
In this case the first argument is the starting number ...

and the second argument is one more than the last number

>>> for number in range(5, 11):
...   print(number)
... 
5
6
7
8
9
10

You can even give three arguments to the range function
If you do, the first two arguments do the same thing ...
as the two argument version
But the third argument is the step value
It is the amount added to the previous number ...

to get the next number in the sequence

>>> for number in range(2, 11, 2):
...  print(number)
... 
2
4
6
8
10

Augmented Assignment Operators

When writing code we often want to change a variable by a certain amount
If I wanted to add 1 to the variable num I could write
```
num  =  num  +  1
```
Statements like this are very common
So Python has a set of special operators that will do three things
- Get the current value of the variable
- CHANGE this number by applying the operator to the number on the right
- Assign this new value to the variable
So instead of writing the statement above we could write
```
num  +=  1
```
This operator works as follows
- Get the current value of the variable on the left
- Get the current value of the expression on the right
- Add the two values
- Assign this new value to the variable
Using this operator makes the code shorter
Which reduces the risk of errors
An operator like this is called an augmented assignment operator

Python has an augmented assignment operator for every arithmetic operator

Operator	Example	Equivalent To
+=	numb += 5	numb = num + 5
-=	num -= 5	num = num - 5
*=	x *= 5	x = x * 5
/=	x /= 5	x = x / 5
//=	x //= 5	x = x // 5
%=	x %= 5	x = x % 5
**=	x **= 5	x = x ** 5

Nested Loops

Just as you can have an if statement inside another if statement ...
you can have one loop inside another
When you have one loop inside another it is called a nested loop
You can nest any type of loop inside another loop
But nested for loops are the most common
When you use a nested loop be sure each loop variable has different name
If you don't, you will get very strange results

Here's a script to create a times table

$ cat times_table.py 
# This script creates a times table using nested for loops

for row in range(1, 11):
    for column in range(1, 11):
        entry  = row * column
        print(entry, end="\t")
    print()

$ python3 times_table.py 
1   2   3   4   5   6   7   8   9   10
2   4   6   8   10  12  14  16  18  20
3   6   9   12  15  18  21  24  27  30
4   8   12  16  20  24  28  32  36  40
5   10  15  20  25  30  35  40  45  50
6   12  18  24  30  36  42  48  54  60
7   14  21  28  35  42  49  56  63  70
8   16  24  32  40  48  56  64  72  80
9   18  27  36  45  54  63  72  81  90
10  20  30  40  50  60  70  80  90  100

The loop variable row gets a new value with each pass through the loop
It keeps that value while the inner loop variable column ranges from 1 to 10
Notice the print statement in the innermost loop
It prints a number followed by a Tab
This keeps the output for each row on its own line
We need a call to print after the inner loop ...
to move to the next line

Functions

The trick to writing software is to break down a big task into smaller tasks ...
then work on these smaller tasks one-by-one
Functions are a great help in splitting the work into smaller tasks
A function is a group of statements that has a name and performs a specific task
Each function operates in its own environment ...
so it can be isolated from the rest of the program
The Python interpreter has a number of predefined functions inside it
They are called builtin functions
They are always available for you to use in your scripts
You can see a list of them here
But you can also define your own Python functions
Most Python scripts contain a number of functions ...
written specially for that script
If you find yourself using certain functions over and over again ...
you can put them in a file ...
and import them into other scripts
These files are called modules

Function Names

Function names must follow the same rules as variable names
- You cannot use keywords as function names
- Function names cannot have spaces
- The first character of a function name must be a letter, a-z and A-Z, or an underscore, _
- After the first character you can use letters, digits or the underscore
- Uppercase and lowercase letters are distinct
Just as with variable names, you can use several words in a function name ...
if you separate each word with an underscore, _
A function name should describe what the function does
Since functions do things, most function names use verbs
```
calculate_gross_pay
get_hourly_rate
calculate_overtime
```

Defining a Function

A function definition has the following format

def FUNCTION_NAME([PARAMETER][...]):
    STATEMENT
    STATEMENT
    ...

The first line of a function definition is called the function header
There are four parts to the function header
- The keyword def
- The function name
- The parameter list enclosed in parentheses, ( )
- A colon, :, at the end of the line
All of these must be present
If there are no parameters, you must still have parentheses in the header
Following the function header is a series of indented statements ...
that form the code block

Calling a Function

To use a function, you make a function call
A function call has two parts
- The function name
- A list of arguments enclosed in parentheses
You must always have parentheses ...
even if the function takes no arguments

Here is an example of a function that takes no arguments

>>> def hello():
...   print("Hello world")
... 
>>> hello()
Hello world
>>>

Parameters

When you call a function it is given its own bit of memory
This allows functions to operate independently ...
of other functions
A function can change anything in its own portion of memory
But those change do not affect anything else
Once the function has finished its work ...
its memory disappears
Most functions need information from the function call
They get this information using parameters
Parameters are variables the live inside the function's memory space
They are listed inside the parentheses of the function header
The function below has a single parameter named team
```
def cheer(team):
    print("Go", team, end="!\n")
```
Parameters get their values ...
from the expressions inside the parentheses of the function call
These expressions are called arguments
In the statement below the argument is "Red Sox"
```
cheer("Red Sox")
```

Local Variables

A function runs inside its own space in memory
It gets this chunk of memory when the function is called
As soon as the function finishes, this memory disappears
All functions variables are stored in the function's memory space
So they disappear when the function is done
Variables defined inside a function are called local variables
All local variables are invisible outside the function
They can only be used inside the function
There are two types of local variables
- Parameters
- Other variables
Parameters are defined inside the parentheses of the function header
The other variables are defined inside the function's code block ...
just as your would create variables outside the function
Parameters get their values from the arguments in the function call
The other variables get their values from assignment statements ...
inside the body of the function
In the function below, team is a parameter ...

but first_word is not

def cheer(team):
    first_word = "Go"
    print(first_word, team, end="!\n")

Functions that Return Values

Functions that return values can be used in assignment statements ...

and function calls

>>> result = math.sqrt(7) 
>>> result
2.6457513110645907
>>> round(math.sqrt(7))
3

Functions use a return statement to send a value back to the function call
Here is the format
```
return  EXPRESSION
```
An expression is anything that the Python interpreter can turn into a value
There are four types of expressions
- Litterals
- Variables
- Calculations involving operators
- Function calls
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 Python statements after return will never be executed
Here is a new version of the cheer function ...

that returns a value

>>> def cheer(team):
...    return "Go " + team + " !"

This version does not actually print anything
So we need to put a call to the function ...
inside the parentheses of a call to print
```
>>> print(cheer("Red Sox"))
Go Red Sox!
```
We can do this because cheer now returns a value
So a call to this new version of cheer is an expression
And we can always use an expression as the argument to a function

Returning Multiple Values

A Python return statement can return more than one value
To do this you follow the return with a comma separated list of expressions
```
return EXPRESION [, 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

So we will need two variables to receive these values

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

Standard Library Functions

All computer languages come with functions that perform useful operations
Here are some examples from Python
- print
- int
- float
- input
- range
All of these are builtin functions
Builtin functions are actually part of the Python interpreter
So they are always available
You do not have to do anything special to use them
But every time you install Python you get many other useful functions
These are contained in special files which make up the standard library
The standard library consist of many files called modules
Each module contains functions and variables that do related things
For example the math module contains many common mathematical functions
But you cannot use a module functions inside a script ...
unless you import them
You do this with an import statement
import statements have the following form
```
import MODULE_NAME
```
The MODULE_NAME is the file name without the .py extension.
When using a function or a variable imported from a module ...
you must use dot notation
First you write the name of the module ...
followed by a dot ( . ) ...
followed by the name of the function or variable

Here are some examples

>>>  math.pi # trying to use a math module variable before importing math
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'math' is not defined
>>> import math
>>> math.pi
3.141592653589793
>>> math.sin(math.pi)
1.2246467991473532e-16
>>> math.cos(math.pi)
-1.0
>>> math.ceil(4.3)
5
>>> math.floor(4.3)
4
>>> math.floor(-4.3)
-5
>>> math.ceil(-4.3)
-4

Objects

A variable is a place in memory with a name that holds a single value ...
like an integer, float or boolean
Objects can hold more than one value
They also contain functions that work with those values
The functions inside an object are called methods
Objects do not have names
Instead they have a location in memory
In order to work with an object ...
its location has to be stored in a variable
You can think of this variable as pointing to the object
To refer to function or variable inside an object ...
you must use dot notation

Files

A file is simply a linear arrangement of data ...
on some long term storage device ...
like a hard drive, thumb drive or CD ROM
Files are identified by their name and their location
The data inside a file can be in any one of a number of formats
As far as Python is concerned, there are two types of files
- Text
- Binary
Text files contain characters: letters, symbols and digits
These characters are grouped into lines ...
which have the newline character \n at the end
So in some sense, a text file is a list of lines
Binary files store their information as a sequence of binary numbers
All of the work we will be doing in this class will be with text files

Using Files

All operations inside a computer take place in the computer's RAM
But files live in some external storage device like a hard drive or a CD
To work with a file the computer needs a structure in RAM ...
that has data which allows the you to use the file
This structure is called a file object
To work with a file you must create a file object connected to the file

Creating a File Object

You create a file object using the open function
open is a builtin function
You do not have to import it
open does two things
- It creates a file object
- It returns the location of the object
We need to store the location returned by open in a variable ...
so we can use the file
Here is the format
```
FILE_VARIABLE  =  open(PATHNAME, MODE)
```
FILE_VARIABLE is the name of the variable that points to the file object
PATHNAME is a string giving the name and location of the file
In this class the file will always be in the same directory as the script
So the pathname will just be the name of the file
MODE is a letter specifying what we want to do with the file

The three most commonly used access modes are

Mode	Description
"r"	Open a file for reading only
"w"	Open a file for writing
"a"	Open a file for writing to the end of the file

These access modes only apply to text files
If you open a file for writing that does not exist, it will be created
If the file does exist, what it contains will be lost
It will be replaced by what you now write to the file
The "a" in the last mode stands for "append"
When you write to a file in append mode ...
the text is added to the bottom of the file
This means you do not lose the previous contents of the file

Writing Data to a File

Objects contain values and the functions that work with those values
The functions inside objects are called methods
To call a method you must use dot notation
Dot notation for methods has the following format
```
OBJECT_VARIABLE.METHOD_NAME
```
To write data to a file we must first open it for writing
```
teams_file = open("teams.txt", "w")
```
The variable teams_file points to the new file object
Now we can use the write method of this file object ...
to write some text to the file
```
teams_file.write("Red Sox\n")
```
If you want to write a line to a text file you must include the newline character ...
which we write as \n

Using a File More Than Once

The file objects created with the access modes above only move in one direction
If you have read a line, you cannot go back
If you need to read the lines in a file more than once
you have to reate a new file object on the same file

Appending Data to a File

Appending means adding lines to a text file that already exists
You open the file using the append access mode like this
```
file = open(filename, "a")
```
If you open a file for writing it overwrites the contents of the file
But opening a file for appending adds text to the bottom of the file

Reading Files with a `for` Loop

The best way to read a file is with a for loop
You create a file object for reading
And then use the variable that points to this object ...
after in in the loop header

The general form of a for loop is

for LOOP_VARRIABLE in LIST_OF_SOME_SORT:
	STATEMENT
	STATEMENT
	...

The LIST_OF_SOME_SORT can be many things
- Lists
- Tuples
- Strings
It can also be a file
Text files contain strings with a newline character at the end
So you can think of a text file as a list of lines
To read a file you put the variable pointing to the file object ...

after the keyword in

for VARIABLE in FILE_VARIABLE:
    STATEMENT
    ...

Here is an example

$ cat print_file.py 
#! /usr/bin/python3

# prints the lines in a file with a for loop

filename = input("Filename: ")
file = open(filename, "r")

for line in file:
    print(line)

$ cat numbers.txt 
3
3
9
5
2
7
6
8
10
1

$ ./print_file.py 
Filename: numbers.txt
3

3

9

5

2

7

6

8

10

1

Why is there a blank line after every number?
Because the loop variable line contains the entire line of text ...
including the newline character at the end of the line
To fix this we should write
```
print(line.strip())
```

General Advice

Course Work

Tips and Examples

Python Review

Trouble? Questions?

Homework 2

Today's Class

General Advice

Do You Have Enough Time to Do the Work for This Course?

Course Work

Class Quizzes

First Graded Quiz

Tips and Examples

Class Exercises

Getting Help

Describing a Problem

Don't Use Screenshots in Piazza

Making Script Executable

Login Failure

Attendance

Python Review

for Loops

The range Function

Augmented Assignment Operators

Nested Loops

Functions

Function Names

Defining a Function

Calling a Function

Parameters

Local Variables

Functions that Return Values

Returning Multiple Values

Standard Library Functions

Objects

Files

Using Files

Creating a File Object

Writing Data to a File

Using a File More Than Once

Appending Data to a File

Reading Files with a for Loop

Class Exercise

Class Quiz

`for` Loops

The `range` Function

Reading Files with a `for` Loop