IT 117: Intermediate Scripting

IT 117: Intermediate Scripting
Class 4

Tips and Examples

Run Test Scripts in the Exercise Directory
Creating Directories with FileZilla
Keeping Your Scripts Organized
Use Flash Cards to Prepare for Graded Quizzes

Python Review

Studying

Some Students Are Having a Hard Time

Microphone

Homework 2

I have posted homework 2 here.

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

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.

The quiz will be available from the Gradescope web site but only for the last 15 minutes of the class.

Once you start the quiz, you will have 15 minutes to finish it.

If you do not take the quiz when it is offered you cannot take it at another time because Gradescope does not permit this.

If you fail to take the quiz but have a valid excuse, send me an email.

Gradescope

In order to take the quiz on Gradescope, you need to sign in to my Gradescope section.

Sometime during the next few days I will enter all your UMB email addresses into Gradescope.

You will receive an email from Gradescope.

What happens next depends on whether you have already registered with Gradescope.

If you are new to Gradescope

Click the "Set your password" link
Confirm your password
Click Save
You will then be taken to the page for your course

If you are already registered with Gradescope

Click the link to the course
At the login screen enter your UMB email address and your Gradescope password
If you have forgotten you password, click the "Forgot your password"link

You will find more information about Gradescope here.

Recordings of Class Meetings

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

You will also find this link on the class web page.

Zoom Office Hours

You will links to the Zoom Office Hours meetings here .

You will also find this link on the class web page.

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 .

Rules for Homework Scripts

You must follow certain rules when you create your homework scripts.

You will find those rules here.

Questions

Are there any questions before I begin?

Tips and Examples

Run Test Scripts in the Exercise Directory

Almost all of the Class Exercise scripts require a data file
This file provides information that the script needs
If you run my test scripts on programs that need a data file ...
you must run it in a directory that contains this file
For example if I run the test script for Class Exercise 4 from my home directory
Which does not contain the data file numbers.txt

I will get an error

$ ~ghoffman/it117_test/ex04.sh
Unix username: ghoffman
ghoffman         Glenn Hoffman
++++++++++++++++++++++++++++++++++
Is file executable?
----------------------------------
ex4.py is executable
----------------------------------
++++++++++++++++++++++++++++++++++
Looking for hashbang
----------------------------------
#! /usr/bin/python3
----------------------------------
++++++++++++++++++++++++++++++++++
Error check
----------------------------------
Traceback (most recent call last):
  File "/courses/it117/s23/ghoffman/ghoffman/ex/ex4/ex4.py", line 85, in >module<
    number_list = read_integers_into_list("numbers.txt")
  File "/courses/it117/s23/ghoffman/ghoffman/ex/ex4/ex4.py", line 43, in read_integers_into_list
    file = open(filename, "r")
FileNotFoundError: [Errno 2] No such file or directory: 'numbers.txt'
SYNTAX ERROR 
ghoffman         Glenn Hoffman
Class Exercise 4

But if I go to my ex4 directory ...
which contains numbers.txt ...
I will not get this error

Creating Directories with FileZilla

You need to create a new directory for each Class Exercise and homework assignment
But you do not have to log in to pe15.cs.umb.edu to do this
You can do it in FileZilla
First connect to pe15.cs.umb.edu
Then drill down to either the ex or hw directory
Right click on the directory
This will bring up a menu that will let you create a directory
You can also move files an directories in FileZilla by clicking and dragging

Keeping Your Scripts Organized

Organization is an important part of IT work
You should keep all the scripts in one directory on your personal machine
This will make it easier to move them to FileZilla
I would suggest you create a python directory in you Documents directory

Use Flash Cards to Prepare for Graded Quizzes

To studying for the graded quizzes you need to study the Class Quizzes for the previous week
The best way to do this is to use flash cards
You take an index card and write the question on one side and the answer on the other
You should make a set of flash cards for each class and label them with the Class Number
Then put a rubber band around them
I did this when taking courses for my Masters degree
I would go through them on my way to work on the T
I know there are programs that you can use to create virtual flash cards
But the simple act of writing each card helps you remember the material

Attendance

Python Review

Running a Script Without `python3`

Here is a simple python script
```
$ cat hello.py
print("Hello world!")
```
Linux lets us make a file executable by giving read and execute permission to users

We can do this using the Unix chmod command

$ chmod 755  hello_1.py

$ ls -l hello_1.py
-rwxr-xr-x 1 ghoffman faculty 50 Mar 13 21:58 hello_1.py

You can also do this in FileZilla
To run an executable script in your current directory you cannot simply use the filename
You have to put . / in front of the filename
The reason for this has to do with security
But one more thing needs to be changed

If I try to run ./hello_1.py it won't work

$ ./hello_1.py
./hello_1.py: line 3: syntax error near unexpected token `"Hello world!"
./hello_1.py: line 3: `print("Hello world!")'

Why does this happen?
Because Unix does not know what interpreter to use to run the script
But Unix provides a way for you to tell it what interpreter to use

You do this by adding a special line as the very first line of the script

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

# prints a friendly message

print("Hello world!")

You can now run the script without having to use the python3 command
```
$ ./hello_2.py 
Hello world!
```
This special line is called the hashbang line
This line must be the first line in the script
And the first characters must be #!
These two characters must be followed by the absolute pathname ...
of the Python interpreter python3
The hashbang line you should use in you script is
```
#! /usr/bin/python3
```

Records

The file sox_games.txt contains the results of Red Sox games

2016-04-04  Red Sox @  Astros   Win 7-5
2016-04-05  Red Sox @  Astros   Win 2-1
2016-04-07  Red Sox vs Yankees  Loss 7-9

The chunks of information that describe the results of a baseball game ...
compose something called a record
A record is a collection of information about some thing or event
A record for a baseball game would contain
- Game Date
- Home Team
- Opposing Team
- Home Team Score
- Opponent Score
The individual pieces of information inside a record are called fields

Errors

A lot of time can be spent fixing problems with scripts
To make this process more efficient, it is important to distinguish three classes of errors
- Syntax errors
- Logic errors
- Runtime errors

Syntax Errors

Syntax errors occur when you write a statement that violates the rules of the programming language
```
>>> for = 5
  File "<stdin>", line 1
    for = 5
        ^
SyntaxError: invalid syntax
```
Python does not let you use a keyword as a variable name
So this is not a legal Python statement

Probably the most common syntax error is misspelling the name of a function or variable

>>> name = "Glenn"
>>> print(nme)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'nme' is not defined

Logic Errors

A logic error occurs when the code does not give the correct results

Here is an example

average = num_1 + num_2/2
print ("Average:", average)

The numerator for division should be sum of both num_1 and num_2
But here it is only num_2
You get no error message with a logic error
The code works and unless you check the results you will not know there is a problem
This is why it is always important run tests on the scripts you write

Runtime Errors

Runtime errors occur only when the the program is running
They occur when a certain value makes a statement fail
If the program is run again with a different value no runtime error would occur

A common way to get a runtime error is to open a file that does not exist

$ ./file_open.py 
Filename: xxxxxx
Traceback (most recent call last):
  File "./file_open.py", line 6, in <module>
    file     = open(filename, "r")
FileNotFoundError: [Errno 2] No such file or directory: 'xxxxxx'

Opening a file for which you have no permission will cause another type of runtime error

$ ./file_open.py 
Filename: unreadable.txt
Traceback (most recent call last):
  File "./file_open.py", line 6, in <module>
    file     = open(filename, "r")
PermissionError: [Errno 13] Permission denied: 'unreadable.txt'

Exception Objects

Python has a mechanism that deals with runtime errors
It gathers information about what happened and where
And uses that information to create an error message
It does this by creating an exception object
When this happens we say that the interpreter has raised an exception

Catching Exceptions

But exceptions can do more than create error messages when something goes wrong
In Python you can detect exceptions while your script is running
This allows you to write code to deal with the runtime error

You do this with a try/except statement which has the following form

try:
    STATEMENT
    STATEMENT
    ...
except:
    STATEMENT
    STATEMENT
    ...

If any statement in the try code block causes a runtime error ...
the interpreter stops executing the code in the try block
Instead it jumps to the except code block and executes those statements
When your code does this, it is said to catch an exception
open can cause runtime errors if you try to open a file that does not exist
So you should always put open statements inside a try block

Like this

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

filename = input("Filename: ")
try:
    file = open(filename, "r")
    for line in file:
        print(line.rstrip())
except:
    print("Could not open file", filename)

$ ./open_file.py
Filename: xxxx
Could not open file xxxx

Notice that the interpreter never ran the for loop

The `else` Clause

A try/except statement can also have an else clause
The statements in this block will be run if the try block code does not cause a runtime error
In the code above a call to open ...
is followed by statements ...
that will only work if there is no runtime error
You could put these statements inside the try block
But I like to put them in an except block

Doing this makes the code easier to read

try:
    file = open(filename, "r")
except:
    print("Cannot open", filename)
else:
    count = 0
    total = 0
    for line in file:
        count += 1
        date, temp = line.split()
        temp   = int(temp)
        total += temp

    average = round(total/count, 2)
    print("Average:", average)

Sequences

Sometimes you need to store many values in a single place
Things like the days of the week or the scores on a test
Python provides a class of data types called sequences that can hold many values
The picture in memory looks like this

The values in a sequence are stored one right after the other
This means they have a definite order
The three most important sequences are
- Lists
- Tuples
- Strings
Lists are sequences whose values can be changed
Tuples are sequences that cannot be changed
Strings are sequences of characters
Both lists and tuples can hold any kind of data
Strings can only contain characters
All sequences are objects which means they have methods
The methods are functions that work on the values contained in the object
The individual values in a sequence are called elements

Indexing Sequence Objects

The elements in a sequence object have a definite order
So you can use the position of an element in the sequence to get its value
The number that specifies the position is called an index
Indexes start at 0 not 1
This is called zero-based indexing
To get the value of an element you put the index inside square brackets, [ ]

Right after the variable that points to the sequence object

>>> list_1   = [1,2,3,4,5]
>>> tuple_1  = (1,2,3,4,5)
>>> string_1 = "12345"
>>> list_1[0]
1
>>> tuple_1[1]
2
>>> string_1[2]
'3'

Sequence Operators

Operators are special characters that perform an action
Usually that action is to create a new value
They work on one or more values called operands
There are only two operators that can be used with sequences
- + - concatenation
- * - repetition

Concatenation creates a new sequence by appending one sequence onto the back of another

>>> [1,2,3] + [4,5]
[1, 2, 3, 4, 5]
>>> (1,2,3) + (4,5)
(1, 2, 3, 4, 5)
>>> "123" + "45"
'12345'

Repetition appends multiple copies of a sequence onto itself

>>> [1,2,3] * 2
[1, 2, 3, 1, 2, 3]
>>> (1,2,3) * 3
(1, 2, 3, 1, 2, 3, 1, 2, 3)
>>> "123" * 4
'123123123123'

Empty Sequences

An empty sequence is a sequence with no elements

>>> empty_list = []            
>>> empty_list
[]
>>> empty_tuple = ()
>>> empty_tuple
()
>>> empty_string = ""
>>> empty_string
"

Empty sequences are like 0 for sequences
We can construct any number by continually adding numbers to 0

Similarly, we can build sequences by concatenating onto an empty sequence

>>> empty_list + [1]
[1]
>>> empty_tuple + (1,2)
(1, 2)
>>> empty_string + "123"
'123'

The `len` Function

Python has a built in function called len that will return the length of any sequence
```
>>> len([1,2,3])
3
>>> len((1,2,3,4))
4
>>> len("1234")
4
```

Using a `for` Loop with Sequences

for loops make it easy to work with the elements of a sequence
Whenever we loop through the elements of a sequence we are said to iterate over it
The header of the loop has the following format
```
for LOOP_VARIABLE in SEQUENCE:
```

Here are some examples

>>> list_1 = [1,2,3]
>>> for element in list_1:
...     print(element)
... 
1
2
3
>>> tuple_1 = (1,2,3)
>>> for element in tuple_1:
...     print(element)
... 
1
2
3
>>> string_1 = "123"
>>> for element in string_1:
...     print(element)
... 
1
2
3

Changing Values in a `for` Loop

Tuples and strings are immutable
That means they cannot be changed
But you can change lists
If you want to change every value in a list you can do this with a for loop
But you must use indexes

The format is

for INDEX_VARIABLE in range(len(LIST)):
    LIST[INDEX_VARIABLE] = NEW_VALUE

Here is an example

>>> numbs = [1,2,3,4,5]
>>>for index in range(len(numbs)):
...     numbs[index] += 1
... 
>>> numbs
[2, 3, 4, 5, 6]

You should only use indexes in a for loop when you want to change an element

Slices

Slices allow you to create a new sequence from elements in an existing sequence
To get a slice from a list, you use the following format
```
SEQUENCE_VARIABLE[FIRST_INDEX:ONE_MORE_THAN_LAST_INDEX]
```

Here are some examples

>>> list_1 = [1,2,3,4,5]
>>> list_1[2:4]
[3, 4]
>>> tuple_1 = (1,2,3,4,5)
>>> tuple_1[0,4]
>>> tuple_1[0:4]
(1, 2, 3, 4)
>>> string_1 = "12345"
>>> string_1[2:6]
'345'

If you leave out the first index Python uses 0 for that index

>>> list_1
[1, 2, 3, 4, 5]            
>>> list_1[:3]
[1, 2, 3]

If you leave out the last index Python uses the length of the sequence
```
>>>  tuple_1
(1, 2, 3, 4, 5)
>>> tuple_1[2:]
(3, 4, 5)
```
If you leave out both indexes Python returns the entire sequence
```
>>> string_1
'12345'
>>> string_1[:]
'12345'
```
This is useful when you want to make a brand new sequence object

From and existing object

>>> list_2 = list_1[:]
>>> list_1
[1, 2, 3, 4, 5]
>>> list_2
[1, 2, 3, 4, 5]
>>> list_1[0] = 5
>>> list_1
[5, 2, 3, 4, 5]
>>> list_2
[1, 2, 3, 4, 5]

The `in` Operator

in is a boolean operator that can be used with sequences
You use it to see if a certain value is contained inside the sequence
in returns True if the sequence contains the value
The format is
```
VALUE in SEQUENCE
```

Here are some examples

>>> nums = [1,2,3,4,5]
>>> 3 in nums
True
>>> 6 in nums
False
>>> numbers = (1,2,3,4,5)
>>> 2 in numbers
True
>>> 7 in numbers
False
>>> digits = "0123456789"
>>> "2" in digits
True
>>> 'a' in digits
False

When you use in with strings you can search for more than 1 character

>>> digits = "0123456789"
>>> "345" in digits
True
>>> "379" in digits
False

List Methods

Lists are objects
Objects can have functions that work on the values inside the object
These functions are called methods

Here are some of the more useful methods

Method	Description
append(item)	Adds item to the end of the list
index(item)	Returns the index of the first element whose value is equal to item. A ValueError exception is raised if item is not found in the list.
insert(index, item)	Inserts item into the list at the specified index . When an item is inserted into a list, the list is expanded in size to accommodate the new item. The item that was previously at the specified index, and all the items after it, are shifted by one position toward the end of the list.
sort()	Sorts the items in the list so they appear in ascending order (from the lowest value to the highest value)
remove(item)	Removes the first occurrence of item from the list. A ValueError exception is raised if item is not found in the list.
reverse()	Reverses the order of the items in the list

The `del` Statement

The easiest way to delete an element from a list is to use a del statement
It has the following format
```
del LIST_VARIABLE[INDEX]
```

Here is an example

>>> nums
[1, 2, 3, 4, 5]
>>> del nums[0]
>>> nums
[2, 3, 4, 5]

You cannot use a del statement with tuple or strings because they are immutable

The min and max Functions

Two built-in functions can also be used with sequences
max will return the largest value in a sequence
```
>>> l1 = [1,2,3,4,5]
>>> max(l1)
5
```
And min will return the smallest
```
>>>  min(l1)
1
```

They also work with strings

>>> l2 = ["abacus", "bear", "cat", "dog"]
>>> max(l2)
'dog'
>>> min(l2)
'abacus'

But not with sequences that mix strings and numbers

>>> l3 = [1,2,4,"five"]
>>> max(l3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: str() > int()

Negative Numbers as Indexes

You can use a negative number as an index
An index of -1 points to the last element in a sequence
-2 points to the second to last element

And so on

>>> nums_1 = [1,2,3,4,5]
>>> nums_1[-1]
5
>>> nums_1[len(nums_1) -1]
5
>>> digits = "0123456789"
>>> digits[-3]
'7'
>>> digits[len(digits) -3]
'7'

strip()

The strip() method creates a new string
I does this by stripping characters from the front and back of a string

When used with no argument it strips whitespace characters

>>> name
'  Glenn  '
>>> name.strip()
'Glenn'
>>> team
'  Red Sox'
>>> team.strip()
'Red Sox'

Splitting a String

The split method creates a list from the different parts of a string
In order to do this it needs to know where each element begins and ends
It does using delimiters
Delimiters mark the boundaries used to split the string

If you don't provide an argument to split it will use spaces

>>> team.split()
["Red", "Sox"]
>>> hamlet
"To be\nor not to be"
>>> hamlet.split()
["To", "be", "or", "not", "to", "be"]

If the string on which the method is called has no whitespace it returns list of one element
```
>>> name
"Glenn"
>>> name.split()
["Glenn"]
```

If you give split a string it will use that string as a delimiter

>>> date1
"2016-05-03"
>>> date1.split("-")
["2016", "05", "03"]
>>> date2
"5/3/16"
>>> date2.split("/")

You can split on any character

>>> name.split("e")
["Gl", "nn"]
>>> name.split("n")
["Gle", ", "]

Or group of characters

>>> date3
"5--3--16"
>>> date3.split("--")
["5", "3", "16"]

Studying

Some Students Are Having a Hard Time

Tips and Examples

Python Review

Studying

Homework 2

First Graded Quiz

Gradescope

Recordings of Class Meetings

Zoom Office Hours

Class Page for IT 116

Rules for Homework Scripts

Questions

Tips and Examples

Run Test Scripts in the Exercise Directory

Creating Directories with FileZilla

Keeping Your Scripts Organized

Use Flash Cards to Prepare for Graded Quizzes

Attendance

Python Review

Running a Script Without python3

Records

Errors

Syntax Errors

Logic Errors

Runtime Errors

Exception Objects

Catching Exceptions

The else Clause

Sequences

Indexing Sequence Objects

Sequence Operators

Empty Sequences

The len Function

Using a for Loop with Sequences

Changing Values in a for Loop

Slices

The in Operator

List Methods

The del Statement

The min and max Functions

Negative Numbers as Indexes

strip()

Splitting a String

Studying

Class Exercise

Class Quiz

Running a Script Without `python3`

The `else` Clause

The `len` Function

Using a `for` Loop with Sequences

Changing Values in a `for` Loop

The `in` Operator

The `del` Statement