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

• 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)
• Contract for the Web

Final Exam

The final exam will be held on Tuesday, December 19th from 3:00 to 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 like those on the quizzes, along with questions asking you to write short segments of Python code.

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

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 Thursday, December 12th, will be a review session.

You will only be responsible for the material in that review session 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.

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, December 22nd, to submit the evaluation.

If you do not complete the course evaluation by this date, I will subtract 1 point from the your weighted score, which determines your grade.

Quiz 10

Let's review the answers to Quiz 10.

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
• The last chapter in our textbook dealt with two types of sequences
  • Lists
  • Tuples
• Strings are sequences where the elements are characters
• Sequences are objects
• 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
• 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 look in memory

• 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"
• This string consisted of the old string plus " 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
• If I keep doing 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 variable 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
  ...

• When a student asks me to test their script
• I run my test script on their code
• If their code works I replace "__" with "100"
• Four times a week, I run a special script on this file
• The script finds all entries with "__" before the name
• Then it runs the test script on that student's script
• 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
  • "HB" 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 the 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 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("Sox","Socks")
  'Red Socks'

Class Exercise