String Review

We know that a string is a sequence of characters.

String Indexing

• The index operator, “_[_]”, looks up a character in a string by its position:

  <string> [<index>]

• The index is an integer representing an offset from the beginning of the string.

• The character at an index is the one that “begins” at that offset.

'hello!' [0]  == 'h'
'hello!' [1]  == 'e'
'hello!' [2]  == 'l'
'hello!' [3]  == 'l'
'hello!' [4]  == 'o'
'hello!' [5]  == '!'

Negative Indices

• For convenience, you may specify a negative index.

• The index [-n] is just a shorthand for [len (<the_string>) - n].

• This has the effect of counting backward from the end of the string.

• Any position in a string can be specified by either a forward (i.e. non-negative) or a backward (i.e negative) index.

'hello!' [5]  == '!'
'hello!' [-1] == '!'
'hello!' [4]  == 'o'
'hello!' [-2] == 'o'
'hello!' [0]  == 'h'
'hello!' [-6] == 'h'

Index Bounds

In order to be valid index for a string s,

• a non-negative integer i must satisfy:

  0 <= i < len (s)

• a negative integer j must satisfy:

  - len (s) <= j < 0

• It is an error to provide an an out-of-bounds index:

  'hello!'[6]    #  IndexError: string index out of range

String Processing

Combining looping with indexing to process a string:

def reverse_string (s) :
    """
    signature: str -> str
    reverses a string
    """
    i  =  0             #  index counter
    acc  =  ''          #  result accumulator
    while i < len (s) :
        acc  =  s [i] + acc
        i  +=  1
    return acc

Substrings

• The slice operator, “_[_:_]”, returns the substring of a string between two indices:

  <string> [<start_index> : <stop_index>]

• The start index is the index of the first character included in the substring.

• The stop index is one greater than the index of the last character included in the substring.

• If the start index is equal to the stop index then the substring will be empty.

'hello!' [1 : 5]   ==  'ello'
'hello!' [4 : 6]   ==  'o!'
'hello!' [0 : 4]   ==  'hell'
'hello!' [-6 : -2] ==  'hell'
'hello!' [3 : 3]   ==  ''
'hello!' [0 : 6]   ==  'hello!'

Slice Shorthands

For convenience, you can omit either index:

• if the start index is omitted, then “0” is assumed.

• if the stop index is omitted, then “len (<string>)” is assumed.

'hello!' [  : 3] == 'hel'
'hello!' [3 :  ]  == 'lo!'
'hello!' [  :  ] == 'hello!'

Namespaces

• To organize them in a logical way and avoid name clashes, functions are organized into namespaces.

• To refer to a function from a namespace, we use dot notation:

  <namespace>.<function_name>

• We have already seen a few examples of this:

  turtle.forward (100)
  math.sqrt (16.0)

• Namespaces can hold global variables as well as functions:

  math.pi

String Functions

Many useful functions for strings are located in the “str” namespace, including:

str.isdigit (<string>)  #  predicate that returns True if all characters of a nonempty string are numerals

str.isalpha (<string>)  #  predicate that returns True if all characters of a nonempty string are letters

str.islower (<string>)  #  predicate that returns True if the string contains letters, all of which are lowercase

str.isupper (<string>)  #  predicate that returns True if the string contains letters, all of which are uppercase

str.lower (<string>)    #  returns the lowercase version of a string, leaving non-letters unchanged

str.upper (<string>)    #  returns the uppercase version of a string, leaving non-letters unchanged

Methods

• Method syntax is a different notation for calling a function.

• It is often used when one argument to a function is considered “principal”.

• Instead of writing:

  <namespace>.<function_name> (<principal_argument> , <other_arguments>)

• we write:

  <principal_argument>.<function_name> (<other_arguments>)

• Since Python knows the type of the principal argument, it can look up the right namespace automatically.

String Methods

All of the functions from the “str” namespace that we just saw can be written as methods:

'42'.isdigit ()                  #  same as str.isdigit ('42')

'hello!'.isalpha ()              #  same as str.isalpha ('hello!')

'hello!'.islower ()              #  same as str.islower ('hello!')

'??'.isupper ()                  #  same as str.isupper ('??')

'hello!'.upper ()                #  same as str.upper ('hello!')

'i LIKE to SHOUT'.lower ()       #  same as str.lower ('i LIKE to SHOUT')

String Comparisons

• The comparison operators (_<_ , _>_ , _<=_ , _>=_)

  are overloaded to compare strings in dictionary order,

• except that all uppercase letters come before any lowercase letters:

  'Zebra' < 'aardvark'     #  evaluates to True

• To do case-insensitive string comparisons, case-normalize before comparing:

  'aardvark'.lower () < 'Zebra'.lower ()    #  evaluates to True

in Operator

• The in operator (_in_) takes two strings and returns a boolean.

• It returns True just in case the left operand occurs as a substring (i.e. a slice) of the right operand.

'he' in 'hello!'  #  evaluates to True

'lo' in 'hello!'  #  evaluates to True

'ho' in 'hello!'  #  evaluates to False

'l'  in 'hello!'  #  evaluates to True

''   in 'hello!'  #  evaluates to True

''[0 : 0] == ''

for Loops

• It is common to write a loop over a string that processes each character in turn.

• For this task, there is a simplified looping construct, the for loop:

  for <loop_variable> in <string> :
      <loop_body>

• A for loop automatically assigns each character of the string to the loop variable in turn in the loop body.

• An equivalent while loop would be:

  i = 0                               #  initialize index counter
  while i < len (<string>) :
      <loop_variable> = <string> [i]  #  assign character at index counter to loop variable
      <loop_body>
      i += 1                          #  increment index counter

• A for loop relieves you of having to keep track of the index.

• But for loops can iterate in only one way: by moving forward through the string and processing each letter in turn,

  whereas while loops can iterate in any order and based on any boolean condition.

Example: Counting Vowels

def is_vowel (char) :
    """
    signature: str -> bool
    predicate for vowels
    """
    return (len (char) == 1) and (char.lower () in 'aeiou')

def count_vowels (text) :
    """
    signature: str -> int
    returns the number of vowels in a string
    """
    acc  =  0        #  number of vowels we've seen so far
    for char in text :
        if is_vowel (char) :
            acc  +=  1
    return acc

To Do This Week:

• Reading:

  • chapter 8: strings (9 pages)

• Come to lab on Thursday.

• Complete homework 4.