Module 7: Strings in Depth – Quiz

Question 1

What is the key characteristic of Python strings that differs from lists?

Strings cannot be indexed
Strings cannot be sliced
Strings are immutable (cannot be changed in place)
Strings cannot contain numbers

Correct! Strings are immutable -- all string methods return a new string rather than modifying the original.

Incorrect. Strings are immutable, meaning they cannot be changed in place. String methods always return new strings.

Question 2

What does "Hello World".lower() return?

"HELLO WORLD"
"hello world"
"Hello world"
"Hello World"

Correct! lower() converts all characters to lowercase.

Incorrect. lower() converts every character to lowercase: "hello world".

Question 3

What does " hello ".strip() return?

"hello"
" hello"
"hello "
" hello "

Correct! strip() removes whitespace from both ends of the string.

Incorrect. strip() removes whitespace from both the beginning and end.

Question 4

What does "banana".count("an") return?

1
3
0
2

Correct! "an" appears twice in "banana" (at positions 1 and 3).

Incorrect. The substring "an" appears twice in "banana": b-AN-AN-a.

Question 5

Given text = "Programming", what does text[0:4] return?

"Progr"
"Prog"
"Pro"
"rogr"

Correct! Slice [0:4] gets characters at indexes 0, 1, 2, 3 -- "Prog".

Incorrect. [0:4] includes indexes 0 through 3 (stop is exclusive): "P-r-o-g".

Question 6

How do you reverse a string in Python?

text.reverse()
reverse(text)
text[::-1]
text[-1:0]

Correct! [::-1] creates a reversed copy of the string using slice notation with a step of -1.

Incorrect. Strings do not have a reverse() method. Use [::-1] to reverse a string.

Question 7

What does "hello".find("xyz") return?

-1
0
False
It raises a ValueError

Correct! find() returns -1 when the substring is not found (unlike index() which raises an error).

Incorrect. find() returns -1 when the substring is not found. index() is the one that raises ValueError.

Question 8

What does "a,b,c,d".split(",") return?

"a b c d"
["a,b,c,d"]
("a", "b", "c", "d")
["a", "b", "c", "d"]

Correct! split(",") breaks the string at each comma and returns a list of substrings.

Incorrect. split(",") returns a list of substrings split at each comma: ["a", "b", "c", "d"].

Question 9

What does "-".join(["2024", "03", "15"]) return?

["2024-", "03-", "15"]
"2024-03-15"
"-2024-03-15-"
"2024", "03", "15"

Correct! join() combines list elements into a single string with "-" between each element.

Incorrect. join() places the separator between each element: "2024-03-15".

Question 10

What does rfind() do differently from find()?

It searches case-insensitively
It raises an error if not found
It searches from the right and returns the last occurrence
It returns all occurrences as a list

Correct! rfind() searches from the right side and returns the index of the last occurrence.

Incorrect. rfind() searches from the right and returns the position of the last occurrence of the substring.

Question 11

What does the r prefix do in r"hello\nworld"?

Treats backslashes as literal characters (raw string)
Makes the string read-only
Reverses the string
Removes whitespace from the string

Correct! The r prefix creates a raw string where backslashes are not treated as escape characters.

Incorrect. The r prefix makes a "raw" string where backslashes are literal, not escape characters.

Question 12

Which is the most efficient way to build a string from many pieces in a loop?

Using += concatenation in each iteration
Using replace() in each iteration
Creating a new string variable each time
Appending to a list, then using "".join(list)

Correct! Building a list and joining is more efficient because strings are immutable -- each += creates a new string in memory.

Incorrect. The most efficient approach is to append pieces to a list, then join them. String concatenation with += creates a new string each time.

Module 7 Quiz: Strings in Depth