IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 27

Review

Strings Are Sequences
Accessing Characters With Indexing
Negative Numbers as Indexes
Using a for Loop with Strings
Strings Are Immutable
Garbage Collection
String Slicing

New Material

Microphone

Final Exam

The final exam will be held on Tuesday, December 17th from 3:00 - 6:00 PM.

The exam will be given in this room.

If for some reason you are not able to take the Final at the time it will be offered, you MUST send an email to me before the exam so we can make alternative arrangements.

The final will consist of questions taken from the Weekly Graded Quizzes, along with questions asking you to write short segments of Python code.

There is a link to the answers to the graded quizze on the class web page.

60% of the points on this exam will consist of questions from the Graded Quizzes.

You do not need to study a Class Quiz question if the topic is not mentioned in either the Midterm or Final review.

The remaining 40% will come from 4 questions that ask you to write some code.

To study for the code questions you should be able to

Write a function to create a list from a file
Write a function that changes a list
Write a function that performs a calculation using the elements of a list
Write a function performs a calculation on the characters in a string

A good way to study for the code questions is to review the Class Exercises, homework solutions and Class Notes.

The last class on Tuesday, December 10th, will be a review session.

You will only be responsible for the material in that review session, which you will find here, and the review for the Midterm, which you will find here.

Although the time alloted for the exam is 3 hours, I would expect that most of you would not need that much time.

The final is a closed book exam.

To prevent cheating, certain rules will be enforced during the exam.

Remember, the Midterm and Final determine 50% of your grade.

Course Evaluation

At the end of each semester we offer you the opportunity to say what you think about this course.

What have I done right?

What have I done wrong?

What can I do better?

You are not asked for you name.

So the submissions are anonymous.

I will not see your responses until after I have submitted grades for this course.

We collect this feedback through Course Evaluations.

I will use what you say to make this course better.

To complete the course evaluation, use the following link .

You have until Friday, May 24th, to submit the evaluation.

First IT Club Event

The new IT Club will hold it's first event today, at 3 PM in the Integrated Sciences Complex, Room 3300.

Jason Agress wil speak about his experiences in the IT industry.

This is a great chance to meet other IT students and expand your network.

Holiday food will be served.

You will find a poster for the event here.

Questions

Are there any questions before I begin?

Review

Strings Are Sequences

There are many different data types in Python
Some hold only one value
- Integer
- Float
- Boolean
Other data types hold more than one value
A sequence is a family of data types containing many values
The values are stored one right after the other
In previous class we talked about two types of sequences
- Lists
- Tuples
Strings are sequences where the elements are characters
Sequences are objects ...
so each sequence data type has its own set of methods

Accessing Characters With Indexing

The characters in a string have a definite order
This means we can use indexing to get a particular character
If we have a string
```
>>> team = "Red Sox"
```

We can use the [ ] operator to get a specific character
Inside the brackets we put an integer
```
>>> team[0]
'R'
```

Negative Numbers as Indexes

You can't use any number as an index
It must be an integer ...

and it cannot be longer than the length of the list minus 1

>>> letters = "abcde"
>>> len(letters)
5
>>> letters[4]
'e'
>>> letters[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

You can use negative numbers as indexes
A negative index is added to the length of the string
In practices this means that -1 is the index of the last character
-2 is the index of the second from last

And so on

>>> letters[-1]
'e'
>>> letters[-2]
'd'
>>> letters[-3]
'c'
>>> letters[-4]
'b'
>>> letters[-5]
'a'
>>> letters[-len(letters)]
'a'

Negative index values can be used with any sequence object

They can be used with lists

>>> numbers = [1, 2, 3, 4, 5]
>>> numbers[-1]
5

And with tuples

>>> values = (1, 2, 3, 4, 5)
>>> values[-1]
5

Using a `for` Loop with Strings

A for loop can iterate over a string

>>> for ch in team:
...   print(ch)
... 
R
e
d

S
o
x

This lets us write some interesting functions

We can count the number of times a character occurs in a string

>>> def character_count(string, char):
...    count = 0
...    for ch in string:
...        if ch == char:
...            count += 1
...    return count
... 
>>> character_count("Mississippi", "i")
4
>>> character_count("Mississippi", "s")
4
>>> character_count("Mississippi", "p")
2

We can also use a for loop to reverse a string

>>> def string_reverse(string):
...     new_string = ""
...     for ch in string:
...         new_string =  ch + new_string
...     return new_string
... 
>>> string_reverse("Mississippi")
'ippississiM'
>>> string_reverse("radar")
'radar'

Strings Are Immutable

Strings are immutable
You cannot change a string

But you can use one string to create another

>>> string_1 = "Red"
>>> string_1 = string_1 + " Sox"
>>> string_1
'Red Sox'

In the first statement above I created the string "Red"
The string variable string_1 points to this new string
Here is how things looked in memory after the first statement

When I wrote
```
string_1 += " Sox"
```
two things happened
First, I created a new string consisting of the characters in the first string and " Sox"
Second, the variable string_1 now points to this new string
Nothing points to the old string "Red"
But that string has not gone away
Here is the new memory situation

Garbage Collection

In the example above we have two strings in memory
- "Red"
- "Red Sox"

I could create still another new string from the second string

>>> string_1
'Red Sox'
>>> string_1 = "Go " + string_1
>>> string_1
'Go Red Sox'

Now I have three string in memory

But I can only work with the newest one ...
because that is the only one to which I have an object variable
I need the object variable to work with the object
If I keep making strings like this ...
I would run out of memory
In C, this would cause the program to crash
This is a type of bug called a "memory leak"
Of course memory cannot leak away
But if you keep creating new objects ...
you will eventually run out of memory the script needs to run
This does not happen in Python and most scripting languages
It also does not happen in Java
In these languages the interpreter does garbage collection
I works like this
The interpreter keeps a table of all objects in memory ...
and the variables that point to them
Every so often the interpreter looks at this table
It will then delete objects that have no variables pointing to them
So programs written in Python will never have a memory leak

String Slicing

A string that is contained inside another string is called a substring
We can use slices to create a substring
Slicing works with all sequence objects including strings
So if we have the following string
```
>>> team = "Boston Red Sox"
```
We can extract the city substring like this
```
>>> team[0:6]
'Boston'
```

Attendance

New Material

Testing Strings

I create a scoring sheet for each Class Exercise that looks like this

IT 116 Scores Class Exercise 24
======================================================
__  Elvis Barbosa
__  Eddie Beazer
__  George Boamah
__  Vincent Chen
...

There is a text file like this for each Class Exercise
Several times during the week I run my test script on students' code
If the student's script works ...
the code replaces "__" with "100" ...
minus, perhaps, a late penalty
If there is no script for the exercise
The "__" remains before their name
If the exercise has a problem, I replace the "__" with other strings
- "EE" if the script is not executable
- "HH" if the script lacks a working hashbang line
- "SS" if the script has syntax errors
- "XX" if there is some other problem with the script
- "II" if the script is incomplete
Another script reads the scoring sheet ...
and sends and email message to all students ...
who do not have a working script
All of this involves testing strings
Strings have a number of methods to make this easier

Testing Strings with `in` and `not in`

Operators perform an action using one or more values
Usually that action creates a new value
This makes them seem like functions
But they operate in a totally different manner
To understand why is beyond the scope of this course
The easiest way to test for one string inside a longer string ...
is to use the in operator

We first met the in operator when studying lists

>>> numbers = [1, 2, 3, 4, 5]
>>> 2 in numbers
True
>>> "foo" in numbers
False

You can use the in operator on a string

>>> team = "Red Sox"
>>> "R" in team
True
>>> "z" in team
False

But in works slightly differently with strings
The first operand does not have to be a single character

It can be any string

>>> "Red" in team
True
>>> "Reds" in team
False

not in also works with strings

>>> "Red" not in team
False
>>> "Reds" not in team
True

The operator is two words - not in
Though not is a logical operator it is not used that way here
We can use not as a logical operator with the in operator

But if we do it must come before first operand for in

>>> not "Red" in team
False
>>> not "Reds" in team
True

not in is a single operator that returns the opposite boolean value that in does

Using the `in` Operator on a File

Let's return to my script for Class Exercises
Often I cannot find a student's script or there some problem with it
In this case a warning script has to send the student an email
The script needs to know what message to send to each student
The message is determined by characters before the name
- "__" means the script is missing
- "EE" means the script is not executable
- "SS" means a syntax error
- "XX" means the script has an error
The script loops through the file
Looking for these strings with the in operator
The script creates an empty list for each of the problems above

Student names are added to the list for each problem

for line in file:
    if "__" in line:
        add to no script list
    elif "EE" in line:
        add to not executable list
    elif "SS" in line:
        add to syntax error list
    elif "XX" in line:
        add to error list

The words in brown are not Python statements
They are descriptions of what the code block does
The script then uses these lists to send the appropriate message ...
to each student

String Methods

Strings are objects
They have methods that operate on their characters
There are three general types of string methods
- Methods that test the values of strings
- Methods that return a new string different from the original
- Methods that search and replace strings

String Testing Methods

The string testing methods are all boolean methods
You can think of them as answering a question about the string

All their names begin with "is"

Method	Description
isalnum	Returns True if the string contains only alphabetic letters or digits and has a length of at least 1. Returns False otherwise.
isalpha	Returns True if the string contains only alphabetic letters and has a length of at least 1. Returns False otherwise.
isdigit	Returns True if the string contains only digits and has a length of at least 1. Returns False otherwise.
islower	Returns True if all of the alphabetic letters in the string are lowercase and has a length of at least 1. Returns False otherwise.
isspace	Returns True if the string contains only whitespace characters and has a length of at least 1. Returns False otherwise.
isupper	Returns True if all of the alphabetic letters in the string are uppercase and has a length of at least 1. Returns False otherwise.

isalnum

isalnum returns True when all the characters are letters or digits

>>> first_name
'Glenn'
>>> first_name.isalnum()
True
>>> digits
'0123456789'
>>> digits.isalnum()
True
>>> user
'alpha26'
>>> user.isalnum()
True

But it will return False if the string contains a space

>>> team = "Red Sox"
>>> team
'Red Sox'
>>> team.isalnum()
False

Or if it contains some other character

>>> jumble
'adbcd1234!@#$%'
>>> jumble.isalnum()
False

Or if the string is empty
```
>>> empty
''
>>> empty.isalnum()
False
```

isalpha

isalpha returns True when all the characters in the string are letters

>>> first_name
'Glenn'
>>> first_name.isalpha()
True
>>> digits
'0123456789'
>>> digits.isalpha()
False

Notice that all the characters must be letters

>>> user
'alpha26'
>>> user.isalpha()
False
>>> team
'Red Sox'
>>> team.isalpha()
False

It returns False when the string is empty
```
>>> empty
''
>>> empty.isalpha()
False
```

isdigit

isdigit returns True when all the characters are digits

 >>> digits
'0123456789'
>>> digits.isdigit()
True
>>> user
'alpha26'
>>> user.isdigit()
False

It returns False when the string is empty
```
>>> empty
''
>>> empty.isdigit()
False
```

islower

islower returns True ...

when all the alphabetic the characters are lower case

>>> noun
'watch'
>>> noun.islower()
True
>>> first_name
'Glenn'
>>>  first_name.islower()
False

Notice that all the string characters do not have to be letters

Only that all the letters must be lower case

>>> user
'alpha26'
>>> user.islower()
True
>>> jumble
'adbcd1234!@#$%'
>>> jumble.islower()
True

islower will return False if there are no letters in the string

>>> digits
'0123456789'
>>> digits.islower()
False
>>> empty
''
>>> empty.islower()
False

isupper

isdigit returns True ...

when all the alphabetic the characters are upper case

>>> league
'MLB'
>>> league.isupper()
True
>>> standard
'HTML 5'
>>> standard.isupper()
True
>>> team
'Red Sox'
>>> team.isupper()
False

It also returns False when no letters are present in the string

>>> digits
'0123456789'
>>> digits.isupper()
False
>>> empty
''
>>> empty.isupper()
False

isspace

isspace returns True when all the characters are whitespace
The whitespace characters are

Space " "

Tab "\t"

Newline "\n"
```
>>> whitespace
' \t\n'
>>> whitespace.isspace()
True
```

All the characters must be whitespace

>>> team
'Red Sox'
>>> team.isspace()
False

And the string cannot be empty
```
>>> empty
''
>>> empty.isspace()
False
```

String Methods That Produce New Strings

Strings are immutable, they can never change

But methods can create a new string from and old one

Method	Description
lower	Returns a copy of the string with all alphabetic letters converted to lowercase. Any character that is already lowercase, or is not an alphabetic letter, is unchanged.
upper	Returns a copy of the string with all alphabetic letters converted to uppercase. Any character that is already uppercase, or is not an alphabetic letter, is unchanged.
lstrip	Returns a copy of the string with leading characters removed. When run without an argument, it removes leading whitespace characters. When run with an argument, removes those characters.
rstrip	Returns a copy of the string with all trailing characters removed. When run without an argument, it removes tailing whitespace characters. When run with an argument, removes those characters.
strip	Returns a copy of the string with leading and trailing characters removed. When run without an argument, it removes leading and tailing whitespace characters. When run with an argument, removes those characters.

lower

lower creates a new string with all letters converted to lower case

>>> team
'Red Sox'
>>> team.lower()
'red sox'
>>> name
'Glenn'
>>> name.lower()
'glenn'
>>>  league
'NFL'
>>> league.lower()
'nfl'

lower does not affect any characters that are not letters

>>> jumble
'adbcd1234!@#$%'
>>> jumble.lower()
'adbcd1234!@#$%'
>>> user
'alpha26'
>>> user.lower()
'alpha26'

upper

upper creates a new string with all letters converted to uppercase

>>> name
'Glenn'
>>> name.upper()
'GLENN'
>>> noun
'leaf'
>>> noun.upper()
'LEAF'

upper does affect other characters

>>> jumble
'adbcd1234!@#$%'
>>> jumble.upper()
'ADBCD1234!@#$%'

lstrip

lstrip creates a new string with leading characters removed

With no argument, lstrip it removes leading whitespace

>>> str1
'   foo   '
>>> str1.lstrip()
'foo   '
>>> str2
'\t\tfoo\t\t'
>>> str2.lstrip()
'foo\t\t'
>>> str3
'\n\nfoo\n\n'
>>> str3.lstrip()
'foo\n\n'

With an argument, lstrip it removes those characters

The argument can be a single character

>>> str4
'---foo---'
>>> str4.lstrip("-")
'foo---'

Or more than one character

>>> str5 = "- - - foo- - - "
>>> str5.lstrip("- ")
'foo- - - '

rstrip

rstrip creates a new string with trailing characters removed

With no argument, lrstrip it removes trailing whitespace

>>> str1
'   foo   '
>>> str1.rstrip()
'   foo'
>>> str2
'\t\tfoo\t\t'
>>> str2.rstrip()
'\t\tfoo'
>>> str3
'\n\nfoo\n\n'
>>> str3.rstrip()
'\n\nfoo'

With an argument, rstripit removes those characters

The argument can be a single character

>>> str4
'---foo---'
>>> str4.rstrip("-")
'---foo'

Or more than one character

>>> str5
'- - - foo- - - '
>>> str5.rstrip("- ")
'- - - foo'

strip

strip is like combination of both rstrip and lstrip

Without an argument, strip it removes leading and trailing whitespace

>>> str1
'   foo   '
>>> str1.strip()
'foo'
>>> str2
'\t\tfoo\t\t'
>>> str2.strip()
'foo'
>>> str3
'\n\nfoo\n\n'
>>> str3.strip()
'foo'

With an argument. strip it removes those characters from both the front and end of the string

The argument can be a single character

>>> str4
'---foo---'
>>> str4.strip("-")
'foo'

Or more than one character

>>> str5
'- - - foo- - - '
>>> str5.strip("- ")
'foo'

String Search and Replace Methods

Another family of string methods can search for a substring ...

or to create a new string

Method	Description
endswith(substring)	The method returns True if the string ends with the substring.
startswith(substring)	The method returns True if the string starts with the substring.
find(substring)	The method returns the lowest index in the string where substring is found. If string is not found, the method returns −1.
replace(old_substring, new_substring)	The method returns a copy of the string with all instances of old_substring replaced by new_substring.

endswith(substring)

endswith(substring) returns True

When its argument is at the end of the string

>>> team = "Red Sox"
>>> team.endswith("Red")
False
>>> team.endswith("Sox")
True
>>> team.endswith(" Sox")
True

startswith(substring)

startswith(substring) returns True

When its argument is at the start of the string

>>> team
'Red Sox'
>>> team.startswith("Sox")
False
>>> team.startswith("Red")
True

find(substring)

find(substring) takes a string as its argument ...

and returns the index with the position of that string

>>> team
'Red Sox'
>>> team.find("Red")
0
>>> team.find(" ")
3
>>> team.find("Sox")
4
>>> nonsense
'foo bar bletch foo'
>>> nonsense.find("foo")
0

If the string is not found in the string find returns -1
```
>>> team.find("Yankees")
-1
```

replace(old_substring, new_substring)

replace takes two string arguments and returns a new string ...

where the first string is replaced by the second string

>>> nonsense
'foo bar bletch foo'
>>> nonsense.replace("foo", "bam")
'bam bar bletch bam'

If the first substring is not found, nothing is replaced

And the method returns the original string

>>> team = "Red Sox"
>>> team.replace("Socks", "Stockings")
'Red Sox'

Contract for the Web

Space	" "
Tab	"\t"
Newline	"\n"

Review

New Material

Final Exam

Course Evaluation

First IT Club Event

Questions

Review

Strings Are Sequences

Accessing Characters With Indexing

Negative Numbers as Indexes

Using a for Loop with Strings

Strings Are Immutable

Garbage Collection

String Slicing

Attendance

New Material

Testing Strings

Testing Strings with in and not in

Using the in Operator on a File

String Methods

String Testing Methods

isalnum

isalpha

isdigit

islower

isupper

isspace

String Methods That Produce New Strings

lower

upper

lstrip

rstrip

strip

String Search and Replace Methods

endswith(substring)

startswith(substring)

find(substring)

replace(old_substring, new_substring)

Class Exercise

Using a `for` Loop with Strings

Testing Strings with `in` and `not in`

Using the `in` Operator on a File