Sequences and Loops
Contents
Sequences and Loops¶
Strings as a Sequence¶
Sequences are an abstract data type in Python that represent ordered collection of elements: e.g., strings, lists, range objects, etc.
Today we will focus on strings which are an ordered sequence of individual characters (type str
)
Consider for example:
word = "Hello"
'H'
is the first character of word,'e'
is the second character, and so on.In Computer Science, it is convention to use zero-indexing, so we say fact
'H'
is at index 0,'e'
is at index 1, and so on.
We can access each character of a string using indices in Python.
Accessing elements of a sequence using []
operator¶
word = 'Williams'
word[0] # character at 0th index?
'W'
word[3] # character at 3rd index?
'l'
word[7] # character at 7th index?
's'
word[8] # will this work?
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
Input In [5], in <cell line: 1>()
----> 1 word[8]
IndexError: string index out of range
Length of a Sequence¶
len()
function. Python has a built-in len()
function that computes the length of a sequence such as a string (or a list, which we will see in next lecture).
For example, len(‘Williams’) outputs 8
Thus, a string word
has (positive) indices 0, 1, 2, ..., len(word)-1
.
len("Williams")
8
len("pneumonoultramicroscopicsilicovolcanoconiosis") # longest word in English
45
Negative Indexing¶
Python also allows for negative indices, staring at -1
which is a handy way to refer to the last element of a non-empty sequence (regardless of its length).
Thus, a string word
has (negative) indices -1, -2, ..., -len(word)
.
place = "Williamstown"
place[-1]
'n'
len(place)
12
place[-12]
'W'
Slicing Sequences¶
Python allows us to extract subsequences of a sequence using the slicing operator [:]
.
For example, suppose we want to extract the substring Williams
from Williamstown
. We can use the starting and ending indices of the substring and the slicing operator [:]
.
place = "Williamstown"
# return the sequence from 0th index up to (not including) 8th
place[0:8]
'Williams'
place[5:7] # what will this return?
'am'
place[4:4] # what will this return?
''
place[1:] # if end index not provided, defaults to len()
'illiamstown'
place[:8] # if start index not provided, defaults to 0
'Williams'
place[:] # what will this do?
'Williamstown'
place[8:100:] # notice no IndexError when slicing!
'town'
place[-4:-1] # can also use negative indices to slice
'tow'
Slicing Sequences with Optional Step¶
The slicing operator [:]
optionally takes a third step parameter that determines in what direction to traverse, and whether to skip any elements while traversing and creating the subsequence.
By default the step is set to +1 (which means move left to right in increments of one).
We can pass other step parameters to obtain new sliced sequences; see examples below.
place = "Williamstown"
place[:8:1] # start is 0, end is 8, step is +1
'Williams'
place[:8:2] # start is 0, end is 8, step is +2
'Wlim'
place[::2] # start is 0, end is 12, step is +2
'Wlimtw'
place[-1:-4:-1]
'nwo'
Nifty Way to Reverse Sequences¶
Using a negative value for the step parameter provides a nifty way to reverse sequences.
For example, to reverse a string, we can set the optional step parameter to -1
.
place[::-1] # reverse the sequence
'nwotsmailliW'
place[::-2] # step of 2 in reverse order
'nosali'
place[8:-13:-1] # notice how start and end are used with a negative step
'tsmailliW'
Testing membership: in
operator¶
The in
operator in Python returns True
or False
and is used to test if a given sequence is a subsequence of another sequence.
For example, we can use it to test if a string is a substring of another string (a substring is a contiguous sequence of characters within a string, e.g. Williams
is a substring of Williamstown
)
'Williams' in 'Williamstown'
True
'W' in 'Williams'
True
'w' in 'Williams' # capitalization matters
False
'liam' in 'WiLLiams' # will this work?
False
lower()
and upper()
string methods¶
In addition to functions, Python provides several built-in methods for manipulating strings. Method are like functions but must be called using dot notation on specific strings. We can ignore or manipulate case of strings, using the .lower()
and .upper()
string methods, which return a new string with the appropriate case.
message = "HELLLOOOO...!!!"
message.lower() # leaves non-alphabetic characters the same
'hellloooo...!!!'
song = "$$ la la la laaa la $$..."
song.upper()
'$$ LA LA LA LAAA LA $$...'
isVowel
function¶
Consider the two isVowel
functions below that take a character as input and returns whether or not it is a vowel. The second one is simpler than the first and takes advantage of both the .lower()
string method and in
string operator.
def oldIsVowel(c):
"""isVowel function"""
return (c == 'a' or c == 'e' or c == 'i' or c == 'o' or c == 'u'
or c == 'A' or c == 'E' or c == 'I' or c == 'O' or c == 'U')
def isVowel(char):
"""Simpler isVowel function"""
c = char.lower() # convert to lower case first
return c in 'aeiou'
oldIsVowel('A')
True
isVowel('z')
False
isVowel('u')
True
Towards Iteration: Counting Vowels¶
Problem. Using our isVowel()
function, let’s write a function countVowels()
that takes a string word as input and returns the number of vowels in the string (as an int).
def countVowels(word):
'''Returns number of vowels in the word'''
pass
Expected behavior:
>>> countVowels('Williamstown')
4
>>> countVowels('Ephelia')
4
Re-using functions. We will use isVowel()
to test individual characters of the string, rather than starting from scratch.
What do we need to do to solve this problem?
Test each character of the string to see if it is a vowel
If we encounter a vowel, we need to remember it (keep a
counter
for all vowels seen so far)
Attempt using Conditionals¶
Suppose we manually check each character of the string and update a counter if it is a vowel.
word = 'Williams'
counter = 0
if isVowel(word[0]):
counter += 1
if isVowel(word[1]):
counter += 1
if isVowel(word[2]):
counter += 1
if isVowel(word[3]):
counter += 1
if isVowel(word[4]):
counter += 1
if isVowel(word[5]):
counter += 1
if isVowel(word[6]):
counter += 1
if isVowel(word[7]):
counter += 1
print(counter)
3
Question. How good is this approach? Will it work for any word?
word = 'Banana'
counter = 0
if isVowel(word[0]):
counter += 1
if isVowel(word[1]):
counter += 1
if isVowel(word[2]):
counter += 1
if isVowel(word[3]):
counter += 1
if isVowel(word[4]):
counter += 1
if isVowel(word[5]):
counter += 1
if isVowel(word[6]):
counter += 1
if isVowel(word[7]):
counter += 1
print(counter)
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
Input In [43], in <cell line: 15>()
13 if isVowel(word[5]):
14 counter += 1
---> 15 if isVowel(word[6]):
16 counter += 1
17 if isVowel(word[7]):
IndexError: string index out of range
Takeaway. Downsides of this approach are many:
Manually checking every character is not generalizable to arbitrary strings
The checks are very repetitive (same for every character in the string): can we automate these repetitive checks?
Iteration over Sequences: for
loops¶
We can “iterate” over the elements of a sequence using a for
loop. A loop is a mechanism to repeat the same operations for an entire sequence.
Syntax of for
loop¶
for var in seq:
do something
var
above is called the loop variable of the for
loop. It takes on the value of each of the elements of the sequence one by one.
# simple example of for loop
word = "Williams"
for char in word:
print(char)
W
i
l
l
i
a
m
s
We often want to count or “accumulate” values as we iterate over a sequence. Consider this example that counts the number of characters in a string. Here count
is called an accumulation variable. Accumulation variables can be integers or strings.
# count length of string manually
count = 0 # initialize
for char in word:
count += 1
print(count)
8
Putting it all Together: countVowels
¶
Now, we are ready to implement our function that takes a string as input and returns the number of vowels in it.
def countVowels(word):
'''Takes a string as input and returns
the number of vowels in it'''
count = 0 # initialize the counter
# iterate over the word one character at a time
for char in word:
if isVowel(char): # call helper function
count += 1
return count
countVowels('Williams')
3
countVowels('Ephelia')
4
Notice that the for
loop does not need to know the length of the sequence ahead of time. In Python, the for
loop automatically finishes after the sequence runs out of elements, e.g., word
runs out of characters, even though we have not computed the length manually.
Tracing the loop. To observe how the variables char
and count
change state as the loop proceeds, we can add print statements.
def traceCountVowels(word):
'''Traces the execution of countAVowels function'''
count = 0 # initialize the counter
for char in word: # iterate over the word one character at a time
print('char, count: ('+ char + ' , ' + str(count) +')')
if isVowel(char):
print('Incrementing counter')
count += 1
return count
traceCountVowels('Williams')
char, count: (W , 0)
char, count: (i , 0)
Incrementing counter
char, count: (l , 1)
char, count: (l , 1)
char, count: (i , 1)
Incrementing counter
char, count: (a , 2)
Incrementing counter
char, count: (m , 3)
char, count: (s , 3)
3
traceCountVowels('Queue')
char, count: (Q , 0)
char, count: (u , 0)
Incrementing counter
char, count: (e , 1)
Incrementing counter
char, count: (u , 2)
Incrementing counter
char, count: (e , 3)
Incrementing counter
4
Summary. As you can see, the loop variable char
takes the value of every character in the string one by one until the last character. Inside the loop, we check if char
is a vowel and if so we increment the counter.
Exercise: countChar
¶
Define a function countChar
that takes two str
arguments: a character and a word, and returns the number of times that character appears in that word (an int).
def countChar(char, word):
'''Counts the number of times a character appears in a word, ignoring case'''
# try this on your own!
pass # command to use when no function body
countChar('a', 'Alabama')
countChar('E', 'Ephs')
countChar('o', 'Rhythm')
Exercise: vowelSeq
¶
Define a function vowelSeq
that takes a string word as input and returns a string containing all the vowels in word in the same order as they appear.
Example function calls:
>>> vowelSeq("Chicago")
'iao'
>>> vowelSeq("protein")
'oei'
>>> vowelSeq("rhythm")
''
def vowelSeq(word):
'''Returns the vowel subsequence in given word'''
vowels = "" # accumulation variable
for char in word:
if isVowel(char): # if vowel
vowels += char # accumulate characters
return vowels
vowelSeq("Chicago")
'iao'
vowelSeq("protein")
'oei'
vowelSeq("rhythm")
''