Strings as a Compound Data Type

Strings as a Sequence of Characters

• we can treat a string as a sequence of characters
• each character can be referred to by its place in the string
• this place is a numeric value called an index
• an index specifies the position of an item in an ordered collection (in the context of strings, a sequence of characters)
• indexes start at 0, not at 1
• consequently, the first character of a string is at index 0
• for example, in the string "hi", h is at index 0, i is at index 1

String Indexes

Let's take the string "cool cat!". What is the index of the first 'c'? What character is at index 1. How about index 4? →

"""+---+---+---+---+---+---+---+---+---+
   | c | o | o | l |   | c | a | t | ! |
   +---+---+---+---+---+---+---+---+---+"""

"""+---+---+---+---+---+---+---+---+---+
   | c | o | o | l |   | c | a | t | ! |
   +---+---+---+---+---+---+---+---+---+
   | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
   +---+---+---+---+---+---+---+---+---+"""

The Last Index

What index is the last character of each of these strings? →

1. "foo"
2. "hi"
3. "!"

Some More Index Exercises

1. What's the index of 'h' in "hello"?
2. What's the index of 'o' in "hello"?
3. What's the index of the second 'l' in "hello"?
4. What's the letter at index 0 in "hi there."?
5. What's the letter at index 2 in "hi there."?

Indexing Into a String

You can reference a specific character in a string (indexing) by:

• using the index (an integer)
• enclosed by square brackets
• immediately following the string
• returns a new string consisting of only that one character
• note that the index or string can be variables or expressions!

a_string[an_index]

Indexing Examples

>>> "hello"[0]
'h'
>>> animal = "aardvark"
>>> animal[4]
'v'
>>> idx = 7
>>> animal[idx]
'k'
>>> 

Indexing Exercises

What does the following code output. Let's walk through it line by line. →

idx = 3
animal = "moose"
print(animal[idx])
print(animal[idx - 3])
print("animal"[1])
print("animal"[5])

s
m
n
l

Negative Indexes Also Work

-1 is the index of the last letter, -2, second to last, etc. …What does the following program output? Let's go through it line by line. →

idx = -3
animal = "cow"
print(animal[-1])
print(animal[idx])
print(animal[idx + 3])

w
c
c

One Last Note About Indexing

• strings are not mutable
  • you can read values by indexing into a string
  • however, you can't change values
  • consequently, you can't set an index equal to another character
• let's see what happens when we try to change a character at an index using the assignment (=) operator →

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

Using Every Character in a String

What if we want to do something to each character in a string? Manually and explicitly using indexes would be time consuming! What if I wanted to:

• count the number of exclamation points I used in my slides!?
• recombine letters, but change vowels into numbers for a variant of "L33T SP34K"

Looping Over Each Character

We can iterate over every character that's in a string.

• we've used a construct that lets us iterate over every element in an ordered sequence
• what was that construct?→

# for loops!
for c in "hello":
  print(c)

For Loops and Strings

my_crazy_string = "oh, my!"
for c in my_crazy_string:
  print(c)

• for loops allow us to iterate over every char in a string.
• similar to looping over a sequence of #'s
• variable specified in loop represents the current char
• the loop continues until there are no letters left
• what would the above code print out? →

o
h
,
m
y

Write a Program That Iterates Over a String

Try implementing this program:

• use a for loop to go over every letter in "jetpack"
• for each letter, print out the letter with a suffix of "am" appended it

word = "jetpack"
suffix = "am"
for c in word:
	print(c + suffix)

Letter in Word

Try implementing this function! (there's something that's built-in to Python that does this, and we'll see it later)

• implement a function called letter_in_word
• it should take two arguments, a letter and a word
• it should return True if the letter is in the word, otherwise, return False
• use assert on a True case and on a False case

def letter_in_word(letter, word):
	result = False
	for c in word:
		if c == letter:
			result = True
			break
	return result

assert True == letter_in_word('c', "chihuahua"), "letter is in word"
assert False == letter_in_word('x', "chihuahua"), "letter is not in word"

Slicing

You can also retrieve a substring from another string.

• you can get a section of consecutive characters from a string
• example: "ana" is a substring in the string "banana"

This is done using slicing. Slicing syntax works as follows:

>>> "placate"[3:6]
'cat'

Slicing Syntax

Looking at the slicing code again:

>>> "placate"[3:6]
'cat'

The general case is:

some_long_string[m:n]

• m is the start index and n is the end index.
• the resulting substring starts at m, and goes up to, but does not include n

Substring Exercises

Write the slice to pick out the following substring from the original string:

sentence = "hi bob!"
#           0123456

1. hi
2. bob!
3. bob

sentence[0:2]
sentence[3:7]
sentence[3:6]

Some Slicing Tricks

• leaving out the first index (before the colon - m) starts at the beginning of the string
• leaving out the second index (after the colon - n), ends at the end of the string
• if the second index, if n is bigger than the length of the string, up to the end is sliced

"eggs and ham"[:4] #eggs
"eggs and ham"[9:] #ham
"eggs and ham"[9:100] #ham

An Easier Way to Tell if a Letter is in a Word

in and not in or operators that each take two arguments. They will test the membership of an element in a collection/sequence.

• in the case of strings, that's character in word
• in
  • returns True if element on left is in element in right
  • False otherwise
• not in
  • returns True if element on left is not in element in right
  • False otherwise

In / Not In Examples

>>> 'c' in "cat"
True
>>> 'c' not in "cat"
False

Some Potential Exercises

• is_digit
  • accepts a string
  • returns True if every character in a string is numeric (0 through 9)
  • hint: use in and or not in… and the string "0123456789"
• remove_vowels
  • accepts a string
  • returns a string without any vowels in it
  • hint: build a string by accumulating characters