IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 23

Today's Topics

Review

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

New Material

Empty Lists
Slices
Leaving Out Indexes in a Slice
Skipping Elements in a Slice
The in Operator
List Methods
The append Method
The pop Method
The index Method
The insert Method
The sort Method
The reverse Method
The del Statement
The min and max Functions
Honesty and Trust
Fairness

Reading Assignment

You should read Chapter 8, More About Strings, from our textbook, Starting Out with Python, before next week's class.

Homework 11

I have posted homework 11 here.

This is the last homework assignment.

Quiz 8

The answers to Quiz 8 are posted here.

Let's take a look.

Review

Sequences

Sequences are Python data types that hold many values
The values are store one right after the other in RAM
Here are two new sequence data types
- lists
- tuples
Lists are sequences whose values can be changed
Tuples are sequences that cannot be changed

Lists

The values in a list are called elements
You can change any value in the list and change their order
You can also add and remove items from the list
We can create a list by placing a series of values inside square brackets

There must be a comma between each value

>>> numbers = [5, 8, 2, 9, 7, 6, 3]
>>> numbers
[5, 8, 2, 9, 7, 6, 3]

Here is what this looks like in memory

This is an example of a list literal
Lists can contain a value of any type
- Integers
- Floats
- Strings
- Booleans
Lists can also contain other lists

The `list` Function

list is a conversion function just like int and str
list turns objects that are collections of things into a list
Strings are sequences of characters in a specific order

list will work on strings

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

Operators That Work on Objects

Operators are special characters that perform some action
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

The Repetition Operator

You cannot divide two lists

>>> 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 first operand is a list and the second 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 loop loop through 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

The elements in a list have a definite order
Each element's place in line can be given by a number
This number 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 of the list

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

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

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]

New Material

Empty Lists

When calculating a total we created a variable called an accumulator and set its value to 0
What if we wanted to build a list from scratch?
We would need to start with an empty list
Then we could add elements to this list
We create an empty list using a list literal with nothing between the square brackets
```
>>> new_list = []
>>> new_list
[]
```
The empty list serves the same purpose that zero does for numbers
If we multiply any number by zero we still get zero
If we use the repetition operator on an empty list we still get an empty list
```
>>> new_list * 5
[]
```

Slices

Let's say we define the following list

>>> days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']

What if I wanted to create a new list with just weekdays?
That is, all the days except Sunday and Saturday
Python gives us a easy way to do this using a slice
A slice is new, smaller list created from another list

To create a slice you use the following format

LIST_VARIABLE[FIRST_INDEX:ONE_MORE_THAN_LAST_INDEX]

The trick to using list is remembering how to get the second index
The second index is not the index of the last element
It's the index of the element after the last element you want
Let's say we wanted to create a new list weekdays
The first element we want in our slice is "Monday" which has an index of 1
The last element we want is "Friday" which has an index of 5
Adding 1 to 5 we get 6

So we create our new list like this

>>> weekdays = days[1:6]
>>> weekdays
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

Here is another list

>>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

To get a slice from 2 to 8 we would write
```
digits[2:8]
[3, 4, 5, 6, 7, 8]
```
With zero-based indexing the index for 3 is 2
The index for 8 is 7
9 is the element after 8 and its index is 8

Leaving Out Indexes in a Slice

Python allows you to create a slice using only one index
If you leave out the first index, Python assumes the value is 0

In other words, the index of the first element

>>> days
['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
>>> days[:4]
['Sunday', 'Monday', 'Tuesday', 'Wednesday']
>>> digits
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> digits[:5]
[1, 2, 3, 4, 5]

If you leave out the second index Python uses the length of the list

So the the slice will end with the last element

>>> days[4:]
['Thursday', 'Friday', 'Saturday']
>>> digits[5:]
[6, 7, 8, 9, 0]

You can even leave out both indexes as long as you keep the :

In this case Python will return a slice that consists of the entire list

>>> days[:]
['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
>>> digits[:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

This is a great way to make a copy of a list

>>> daynames = days[:]
>>> daynames
['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']

Skipping Elements in a Slice

You can also skip elements when creating a slice
It works just like the 3rd argument to the range function

To use this feature you add a second : followed by a number

LIST_VARIABLE[FIRST_INDEX:ONE_MORE_THAN_LAST_INDEX:STEP_VALUE]

The STEP_VALUE works just like the range function
It is what we add to the index of the last element to get the next one
It is the difference between the index of any two elements in the original list

If we wanted to create a slice of all the even digits

>>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> digits[1:10:2]
[2, 4, 6, 8, 0]

Actually, I could leave out the second index
```
digits[1::2]
[2, 4, 6, 8, 0]
```

The `in` Operator

Operators are special characters that perform some action
The only operator we have seen so far have been symbols
- +
- -
- *
- /
- //
- **
- %
But operators can also be words
in is an operator that works on objects that are a collection of values
We use it like this
```
VALUE in LIST
```
The in operator returns True if the LIST contains VALUE

Otherwise it returns False

>>> digits
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> 1 in digits
True
>>> 11 in digits
False

Is is possible for a list to contain the same value many times
```
>>> l = [1, 2, 3, 3, 3, 4, 5, 6]
```
in will tell you that value is in a list
```
>>> 3 in l
True
```
But it will not tell you it is in there more than once

List Methods

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

Here are some of the more useful list methods

Method	Description
append(item)	Adds item to the end of the list
pop(index)	Removes the element at a given index from the list and returns the value. If called with no argument, it returns the last element and deletes it from 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)
reverse()	Reverses the order of the items in the list

The append Method

The append method adds a value to the end of a list
It takes one argument, the value you want to add
Is it probably the most frequently used list method
You can use the append method to create a list from scratch
First you create an empty list
```
>>> teams = []
>>> teams
[]
```
Then we can call the append method on this list using dot notation
```
>>> teams.append('Red Sox')
>>> teams
['Red Sox']
```

We can call this method as many times as we like

>>> teams.append('Orioles')
>>> teams.append('Blue Jays')
>>> teams.append('Rays')
>>> teams.append('Yankees')

Each new value is added to the end of the list

>>> teams
['Red Sox', 'Orioles', 'Blue Jays', 'Rays', 'Yankees']

The pop Method

The pop method does two things
- Removes an element from a list
- Returns the value of that element

It's argument is the index of the value to be removed

>>> numbs = [1, 2, 3, 4, 5]
>>> n = numbs.pop(0)
>>> n
1
>>> numbs
[2, 3, 4, 5]

If you leave out the index argument, pop removes the last element
```
>>> n = numbs.pop()
>>> n
5
>>> numbs
[2, 3, 4]
```

The index Method

The in operator will tell us if a list contains a value ...
but it won't tell us where that value is inside the list
```
>>> 'Red Sox' in teams
True
```
We can use the index method to do that
We give this method the value we are looking for as an argument

And it will return the index of that value

>>> teams.index('Red Sox')
0
>>>  teams.index('Blue Jays')
2

If the value we are looking for is not in the list we will get a ValueError exception

teams.index('Mets')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'Mets' is not in list

If the value occurs more than once, the index of the first element is returned
```
>>> >>> l = [1, 2, 3, 3, 5]
>>> l.index(3)
2
```

The insert Method

append always adds to the end of a list
To insert a value somewhere else we need insert
The method takes two arguments
- The index where the element should be inserted
- The value to be inserted there
insert puts the value at the index given and moves every element to its right over one position
```
>>> l1 = [1, 2, 3, 4, 5]
>>> l1.insert(2, 7)
>>> l1
[1, 2, 7, 3, 4, 5]
```

The sort Method

A list is mutable so we can add elements or remove them
But we can also change the order of the elements

This can be done with the sort method which takes no argument

>>> l2 = [9, 1, 0, 2, 8, 6, 7, 4, 5, 3]
>>> l2
[9, 1, 0, 2, 8, 6, 7, 4, 5, 3]
>>>l2.sort()
>>> l2
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

The reverse Method

The reverse method reverses the order of a list

>>> l3 = [5, 4, 3, 2, 1]
>>> l3.reverse()
>>> l3
[1, 2, 3, 4, 5]
>>> l3.reverse()
>>> l3
[5, 4, 3, 2, 1]

If you have a list of unsorted numbers and you want to sort them in descending order you first need to use sort
```
>>> l4 = [2, 5, 9, 1, 8, 6, 3, 7, 4]
>>> l4.sort()
>>> l4
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

Then use reverse

>>> l4.reverse()
>>> l4
[9, 8, 7, 6, 5, 4, 3, 2, 1]

The `del` Statement

List methods aren't the only things you can use to work with lists
You can delete elements from a list using the del statement
The format of a del statement looks like this
```
del LIST_VARIABLE[INDEX]
```
After the keyword del comes the list variable and the index inside square brackets

>>> l5 = [1, 2, 3, 4, 5, 6]
>>> del l5[2]
>>> l5
[1, 2, 4, 5, 6]

The min and max Functions

Two built-in functions can also be used with lists
They do not change the list but they return information about it
min returns the smallest value in a list
```
>>> l6
[1, 4, 5, 6]
>>> min(l6)
1
```
max returns the largest
```
max(l6)
6
```

Honesty and Trust

The third of the ACM ethical principles is
```
Be honest and trustworthy
```
Professionals depend upon their reputation
Would you go to an accountant who had been accused of embezzlement?
Or a doctor who was addicted to drugs?
IT professionals often have access to confidential data
And trade secrets
A company would be stupid to hire you if they could not trust you
Men could learn the address and phone number of attractive women
Dishonest employees could sell confidential information to competitors
Integrity is especially important for people working in security

Fairness

The fourth ACM ethical principle is

Be fair and take action not to discriminate

Technical knowledge gives us the power to help people
We have a moral obligation use this ability fairly
To do this, we must distinguish between two things
- Prejudice
- Unconscious Bias
Prejudice is "preconceived opinion that is not based on reason or actual experience"
In other words, coming to a conclusion about something before examining the evidence
Prejudice toward minorities is illegal in this country and many others
Most large companies have policies against this
This is done for both legal and practical reasons
Companies do not want to violate the law
And they don't want to alienate potential customers
Prejudice does occur in professional life
But unconscious bias is more prevalent
It is also harder to recognize
Prejudice is conscious
Unconscious bias is not
Unconscious biases are formed through life experiences
And the cultural context in which we live
The brain has two decision making systems, one slow and the other fast
The slow system allows us to think about problems and come to a well thought out decision
But some dangers come quickly
This is why we have a faster decision system as this video explains
This system is fast but not very smart or accurate
But you can train yourself to learn when this fast system kicks in
You can learn to stop it from making a biased decision