Check your understanding of the previous reading: the six logical patterns, and how to reason about multiple return statements.

Question 1

Match each explanation to the most relevant pattern.

An if statement with an and can be replaced with two if statements, one inside the other.

This describes And vs Nested If directly: if A and B: is the same as if A: if B:.

Wrap some code with an if statement so that errors are not caused in certain conditions.

This is the Defensive Guard pattern: guard against a ZeroDivisionError or a bad conversion before it happens.

Return a value from a function if a condition is not met, in order to avoid errors.

Return a value from a function with many if/elif/else branches by putting return statements in each branch.

This is the Multiple Return Spots pattern: a return inside each branch.

Return a value from a function with many if/elif/else branches by updating a variable and then only having one return statement at the end.

This is the Build-Up-Return pattern: assign to a result variable in each branch, then one return result at the end.

Avoid having multiple else branches to specify default behavior by assigning an initial value to a variable prior to the if statements.

Question 2

What happens when there are multiple return statements in a function?

Select every answer that applies, then check.

The program ends when the first return statement is reached.
Not quite. A return ends the function call, not the whole program; execution continues right after the call.
The function ends when the first return statement is reached.
Correct. As soon as a return executes, the function is over — nothing after it runs for that call.
An error will occur, because you cannot have more than one return statement.
Not quite. A function may contain as many return statements as you like, as long as at most one of them executes per call.
The last return statement will be used to determine the returned value.
Not quite. Only the first return that actually executes matters; a function ends the moment it runs.
All the values from all the return statements will be combined using the type rules.
Not quite. Only one return executes per call, so there is nothing to combine.
The return statements must be placed under other control structures like if statements, or the other return statements will not be reachable.
Correct. A return unconditionally ends the function, so any code written right after it at the same indentation — including another return — is unreachable. if/elif/else branches are what let several return statements each be reachable.

Question 3

Why might you use the Build-Up-Return pattern instead of the Multiple-Returns pattern?

Select every answer that applies, then check.

The Build-Up-Return pattern only has one return statement, so the control flow is a little less complicated.
Correct — this is exactly the trade-off from the reading: isolating return to a single spot makes the control flow easier to reason about.
The Build-Up-Return pattern often leads to shorter code.
Not stated, and not generally true: Build-Up-Return needs an assignment in every branch plus a final return result, which is usually about the same length as Multiple Return Spots.
The Build-Up-Return pattern often leads to faster code.
Not stated in the reading. The two patterns do the same work; there's no meaningful performance difference.
The Build-Up-Return pattern guarantees that a value will be returned no matter what, unlike the Multiple-Returns where you might forget to return a value from a branch.
Not quite. Both patterns need an exhaustive if/elif/else chain (ending in else) to guarantee a value — forgetting a branch is just as possible either way.
The Multiple-Returns pattern is not functionally equivalent to the Build-Up-Return pattern, so that pattern is more powerful.
Incorrect — the reading says the opposite: "Functionally, they are equivalent." Neither pattern can do something the other can't.

Question 4

In which of these cases might you need a Defensive Guard to avoid an error?

Select every answer that applies, then check.

Make sure that a value is not zero before division.
Correct — the reading's own example: guard distance / time with if time > 0:.
Make sure a string contains only digits, before you convert it to an integer.
Correct — the reading's own example: guard int(user_input) with if user_input.isdigit():.
Make sure an integer is positive, before you convert it to a string.
Not needed. str() works on any integer — positive, negative, or zero — without error.
Make sure a boolean value is True, before you invert it with not.
Not needed. not works on any boolean value without error.
Make sure that a string has at least one character, before you index the first character.
Correct. Indexing an empty string (e.g. ""[0]) raises an IndexError, so checking the string is non-empty first avoids it.
Make sure that a string has at least 5 characters, before you subscript the first ten characters.
Not needed for a slice: some_string[:10] never raises an error, even on a shorter string — it just returns however many characters are available.

Question 5

Which of these comparisons between the patterns are accurate?

Select every answer that applies, then check.

The Early Return and Defensive Guard patterns are similar, since they both avoid problematic code with an if statement.
Correct — the reading says exactly this: "The Early Return pattern is like the Defensive Guard pattern, with an if statement ending a branch inside of a function before an error ... can occur."
The "And vs Nested If" pattern is similar to the "Defensive Guard", since one incorporates the and operator and the other incorporates the or operator.
Incorrect on two counts: the reading never compares these two patterns, and Defensive Guard doesn't use or at all — its examples are plain if checks.
The Build-Up-Return pattern and the Multiple Return Spots patterns are similar, since they both achieve the same result.
Correct — the reading states they are "functionally equivalent," with the same value returned either way.
The Define-and-Refine pattern is useful for specifying default behavior to avoid having too many branches, just like the Multiple Returns pattern.
Incorrect. Define-and-Refine is contrasted with needing an else at every level of nested if, not with Multiple Return Spots — the reading never draws that comparison.

Question 6

What does the following code print?

alpha = 20
beta = 3

if alpha > 10:
    if beta > 10:
        alpha = 10

print(alpha)

Show worked solution

The outer condition alpha > 10 is true (20 > 10), so Python enters that block. But the inner condition beta > 10 is false, since beta is 3. So the inner if body (alpha = 10) never runs, and alpha keeps its original value. print(alpha) prints 20.

Question 7

Given the following code:

gamma = "Hello!"
if gamma and gamma[-1] == "!":
    print("Exclaim")

Which of the following programs are functionally equivalent to the conditional part, for any string value of gamma (not just "Hello!")?

Select every answer that applies, then check.

if len(gamma) > 0 and gamma[-1] == "!": print("Exclaim")
Equivalent. len(gamma) > 0 is true exactly when gamma is truthy, and and short-circuits the same way in both versions, so an empty string never reaches the indexing.
if gamma or gamma[-1] == "!": print("Exclaim")
Not equivalent. With or, any non-empty gamma makes the condition true regardless of its last character, and an empty gamma would fall through to gamma[-1] and raise an IndexError — the original never does either.
if gamma: if gamma[-1] == "!": print("Exclaim")
Equivalent. This is exactly the And vs Nested If pattern applied to the original condition.
if gamma: print("Exclaim") if gamma[-1] == "!": print("Exclaim")
Not equivalent. This can print twice, prints even when the last character isn't "!", and still indexes gamma[-1] unguarded when gamma is empty.
if gamma: print("Exclaim") elif gamma[-1] == "!": print("Exclaim")
Not equivalent. Any non-empty gamma prints via the first branch, regardless of its last character — the original also requires the last character to be "!".