Python String Formatting Exercises

As you build Python applications that display output or generate reports, you'll frequently need to combine text with variables — such as showing usernames, prices, or formatted dates. Python provides multiple ways to format strings, including the `%` operator (old style), `.format()` method, and f-strings, which are considered the most modern and readable approach for string formatting in Python.

Consider the following code:

name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")

What does this example illustrate about Python’s string formatting capabilities?

The code will raise a syntax error because strings cannot contain expressions inside curly braces.

The f before the string indicates an f-string, which allows embedding variables directly inside the string using {}.

Python requires string formatting to be done using %s and %d only; f-strings are invalid.

The format() method must be used instead of f-strings to include variables inside strings.

The f before the string in print(f"...") indicates an f-string, which was introduced in Python 3.6. F-strings allow variables and even expressions to be embedded directly within curly braces {}. The result is both cleaner and faster than older methods like "%s" % value or .format().

In the code:

name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")

Python replaces {name} with "Alice" and {age} with 30, producing the output:

My name is Alice and I am 30 years old.

F-strings improve readability and reduce the chances of errors, especially when formatting multiple variables. They're widely used in modern Python codebases and recommended over older formatting styles unless compatibility with older Python versions is required.

What does this code print?

name = "Leah"
print("Hi, {}!".format(name))

Hi, Leah!

Hi, {name}!

{} Leah

name

The format() method replaces the {} placeholder with the provided argument. So "Hi, {}!".format(name) becomes "Hi, Leah!". The other options either treat the placeholder as a string or don’t format properly.

Which method is used to format numbers to two decimal places?

{:.1f}

{:2f}

{:.2f}

{:decimal2}

In Python formatting, {:.2f} is the correct syntax to round a float to 2 decimal places. For example, "{:.2f}".format(3.14159) results in "3.14". The other options are either incorrect formats or round to only 1 decimal.

What is the result of the following?

city = "Kyoto"
print(f"Welcome to {city}")

Welcome to city

Welcome to Kyoto

{city}

Welcome to

The f-string replaces the variable inside the braces with its actual value. So {city} becomes "Kyoto", making the final output: "Welcome to Kyoto".

Which function will center-align a string in a field of 10 characters?

"Test".center(10)

"Test".ljust(10)

"Test".rjust(10)

"Test".pad(10)

The center() method pads the string with spaces equally on both sides, centering it in the specified width. So "Test".center(10) would output something like ' Test '. The ljust() and rjust() methods align left and right respectively, and pad() does not exist.

What will the following code output?

value = 123.456
print("Formatted value: {:.1f}".format(value))

Formatted value: 123.46

Formatted value: 123.4

Formatted value: 123.5

Formatted value: 123.45

The format specifier {:.1f} rounds the floating-point number to 1 decimal place. Since 123.456 rounds to 123.5, that's the correct output. This is standard rounding behavior.

Which of these will print "Hello, Emma!" using the format() method?

print("Hello, {Emma}!".format())

print("Hello, {}!".format("Emma"))

print("Hello, Emma!".format())

print(format("Emma", "Hello, {}!"))

The format() method substitutes values into curly braces in the string. The correct syntax is "Hello, {}!".format("Emma"), which produces the intended output. The other options either contain incorrect syntax or are improperly ordered.

Which formatting style is used in this code?

name = "David"
print(f"Welcome, {name}")

Template strings

format() method

f-string

string interpolation using %

This is a classic example of an f-string, introduced in Python 3.6. It allows embedding expressions inside curly braces within string literals by prefixing the string with an f. It’s more concise and readable compared to older formatting styles like % or format().

How can you right-align the word "Magic" within 10 spaces using string formatting?

print("{:>10}".format("Magic"))

print("{:<10}".format("Magic"))

print("{:^10}".format("Magic"))

print("{:#10}".format("Magic"))

The format specifier {:>10} means "right-align the string in a field of width 10". The result will be ' Magic' (5 spaces, then 'Magic'). Other options either left-align, center, or use an invalid symbol (#).

What will the output of this be?

a, b = 3, 7
print(f"Sum of {a} and {b} is {a + b}")

Sum of {a} and {b} is {a + b}

Sum of 3 and 7 is 10

Sum of a and b is a + b

3 + 7 = 10

f-strings evaluate the expressions inside curly braces. Here, {a} is replaced with 3, {b} with 7, and {a + b} with 10. So the result is: "Sum of 3 and 7 is 10".

What will be the output of the following code?

name = "John"
age = 25
print("Name: {}, Age: {}".format(name, age))

Name: John, Age: 25

Name: name, Age: age

Name: John, Age: 25, Age: 25

Name: {}, Age: {}

The format() method replaces the curly braces with the provided values in order. In this case, "Name: {}, Age: {}".format(name, age) will replace {} with "John" for the name and "25" for the age. So the output will be: "Name: John, Age: 25". Other options either don't replace values or misplace them.

Which of the following will correctly format a floating-point number to show 4 decimal places?

"{:.4f}".format(3.14159265359)

"{:.4f}".format(3.1415)

"{:.4}".format(3.14159265359)

"{:.4f}".format(3.14)

To round a float to 4 decimal places, the correct format specifier is {:.4f}. This ensures that the floating-point number is represented with exactly four digits after the decimal. In this case, "{:.4f}".format(3.14159265359) results in "3.1416" (rounded). Other options either use incorrect specifiers or round improperly.

Which of the following prints the value of pi = 3.141592653589793 with exactly 2 digits after the decimal point?

print(f"Pi value: {pi:.2f}")

print(f"Pi value: {pi:2.2f}")

print(f"Pi value: {pi:2.4f}")

print(f"Pi value: {pi:.3f}")

f-strings allow for precise formatting, and the format specifier {pi:.2f} ensures that the value of pi is rounded and displayed with exactly 2 decimal places. In this case, 3.141592653589793 becomes 3.14. The other options use incorrect widths or more decimal places than required.

What will this code print?

a = 5
b = 7
print("The product of {} and {} is {}".format(a, b, a * b))

The product of 5 and 7 is 35

The product of a and b is a * b

The product of 5 and 7 is a * b

The product of 5 and 7 is 12

In this code, the format() method is used to replace the curly braces with values. The first {} is replaced by a, the second {} by b, and the last one by the product a * b, which equals 35. Therefore, the output will be: "The product of 5 and 7 is 35". The other options either miss the proper variable formatting or provide incorrect results.

Which code snippet correctly aligns a string to the center in a field of 15 characters?

print("{:15}".format("Center"))

print("{:0^15}".format("Center"))

print("{:^15}".format("Center"))

The format specifier {:^15} means "center-align the string in a field of width 15". This ensures that "Center" is centered in the available space. The result will look like: ' Center '. The other options either align left or use incorrect padding.

What is the output of the following code?

x = 1234
y = 5678
print(f"{x:,} and {y:,}")

1234 and 5678

1,234 and 5,678

1,234 and 5678

1,234 and 5,678.00

The format specifier {:,} is used to add commas as thousand separators. The first value 1234 becomes 1,234 and the second value 5678 becomes 5,678. Hence, the output is: "1,234 and 5,678".

What will this code print?

a = 3.141592653589793
print(f"{a:.3f}")

3.141

3.142

3.14

3.143

The format specifier {:.3f} rounds the floating-point number to 3 decimal places. The number 3.141592653589793 is rounded to 3.142 because the fourth decimal digit (5) rounds the number up. Thus, the output is "3.142".

What will this code print?

a = "hello"
b = "world"
print(f"{a.upper()} {b.lower()}")

HELLO WORLD

hello WORLD

HELLO world

hello world

The upper() method converts the string "hello" to uppercase, resulting in "HELLO", while the lower() method converts the string "world" to lowercase, which remains "world". The output will therefore be: "HELLO world".

What will this code print?

x = 42
y = "The number is"
print(f"{y} {x:04d}")

The number is 42

The number is 0042

The number is 42.0

The number is 0042.0

The format specifier {x:04d} pads the number with leading zeros to make it 4 digits wide. The number 42 becomes 0042. Therefore, the output is: "The number is 0042".

What will this code print?

name = "Alice"
age = 30
print(f"Name: {name:<10}, Age: {age:>3}")

Name: Alice, Age: 30

Name: Alice , Age: 30

Name: Alice, Age: 30

Name: Alice , Age: 30

The format specifier {name:<10} left-aligns the string "Alice" in a field of 10 characters, and {age:>3} right-aligns the integer 30 in a field of 3 characters. The result is: "Name: Alice , Age: 30".

Python String Formatting Exercises

Consider the following code:

What does this example illustrate about Python’s string formatting capabilities?

What does this code print?

Which method is used to format numbers to two decimal places?

What is the result of the following?

Which function will center-align a string in a field of 10 characters?

What will the following code output?

Which of these will print "Hello, Emma!" using the format() method?

Which formatting style is used in this code?

How can you right-align the word "Magic" within 10 spaces using string formatting?

What will the output of this be?

What will be the output of the following code?

Which of the following will correctly format a floating-point number to show 4 decimal places?

Which of the following prints the value of pi = 3.141592653589793 with exactly 2 digits after the decimal point?

What will this code print?

Which code snippet correctly aligns a string to the center in a field of 15 characters?

What is the output of the following code?

What will this code print?

What will this code print?

What will this code print?

What will this code print?

About This Exercise: Python – String Formatting