CP104 Notes: Strings

Topics

• String Indexes
• Substrings / Slices
• Traversing Strings
• String Concatenation
• String Methods
• String Case Methods
• String Tests
• String Trimming
• Searching Strings
• String Comparators
• The in Operator

String Indexes

Individual characters in a string may be accessed in exactly the same way that individual elements of a list are accessed: use an integer index to access a character. Unlike lists, strings are immutable, so you cannot change an individual character of a string by referring to its index. Some example:

"Some sentence"

"e"

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

Substrings / Slices

A substring, or slice of a string is accessed by assigning two indexes separated by a ":". (This is identical to list slices.) The values returned start with the first index up to, but not including, the second index. Indexes that are too small, too large, or left out default to 0 and the length of the list. Some examples:

"Some sentence"

"S"

"Some sentence"

"me sent"

"Some sentence"

"sentence"

""

""

Traversing Strings

Strings can be traversed - 'walked' through from one end to the other - in three ways, in much the same way that lists can be traversed. The following code shows how the contents of the list:

    
st = "David"

  

can be traversed:

• By index with a while loop:

          
  i = 0
  n = len(st)
  
  while i < n:
      print(st[i])
      i = i + 1
  
        

• By index with a for loop:

          
  for i in range(n):
      print(st[i])
  
        

• By value with a for loop:

          
  for c in st:
      print(c)
  
        

All three versions print the contents of st as:

D
a
v
i
d

Don't Do This:

    
for i in st:
    print(st[i])

  

i is being treated as though it is an index, but it's not. It is the same as the variable c in the previous example - it is actually a character in the string st. What is being done here is the equivalent of attempting to print:

st["D"]
st["a"]
st["v"]
st["i"]
st["d"]

which isn't going to work, because indexes have to be integers, so the loop dies on the first iteration. We strongly recommend that you use i as a variable name for string iteration when it is an index, but not when it is one of the characters in the string. Although you can use any variable name you like, using i for other than an index variable is potentially very confusing.

String Concatenation

Strings can be concatenated: we can to add strings together. Some examples:

          name1 = "David"
name2 = "Brown"
        

    
result = ""

while i < n:
    result = result + "*_"
    n += 1

  

String Methods

String methods are methods that can be applied to strings. The basic format is:

return_value = string.method()

Note that string method calls do not change the current string: rather they return a new string, as in this example:

          
upname = name.upper()
print(name)
print(upname)

        

David
DAVID

String Case Methods

There are a number of methods for altering string case:

Some examples:

"This is a sentence."

"THIS IS A SENTENCE."

"this is a sentence."

String Tests

There are a number of methods for testing the contents of a string.
These methods return True or False depending on the state of the string they are testing. These methods are:

Some examples:

"ABCs"

True

False

False

True

True

True

String Trimming

There are a number of methods for removing space characters from either side of a string:

Some examples:

          string = "       some  words          "
        

|       some  words          |

|some  words|

|       some  words|

|some  words          |

Searching Strings

Strings can be searched to see if they contain other strings or substrings. A substring is just another string that may or may not be part of another (usually larger) string. Search methods allow only part of the original string to be searched. This is shown by the syntax

(srch [, start[, end ]])

where srch is the string to search for, start is the starting index within the main string to begin searching, and end is the last index within the main string to search. This is equivalent to segmenting a string with the [start:end] segmentation syntax.

All counts and searches are case-sensitive. Counts and searches operate on non-overlapping substrings. Thus "Wooo!" contains the substring "oo" once, not twice. Note that find returns the index of location of the search string in the main string, not in any substring that may be specified.

Some examples:

1

1

2

0

"avi"

True

2

"v"

-1

"x"

String Comparators

Strings can be compared in the same way that any other objects can be compared in Python, with the <, <=, >, >=, ==, !=, in, not in operators. These operators return True or False. Strings are compared on the basis of the integer ASCII values of their component characters. For example, the letter "A" comes before "a" in the ASCII table. Some examples:

          upname = "DAVID"
name.upper() == upname
        

True

    
char = "i"
is_there = char in "David"

  

True

True

False

The in Operator

The in operator determines if a specific substring is found in a string or not, and returns True or False respectively. It is used as:

substring in string

Examples:

"David"

True

"a"

False

"z"

    
c = "vi"
found = c in st

  

True

    
b = 'Hello'
found = b in st

  

False