IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 22

Today's Topics

Review

The Code in the try Clause
Different Exception Types
Common Exception Types
Handling More Than One Type of Exception
The else Clause
The finally Clause

New Material

Working with Collections of Data
Sequences
Lists
The list Function
Operators That Work on Objects
Concatenating Lists
The Repetition Operator
Using a for Loop with Lists
Indexing
The len Function
Changing Elements Using Indexes
Being a Good Citizen
Do No Harm

Homework 10

I have posted homework 10 here.

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

Review

The Code in the `try` Clause

Whenever you open a file you need to put the open statement in the try block of a try/except statement
But the rest of your code needs the file object to function properly

If this code is outside the try/except statement you will get an error

filename = input("Filename: ")
try:
    file = open(filename, 'r')
except:
    print('Cannot open', filename)

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)


$ ./temps_average_3.py 
Filename: xxx
Cannot open xxx
Traceback (most recent call last):
  File "./temps_average_3.py", line 15, in <module>
    for line in file:
NameError: name 'file' is not defined

because the code depends on the open statement working
You need to put all the code that depends on the file object try/exceptstatement

Different Exception Types

When a runtime error occurs the Python interpreter creates an exception object
When this happens the interpreter is said to raise an exception
The exception mechanism has three purposes
- To allow the interpreter to handle the runtime error
- To give the programmer some idea of what went wrong
- To give the programmer the chance to do something about it
There is more than one way to cause a runtime error
So different exception objects are created for different types of exceptions

Common Exception Types

When you try to open a file that does not exists you get a FileNotFoundError exception object

>>> open("xxx.txt","r")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: 'xxx.txt'

If you try to open a file for which you do not have permission you will get a PermissionError object

file = open("test.txt","r")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
PermissionError: [Errno 13] Permission denied: 'test.txt'

If a conversion function gets the wrong type of argument a ValueError object is created

>>> number = float(input("Number: "))
Number: five
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'five'
>>> number = float(input("Number: "))
Number: 5..4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: could not convert string to float: '5..4'

If you import a module that doesn't exist you get an ImportError object

>>> import foo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named 'foo'

If you try to divide a number by zero the interpreter will create a ZeroDivisionError exception object

>>> print(5/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

Handling More Than One Type of Exception

You can have many except clauses, one for each exception type

The format is

try:
    STATEMENT
    ...
except EXCEPTION_TYPE_1:
    STATEMENT
    ...
except EXCEPTION_TYPE_2:
    STATEMENT
    ...
...

You can catch as many exception types as you want

We can use this format to write an improved version of the function

def open_file_reading():
    while True:
        filename = input("Filename: ")
        try:
            file = open(filename, "r")
            return file
        except FileNotFoundError:
            print("Cannot find", filename)
        except PermissionError:
            print("You do not have permission to read", filename)

The `else` Clause

A try/except statement can also have an else clause
The statements in this block will be run if try block code does not cause a runtime error
You should put all code that need the statements in the try clause to work inside an else clause

Like this

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)

The `finally` Clause

There is another type of clause that can occur a try/except statement
It has the format
```
finally:
    STATEMENT
    ....
```
The statements in a finally clause will always be executed
It does not matter whether a runtime error occurs
We will not have to use this feature of Python
But in more advanced scripts it can be useful
The finally clause allows you to clean up any lose ends no matter what happens when the script is run

New Material

Working with Collections of Data

A variable holds one piece of information
For simple tasks, that's all we need
But for many tasks we need to work with collections of data
For example a list of all the students in a class

Or all the scores on a quiz like this

>>> scores = '100 85 76 60 78 65 55 88'

I can use the split method to get the each score
But I would have to create a variable for each score in a multiple assignment statement

Like this

score_1, score_2, score_3, score_4, score_5, score_6, score_7, score_8 = scores.split()

To add the scores I would have to mention each and every variable

total = score_1, score_2, score_3, score_4, score_5, score_6, score_7, score_8

But I have classes with up to 65 students
Clearly there has to be a better way

Sequences

We need something that can hold more than one value
Python has a class of data types for this purpose called sequences
Sequences are Python data types that hold multiple values stored one right after the other in RAM
Sequences are a series of values in a particular order
We will study two new sequence data types
- lists
- tuples
Lists are sequences whose values can be changed
Tuples are sequences that cannot be changed
A list or tuple is an object
This means they have methods
These methods make it easy to work with the values inside the object

Lists

Lists hold many values in a specific order
The values are called elements
They are stored in RAM one right after the other
You can change any value in the list
You can also change their order
And add and remove items from the list
We can create a list literal by placing a series of values inside square brackets

There must be a comma between each value

>>> even_numbers = [2, 4, 6, 8, 10]
>>> even_numbers
[2, 4, 6, 8, 10]

Here is what this looks like in memory

Lists can contain strings

>>> courses = ["IT 244", "IT 341", "IT 116"]
>>> courses
['IT 244', 'IT 341', 'IT 116']

They can hold float values

>>> expenses = [37.55, 21.25, 32.00]
>>> expenses
[37.55, 21.25, 32.0]

They can hold boolean values

>>> results = [True, False, True]
>>>results
[True, False, True]

They can also hold values of different types

>>> python_class = ["IT 116", 32, "McCormack 2-621"]
>>> python_class

You can even have lists of lists

>>> lists = [ numbers, results, expenses]
>>>  lists
[[5, 8, 2, 9, 7, 6, 3], [True, False, True], [37.55, 21.25, 32.0]]

The `list` Function

List literals are only one way to create lists
Another way is to use the built-in function list
list is a conversion function just like int and str
list turns objects that are collections of things into a list
It turns out that strings are also sequences
A string is a collection of characters one right after the other

So we can use list on strings

>>> name = "Glenn"
>>> characters = list(name)
>>> characters
['G', 'l', 'e', 'n', 'n']

Why is there a separate data type for strings?
Because string objects have methods that only work on characters
```
>>> name.upper()
'GLENN'
>>> name.lower()
'glenn'
```

Operators That Work on Objects

Operators are special characters that perform some action
Usually that action is to create a new value
They work on values that are called operands
Every data type has its own set of operators
For numbers, we have the arithmetic operators
- +
- -
- *
- /
- //
- %
- *
Sequences have only two operators
- +
- *

Concatenating Lists

The concatenation operator that works on strings

>>> name = "Glenn" + " " + "Hoffman"
>>>  name
'Glenn Hoffman'

also works on lists

>>> n1 = [1,2,3]
>>> n2 = [4,5,6]
>>> n1 + n2
[1, 2, 3, 4, 5, 6]

That because both strings and lists are sequence data types

But it only works when both the operands are the same data type

>>> n1 + name
Traceback (most recent call last):
  File "<stdin>", line 1, in Monday
TypeError: can only concatenate list (not "str") to list

The Repetition Operator

You cannot subtract two list

>>> n2 - n1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'list' and 'list'

nor can you divide them

>>> n1 / n2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for /: 'list' and 'list'

But you can use the * on lists
When you do the 1st operand is a list and the 2nd is an integer

The result is a new list with multiple copies of the elements of the original list

>>> zeros = [0] * 5
>>> zeros
[0, 0, 0, 0, 0]
>>> numbers = [1, 2, 3] * 3
>>> numbers
[1, 2, 3, 1, 2, 3, 1, 2, 3]

The repetition operator also works on strings
```
>>> "Go " * 3
'Go Go Go '
```

Using a `for` Loop with Lists

A for loop will work with a list

>>> numbers = [1, 2, 3, 4, 5]
>>>for n in numbers:
...   print(n)
...
1
2
3
4
5

When we use a loop to work with each value in a list we are said to iterate over that list

We can also use a for loop with strings

>>> team = "Red Sox"
>>> for char in team:
...     print(char)
... 
R
e
d
 
S
o
x
>>>

Indexing

What if we wanted to get the 3rd element in a list?

We can do this with a for loop but it is very cumbersome

>>> even_numbers = [2, 4, 6, 8, 10]
>>> count = 0
>>> for n in even_numbers:
...   count += 1
...   if count == 3:
...      third_element = n
... 
>>> third_element
6

There is an easier way
All elements in a list are arranged one right after the other
This means they have a definite order
Each element's place in line can be specified by an integer
The integer that specifies an element's place is a list is called an index
Unfortunately, index numbers do not start at 1
Indexes start at 0
This is called zero-based indexing
This means that the first element in a list has an index of 0
The second has an index of 1 and so on
It also means that the index of the last element is one less than the length

To get a particular element we use the [ ] operator
We put this operator right after the name of the list variable

The index goes inside the square brackets

>>> even_numbers[0]
2
>>> even_numbers[1]
4
>>> even_numbers[2]
6

If you use an index that is too big you will get an IndexError exception

>>> even_numbers[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

The `len` Function

The built-in function len will return the length of any sequence

>>> even_numbers = [2, 4, 6, 8, 10]
>>> len(even_numbers)
5
>>> len("foo")

We can use len with range to iterate through a list

for i in range(len(even_numbers)):
...   print(even_numbers[i])
... 
2
4
6
8
10

Now you see why range works the way it does
With one argument, the first integer in the list it creates is 0
Which is the the index of the first element
The the last number is one less then the length of the list
Which is the index of the last element

Changing Elements Using Indexes

Lists are said to be mutable
That means they can be changed
This can only be done using indexes
If we have a list of numbers
```
numbers = [1, 4, 6, 8]
```

We can change the first number like this

>>> numbers[0] = 2
>>> numbers
[2, 4, 6, 8]

We can use indexes in a for loop to change every element inside a list

>>> for i in range(len(numbers)):
...   numbers[i] += 1
... 
>>> numbers
[3, 5, 7, 9]

Being a Good Citizen

The first of the general ethical principles of the ACM is

Contribute to society and to human well-being, acknowledging 
that all people are stakeholders in computing

I think this breaks down into two responsibilities
- Make the world a better place
- Make sure what you do benefits everyone
Every day technology makes our lives easier
Weather reports help us plan our day
Remote connections allow us to work from anywhere on the planet
We can get detailed directions to anywhere we want to go
We are lucky to live when we do and enjoy these conveniences
We enjoy these benefits because the people who came before us made it happen
We owe them a debt
But the debt is not to them, but to those who come after us
We repay our debt by working on improvements that will benefit future generations
But we must be sure that the benefits go to all levels of society
Not just to the affluent and well-connected
Certain groups do not enjoy the same benefits of technology as the majority
IT work is well paid
And those who work in it tend to associate with other well paid people
This can make the important needs of some people invisible
We must not let our good fortune blind us to the needs of others
This is particularly important now when immigrants are vilified
When people of color are considered less than human by some
If you are not part of the solution, you are part of the problem

Do No Harm

The second ACM general ethical principle is
```
Avoid harm
```
As examples of harm the ACM gives
- Unjustified physical or mental injury
- Unjustified destruction or disclosure of information
- Unjustified damage to property, reputation, and the environment
Social networks have been used to bully and harass people, especially women and minorities
IT skills have been used for these purposes
They have also been used to invade people's privacy and reveal personal information
Even seemingly neutral activities can have bad consequences
Bitcoin mining uses as much power as a small country according to some estimates

Today's Topics

Review

New Material

Homework 10

Review

The Code in the try Clause

Different Exception Types

Common Exception Types

Handling More Than One Type of Exception

The else Clause

The finally Clause

New Material

Working with Collections of Data

Sequences

Lists

The list Function

Operators That Work on Objects

Concatenating Lists

The Repetition Operator

Using a for Loop with Lists

Indexing

The len Function

Changing Elements Using Indexes

Being a Good Citizen

Do No Harm

Attendance

The Code in the `try` Clause

The `else` Clause

The `finally` Clause

The `list` Function

Using a `for` Loop with Lists

The `len` Function