Overview

We’re going to take a closer look at lists and strings, particularly the methods that each data type has. Methods are like functions, but they belong to the data object, and they have access to the object’s information. Python provides many useful and powerful methods for manipulating strings and lists.

Key idea for strings: Strings are immutable, you cannot modify an existing string, but you can construct a modified copy of the string. Many string methods build new, modified versions of the original string.

Key idea for lists: Lists are mutable, you can modify an existing list. They can hold any kind of data, including numbers, strings, other lists and tuples, and even functions. Many list methods actually modify the list they apply to.

This activity will first ask you to try out some of the operations described in the reading, and then it will ask you to write a series of functions that operate on stings and lists.

The Github repository contains a starter code file, activ8.py. Add all your work to this file, as directed below and by the TODO comments in the file.

Review of string and list operators

String review: operators, selection, slicing, functions, loops

Earlier in the term you learned a number of tools to manipulate strings: the + and * operators, the selection operator and slicing (square bracket operations), len function, and the accumulator pattern for strings. Here you will practice writing functions that operate on strings, using the tools you already know.

String operators & functions

Example	Meaning
`len('foo')`	Returns the number of characters in its argument
`'foo' + 'bar'`	Concatenates the two strings together
`'foo' * 3`	Concatenates the string with itself the number of times given
`'mom' in s`	Checks if first string occurs in second string
`s[3]`	Returns the character at the given position, zero-based
`s[3:5]`	Returns a substring starting at 3 and ending before 5

Loops with strings

for loop over characters

string = "my string"
for ch in string:
    print(ch)

m
y
 
s
t
r
i
n
g

for loop over indices

string = "my string"
for i in range(len(string)):
     print(string[i])

m
y
 
s
t
r
i
n
g

String accumulator pattern

def copyStr(string):
    ansStr =  ""                 # initialize accumulator to empty string
    for c in string:
        ansStr = ansStr + c     # update ansStr
    return ansStr

Practice

Choose one of these functions to complete, until you have worked through the whole activity, then return and use the remaining functions for extra practice.

Try this to hand in: Practice using string operators, functions, and loops by completing one of the following two exercises. Do not use string methods here.

Create a Python function symbolPattern that takes 2 input parameters. The first, str, should be a string, the second, num, should be an integer. The function should build a new string where each character in the input string, str, is repeated num times. The new string should be returned. Use the accumulator pattern for strings as the base for this function. You will also need the string operators * and + to accomplish this task.

print(symbolPattern("*!*!", 5))
print(symbolPattern("@$&", 3))
print(symbolPattern("(*)", 4))

*****!!!!!*****!!!!!
@@@$$$&&&
((((****))))

Create a Python function firstVowel that takes a string as its input. It should use a loop to iterate over the string looking for vowels - ‘aeiou’. It should return the index of the first vowel in the string. The in operator is helpful here.

print(firstVowel("strings"))
print(firstVowel("myth busters"))
print(firstVowel("equal"))

3
6
0

Review of basic list operations

Earlier in the term you learned a number of tools to manipulate lists: the + and * operators, the selection operator (square brackets, used to select a value from the list) and list slicing, and the accumulator pattern for lists. Here you will practice writing functions that operate on lists, using the tools you already know.

Remember that strings and lists may be indexed from right to left with negative integers: -1 is the index of the rightmost element in a string or list.

Example	Meaning
`len([25, 12, 19])`	Returns the number of characters in its argument
`['a', 'b'] + ['c', 'd', 'e']`	Concatenates the two strings together
`[5, 3] * 3`	Concatenates the string with itself the number of times given
`'mom' in lst`	Checks if first string occurs in second string
`lst[3]`	Returns the character at the given position, zero-based
`lst[3:5]`	Returns a substring starting at 3 and ending before 5

Loops with lists

for loop over list elements

lst = ['cat', 'fish', 'dog', 'pig']
for val in lst:
    print(val)

cat
fish
dog
pig

for loop over indices

lst = ['cat', 'fish', 'dog', 'pig']
for i in range(len(lst)):
     print(lst[i])

cat
fish
dog
pig

List accumulator pattern

def perfectSquares(n):
    ansList =  []                  # initialize accumulator to empty list
    for i in range(n):
        ansList = ansList + [i*i]  # update ansList
    return ansList

Practice

Try this to hand in: For these problems use only list functions (len), operators (+, *, [ ], in). Do not use list methods yet.

Choose one of these functions to complete, until you have worked through the whole activity, then return and use the remaining functions for extra practice.

Create a Python function everyOther that takes a list as its input. It should build a new list that contains every other value from the original input list. The easiest solution is to use list slicing (look up list slicing to recall how it works), but you could also loop over the list or its indices and use an accumulator variable.

print(everyOther([1, 2, 3, 4, 5]))
print(everyOther(['d', 'e', 'f', 'g']))
print(everyOther([]))

[1, 3, 5]
['d', 'f']
[]

Create a Python function sumPositive that takes a list of numbers as its input. Your function should use a for loop to iterate over the values in the list. If the number is positive then it should be added to an accumulator variable that holds the number that is the sum.

print(sumPositive([-1, -3, 4, 2, -6, 6]))
print(sumPositive([-10, -20, -30]))
print(sumPositive([1, 1, 1, 1, 1, 1]))
print(sumPositive([]))

Modifying lists

Unlike strings, lists can be modified. This is powerful, but can also be dangerous. It means you have to be more careful with lists. If you pass a list to a function, and that function changes the contents of the list, that change is permanent and visible everywhere the list is visible.

NOTE: using a for loop to loop over a changing list is a bad idea!

The basic method for changing lists uses the selection and slicing operators. Try each of the following, and experiment with your own examples to change testList

testList = [1, 2, 3, 4, 5, 6]
print("line 2:", testList)
testList[3] = 105
print("line 4:", testList)
testList[0] = 99
print("line 6:", testList)
testList[4:6] = [25, 26]
print("line 8:", testList)
testList[1:3] = [-5]
print("line 10:", testList)

line 2: [1, 2, 3, 4, 5, 6]
line 4: [1, 2, 3, 105, 5, 6]
line 6: [99, 2, 3, 105, 5, 6]
line 8: [99, 2, 3, 105, 25, 26]
line 10: [99, -5, 105, 25, 26]

Note that the last modification actually changes the length of the list. You can also delete elements from a list using the del operator:

del testList[1]
print(testList)
del testList[3:5]
print(testList)

[99, 105, 25, 26]
[99, 105, 25]

Practice

Try this to hand in: Create a function changeStart that takes a value and a list as inputs. It should not build a new list. It should modify the input list by changing zeroth value to be the input value. Below is an example of what should happen:

tList = ['a', 'b', 'c', 'd', 'e', 'f']
changeStart('X', tList)
print(tList)

['X', 'b', 'c', 'd', 'e', 'f']

String and list methods

String methods

Your reading had a partial list of string methods. I recommend looking at the Python Documentation for String Methods for the complete list. I’ve broken down the list of (most) string methods by category below. Define the example strings below, and then try each of the string methods in the examples to see what it does.

s1 = "banana"
s2 = "FROG"
s3 = "Glimmer"
s4 = "The Man From Mars"

Capitalization-related

The methods here are used both to check on the capitalization of a string, and to change its capitalization. None of these take any inputs, but they do return values.

Method	Description
Method	Description
`islower`	Returns `True` if all characters in its string are lowercase and `False` otherwise
`isupper`	Returns `True` if all characters in its string are uppercase, and `False` otherwise
`istitle`	Returns `True` if the string is a title with every first character capitalized and no others, and it returns `False` otherwise
`capitalize`	Returns a copy of the string with its first character capitalized and the rest lowercase
`lower`	Returns a copy of the string with all characters lowercased
`upper`	Returns a copy of the string with all characters uppercased
`title`	Returns a copy of the string with the first character of each word capitalized and all the rests lowercased
`swapcase`	Returns a copy of the string with the case of each letter swapped: lower to upper and upper to lower