Before you keep reading...

Runestone Academy can only continue if we get support from individuals like you. As a student you are well aware of the high cost of textbooks. Our mission is to provide great books to you for free, but we ask that you consider a $10 donation, more if you can or less if $10 is a burden.

Support Runestone Academy Today

Before you keep reading...

Making great stuff takes time and $$. If you appreciate the book you are reading now and want to keep quality materials free for other students please consider a donation to Runestone Academy. We ask that you consider a $10 donation, but if you can give more thats great, if $10 is too much for your budget we would be happy with whatever you can afford as a show of support.

Support Runestone Academy Today

9.5. String Methods

We previously saw that each turtle instance has its own attributes and a number of methods that can be applied to the instance. For example, we wrote tess.right(90) when we wanted the turtle object tess to perform the right method to turn to the right 90 degrees. The “dot notation” is the way we connect the name of an object to the name of a method it can perform.

Strings are also objects. Each string instance has its own attributes and methods. The most important attribute of the string is the collection of characters. There are a wide variety of methods. Try the following program.

ss = "Hello, World" print(ss.upper()) tt = ss.lower() print(tt)

In this example, upper is a method that can be invoked on any string object to create a new string in which all the characters are in uppercase. lower works in a similar fashion changing all characters in the string to lowercase. (The original string ss remains unchanged. A new string tt is created.)

In addition to upper and lower, the following table provides a summary of some other useful string methods. There are a few activecode examples that follow so that you can try them out.

Method	Parameters	Description
upper	none	Returns a string in all uppercase
lower	none	Returns a string in all lowercase
capitalize	none	Returns a string with first character capitalized, the rest lower
strip	none	Returns a string with the leading and trailing whitespace removed
lstrip	none	Returns a string with the leading whitespace removed
rstrip	none	Returns a string with the trailing whitespace removed
count	item	Returns the number of occurrences of item
replace	old, new	Replaces all occurrences of old substring with new
center	width	Returns a string centered in a field of width spaces
ljust	width	Returns a string left justified in a field of width spaces
rjust	width	Returns a string right justified in a field of width spaces
find	item	Returns the leftmost index where the substring item is found, or -1 if not found
rfind	item	Returns the rightmost index where the substring item is found, or -1 if not found
index	item	Like find except causes a runtime error if item is not found
rindex	item	Like rfind except causes a runtime error if item is not found
format	substitutions	Involved! See String Format Method, below

You should experiment with these methods so that you understand what they do. Note once again that the methods that return strings do not change the original. You can also consult the Python documentation for strings.

ss = " Hello, World " els = ss.count("l") print(els) print("***" + ss.strip() + "***") print("***" + ss.lstrip() + "***") print("***" + ss.rstrip() + "***") news = ss.replace("o", "***") print(news)

food = "banana bread" print(food.capitalize()) print("*" + food.center(25) + "*") print("*" + food.ljust(25) + "*") # stars added to show bounds print("*" + food.rjust(25) + "*") print(food.find("e")) print(food.find("na")) print(food.find("b")) print(food.rfind("e")) print(food.rfind("na")) print(food.rfind("b")) print(food.index("e"))

Check your understanding

What is printed by the following statements?

s = "python rocks"
print(s.count("o") + s.count("p"))

• 0
• There are definitely o and p characters.
• 2
• There are 2 o characters but what about p?
• 3
• Yes, add the number of o characters and the number of p characters.

What is printed by the following statements?

s = "python rocks"
print(s[1] * s.index("n"))

• yyyyy
• Yes, s[1] is y and the index of n is 5, so 5 y characters. It is important to realize that the index method has precedence over the repetition operator. Repetition is done last.
• 55555
• Close. 5 is not repeated, it is the number of times to repeat.
• n
• This expression uses the index of n
• Error, you cannot combine all those things together.
• This is fine, the repetition operator used the result of indexing and the index method.

9.5.1. String Format Method

In grade school quizzes a common convention is to use fill-in-the blanks. For instance,

Hello _____!

and you can fill in the name of the person greeted, and combine given text with a chosen insertion. We use this as an analogy: Python has a similar construction, better called fill-in-the-braces. The string method format, makes substitutions into places in a string enclosed in braces. Run this code:

person = input('Your name: ') greeting = 'Hello {}!'.format(person) print(greeting)

There are several new ideas here!

The string for the format method has a special form, with braces embedded. Such a string is called a format string. Places where braces are embedded are replaced by the value of an expression taken from the parameter list for the format method. There are many variations on the syntax between the braces. In this case we use the syntax where the first (and only) location in the string with braces has a substitution made from the first (and only) parameter.

In the code above, this new string is assigned to the identifier greeting, and then the string is printed.

The identifier greeting was introduced to break the operations into a clearer sequence of steps. However, since the value of greeting is only referenced once, it can be eliminated with the more concise version:

person = input('Enter your name: ') print('Hello {}!'.format(person))

There can be multiple substitutions, with data of any type. Next we use floats. Try original price $2.50 with a 7% discount:

origPrice = float(input('Enter the original price: $')) discount = float(input('Enter discount percentage: ')) newPrice = (1 - discount/100)*origPrice calculation = '${} discounted by {}% is ${}.'.format(origPrice, discount, newPrice) print(calculation)

The parameters are inserted into the braces in order.

If you used the data suggested, this result is not satisfying. Prices should appear with exactly two places beyond the decimal point, but that is not the default way to display floats.

Format strings can give further information inside the braces showing how to specially format data. In particular floats can be shown with a specific number of decimal places. For two decimal places, put :.2f inside the braces for the monetary values:

origPrice = float(input('Enter the original price: $')) discount = float(input('Enter discount percentage: ')) newPrice = (1 - discount/100)*origPrice calculation = '${:.2f} discounted by {}% is ${:.2f}.'.format(origPrice, discount, newPrice) print(calculation)

The 2 in the format modifier can be replaced by another integer to round to that specified number of digits.

This kind of format string depends directly on the order of the parameters to the format method. There are other approaches that we will skip here, explicitly numbering substitutions and taking substitutions from a dictionary.

A technical point: Since braces have special meaning in a format string, there must be a special rule if you want braces to actually be included in the final formatted string. The rule is to double the braces: { { and }}. For example mathematical set notation uses braces. The initial and final doubled braces in the format string below generate literal braces in the formatted string:

a = 5
b = 9
setStr =  'The set is {​{ {},{} }​}.'.format(a, b)
print(setStr)

Unfortunately, at the time of this writing, the ActiveCode format implementation has a bug, printing doubled braces, but standard Python prints {5, 9}.

You can have multiple placeholders indexing the same argument, or perhaps even have extra arguments that are not referenced at all:

letter = """ Dear {0} {2}. {0}, I have an interesting money-making proposition for you! If you deposit $10 million into my bank account, I can double your money ... """ print(letter.format("Paris", "Whitney", "Hilton")) print(letter.format("Bill", "Henry", "Gates"))

What is printed by the following statements?

x = 2
y = 6
print('sum of {} and {} is {}; product: {}.'.format( x, y, x+y, x*y))

• Nothing - it causes an error
• It is legal format syntax: put the data in place of the braces.
• sum of {} and {} is {}; product: {}. 2 6 8 12
• Put the data into the format string; not after it.
• sum of 2 and 6 is 8; product: 12.
• Yes, correct substitutions!
• sum of {2} and {6} is {8}; product: {12}.
• Close: REPLACE the braces.

What is printed by the following statements?

v = 2.34567
print('{:.1f} {:.2f} {:.7f}'.format(v, v, v))

• 2.34567 2.34567 2.34567
• The numbers before the f in the braces give the number of digits to display after the decimal point.
• 2.3 2.34 2.34567
• Close, but round to the number of digits and display the full number of digits specified.
• 2.3 2.35 2.3456700
• Yes, correct number of digits with rounding!

You have attempted of activities on this page