IT 117: Intermediate Scripting

IT 117: Intermediate Scripting
Class 3

Tips and Examples

Class Exercises
Getting Help
Describing a Problem
Don't Use Screenshots in Piazza
Making Script Executable

Python Review

Login Failure

If you enter the wrong password 5 times when connecting to pe15 you will be temporarily blocked from logging in to this machine.

This lock out will only last for 2 hours.

After 2 hours, you should be able try again.

If you have forgotten or misremembered your password, you can change it.

Go to https://portal.cs.umb.edu/password/

Recordings of Class Meetings

You will find links to the recordings of class meetings here.

Use of Storage Space on the CS LAN

All of you will have an account on the Computer Science Department network.

With this account you get a home directory.

There is a limit on the total size of the files in your home directory.

So you should not store there anything you do not need for your classwork.

Homework 2

I have posted homework 2 here.

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

Format of Homework Assignments

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 quiz you need to take.

Answer all the questions on a piece of paper.

Go to the listing of Class Quiz Answers you will find here.

Check your answers.

First Graded Quiz

The first graded quiz will be given on Tuesday next week.

The questions from the graded quiz are taken from the ungraded quizzes of the previous week.

Unless I tell you otherwise, you should expect a graded quiz each week.

The quiz will be available on Gradescope on Tuesday.

Class Page for IT 116

You may find it useful to look at my materials for IT 116.

I have a web site where I post most of the materials for my courses for the previous semester.

You will find these materials here http://96.126.105.215/umb_classes_html/it116_html/class_page_it116.html .

I have included this link on the class page for the course.

Go to the index for the Class Notes and search for a topic.

You will find the index here http://96.126.105.215/umb_classes_html/it116_html/class_notes_it116/class_notes_index_it116.html .

Do Not Post Anything From this Class Online

There are many web site that claim to "help" students learn new material.

As far as I am concerned sites like Chegg and CourseHero get their money by helping students cheat on their assignments.

Posting ANYTHING on such sites is a violation of your Oath of Honesty and will be reported to the Provost's Office.

This includes quiz and exam questions as well as homework assignments and Class Exercises.

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 two points for each day it is late
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 an hit return, the tests will bw 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 check
----------------------------------
----------------------------------
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

First test is the Error check which looks for mistakes in your code
If you see nothing between the two dashed lines, no errors were detected
If the output of your script is missing someting or produces in correct 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 two ways you can do this
- Post a question in the class discussion area
- Email the Class Assistant
DO NOT EMAIL ME with your question
I have over 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
- I can't log in
- It does not work
You have to describe the specific circumstances that caused the problem
The best way to do this is with the actual text from the ssh client window
Copy both what you typed, and what happened after you hit Enter

Something like this

>>>  print "Hello Wolrd"
SyntaxError: Missing parentheses in call to 'print'. Did you mean print("Hello Wolrd")?
>>>

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
And type the name of your file into your Piazza entry
This way I can run the code myself
And use various debugging techniques

Making Script Executable

All scripts submitted for this course must be executable
If not you will lose points
You make a file executable by doing two things
- Using the hashbang line
- Running the Unix command chmod
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
```

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

Creating the list of integers is not hard if the list is short
But what if we wanted to add the numbers from 1 to 100?
Creating that list would be very tedious

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

>>> 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
The step value is the amount by which each number is changed from the number that came before
```
>>> 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 number by a certain amount
If we wanted to add 1 to the variable num we 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 a loop inside another loop
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

Let's write 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 print 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 function that are predefined inside it
They are called built-in 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 the script
If you find yourself using certain function over and over again you can put them in a file
These files are called modules
You can bring these functions into your script using an import statement

Function Names

Function names must follow the same rules as variable names
- You cannot use keywords variable names
- Variable names cannot have spaces
- The first character of a variable 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 is what allows functions to operate independently
A function can change anything in its own section of memory
But those changed do not affect anything else
Once the function has finished its work its memory disappears
Most functions need information from the function call to do their work
They get this information using parameters
Parameters are variables the live inside the function
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 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 functions 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
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
```
>>> result = math.sqrt(7) 
>>> result
2.6457513110645907
```
Functions use a return statement to send a value back to the function call
Here is the format
```
return  EXPRESSION
```
Remember, an expression is anything that the Python interpreter can turn into a value
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 the call to the function inside the parentheses of 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 built-in functions
Built-in 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 called 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 imported 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 function or variable imported from a module you must employ 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 can 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 this 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 use dot notation

Files

A file is simply a linear arrangement of data on some storage medium
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, symbols and digits which make sense to us
Binary files store their information a sequences 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 can access 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 built-in
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 work with 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 the text is added to the bottom 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 new file object to send 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

Closing a File

When you have finished working with a file you should close it
This will allow other programs to use the file
To close a file you use the close method
The general format for using the close method is
```
FILE_VARIABLE.close()
```
Closing destroys the file object
And breaks the connection to the file
To close the file object pointed to by file you would write
```
file.close()
```

Using a File More Than Once

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

Appending Data to a File

You add lines to a text file that already exists
If 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
- List
- Tuple
- String
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 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())
```

Tips and Examples

Python Review

Login Failure

Recordings of Class Meetings

Use of Storage Space on the CS LAN

Homework 2

Format of Homework Assignments

Class Quizzes

First Graded Quiz

Class Page for IT 116

Do Not Post Anything From this Class Online

Tips and Examples

Class Exercises

Getting Help

Describing a Problem

Don't Use Screenshots in Piazza

Making Script Executable

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

Closing a File

Using a File More Than Once

Appending Data to a File

Reading Files with a for Loop

Attendance

Class Exercise

Class Quiz

`for` Loops

The `range` Function

Reading Files with a `for` Loop