IT 117: Intermediate Scripting

IT 117: Intermediate Scripting
Class 4

Python Review

Microphone

Questions? Issues?

Does anybody have any questions before I begin?

Homework 2

I have posted homework 2 here.

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

Today's Class

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

General Advice

Make a Study Schedule

One of the most important thing you can do to do better in class ...
is to make a study schedule ...
and keep to it
A consistant study routine is the single most important thing you can do ...
to improve your grade
You should set aside regular chunks of time for this course ...
and stick to it as best you can
The semester is long - 14 weeks
Most of you have many responsibilites
Conflicting demands on your time can cause you to lose focus
Having a regular schedule can keep you on track ...
and prevent panic attacks before exams
Time is a finite resource
Once you have wasted an hour ...
you can never get it back
If you find your schedule is not working ...
make some changes
But do not use that as an excuse to abandon a schedule
There is an old saying
If you fail to plan ...
you are planning to fail

Course Work

First Graded Quiz

The first graded quiz will be given on Tuesday next week
The question on the quiz are taken from the ungraded quizzes ...
of the previous week
You should expect a Graded Quiz each week on Tuesday
If you do not take the quiz when it is offered ...
you cannot take it at another time
If you miss a quiz but have an excuse, send me an email

Gradescope

In order to receive your scores in Gradescope ...
you need to sign in to my Gradescope section
You do not have to register with Gradescope
In the next few days I will enter all your UMB addresses into Gradescope
You will then receive an email from Gradescope
What happens next depends on whether you are 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.

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

Rules for Homework Scripts

Your homework scripts must follow certain rules ...
which you will find here
Let's take a look

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
You can do this in FileZilla
First connect to pe15.cs.umb.edu
Then drill down to either the ex or hw directory
Double click on the directory
Right click on the blank area of the bottom panel
This will bring up a menu
Select "Create directory"
You can also move files and 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 for this class in one directory
Go to your Documents directory and create a python directory
Then create all your Python scripts in this directory
This will make it easier to find them in FileZilla ...
when you need to move them to pe15.cs.umb.edu

Use Flash Cards to Prepare for Graded Quizzes

To study 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`

Python script can be run on the command line ...
without calling the Python interpreter python3 ...
if you make the script executable
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
You can run executable script on the Unix command line
To run a 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
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 scripts 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

Most script don't work the first time you run them
The process of locating and fixing the errors can take some time
To make this process more efficient ...
it is important to distinguish three types of errors
- Syntax errors
- Logic errors
- Runtime errors

Syntax Errors

Syntax errors occurwhen 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 runs those statements
When your code does this, it is said to catch an exception
A call to open can cause a runtime error ...
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 leave 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("Could not open file", filename)
else:
    for line in file:
	print(line.rstrip())

Sequences

Sometimes you need to store many values in a single place
Things like 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 obtain 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 builtin 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
It 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 are characters that mark the boundaries between values

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

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

If the string 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("/")
["5","3","16"]

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"]

General Advice

Course Work

Tips and Examples

Python Review

Questions? Issues?

Homework 2

Today's Class

General Advice

Make a Study Schedule

Course Work

First Graded Quiz

Gradescope

Class Quizzes

Rules for Homework Scripts

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

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