Python conditionals — solved exercises with movies, tax brackets, passwords and the number guessing game (and the or that let everybody in)

My first attempt at the movie exercise had this line: if age >= 13 or age < 17:. The idea was “between 13 and 16”. I tested it with my own age, it worked, and I called it done. A few days later I showed it to my 8-year-old cousin so he could play with it, and the program told him he could watch a 13+ movie, no problem. An 8-year-old is “under 17”, and with an or that’s enough. That line is snippet 2 in “What’s wrong here?”, so you can catch it before it catches you.

These are Python conditionals exercises with solutions: four exercises across three levels (basic, intermediate and challenge), three buggy snippets to predict, the solutions commented line by line and a cheat sheet to review before the exam. If you haven’t yet, read the conditionals theory and the practice with three programs first: here I no longer give you the code.

How to use this article

1. Read the statement and the expected output. The data is fixed in variables at the top of the program, so your output has to match the article’s. Once it works, swap the variables for input().
2. Try to solve it in VS Code without looking at anything. If you’ve been stuck for more than 10 minutes, read the hint.
3. Before looking at the solution, test your boundaries: the exact value of each threshold and the one just below it. That’s where conditionals break.
4. Compare with the commented solution and read “Why it’s done this way”: sometimes your version works and there’s still something to learn from the other one.

Basic level

Exercise 1 — Movie rating system

Write a program that, given the user’s age, a movie’s rating and whether they’re with an adult, says whether they can watch it. The ratings are:

Rules: if they reach the minimum age, they can watch it; if not, but they’re with an adult, they can too, except for NC-17, which allows no exceptions. The rating may come in lowercase ("r"). If it isn’t one of the five, the program says so. With age = 15, rating = "r" and with_adult = False, the expected output is:

--- Result ---
Rating R: not recommended under 17
Your age: 15
Access: ✗ You cannot watch this movie without an adult

Exercise 2 — Income tax calculator

Write a program that, given the annual gross salary, picks the rate that applies according to these simplified brackets and applies it to the whole salary:

It must show the gross salary, the rate applied, the tax, the annual net salary and the net per month over 12 payments, with two decimals. With salary = 28000.0, the expected output is:

--- Simplified calculation ---
Gross salary: 28000.00 €
Rate applied: 30 %
Tax: 8400.00 €
Net salary: 19600.00 €
Net per month (12 payments): 1633.33 €

Intermediate level

Exercise 3 — Password strength validator

Write a program that analyses a password against five criteria, says which ones it meets and which it doesn’t, and gives it a score from 0 to 5:

• At least 8 characters → +1 point.
• Has capitals → +1 point.
• Has lowercase letters → +1 point.
• Has digits → +1 point.
• Has a special character from !@#$%^&* → +1 point.

Final classification: 0 to 2 points, “Very weak 🔓”; 3, “Weak 🔐”; 4, “Strong 🔒”; 5, “Very strong 🔒”. With password = "Python@2024", the expected output is:

--- Password analysis ---
✓ Long enough (11 characters)
✓ Has capitals
✓ Has lowercase letters
✓ Has digits
✓ Has special characters
Score: 5/5
Strength: Very strong 🔒

Final challenge

Exercise 4 — Number guessing game

The classic. The program thinks of a number between 1 and 100 and the player tries to guess it. After each attempt, the program says “Too low”, “Too high” or “Correct!”, and at the end it shows how many attempts it took and a rating: 1 to 3, “Incredible 🏆”; 4 to 6, “Great 👏”; 7 to 10, “Good ✓”; more than 10, “Keep practising 💪”.

So your output can be compared, fix secret_number = 69 and keep the guesses in a list, guesses = [50, 75, 63, 69], instead of reading them with input(). The expected output is:

=== GUESS THE NUMBER ===
I'm thinking of a number between 1 and 100...
Attempt 1: 50
→ Too low
Attempt 2: 75
→ Too high
Attempt 3: 63
→ Too low
Attempt 4: 69
→ Correct! 🎉
--- Result ---
You guessed it in 4 attempts
Rating: Great 👏

What’s wrong here?

Three short snippets, each with a typical bug. Before reading the explanation, predict what each one prints.

Snippet 1: the grade that came from input()

grade = "7"            # input() ALWAYS returns text, even if you type a number

if grade >= 5:
    print("Pass")

Does it print “Pass”? It doesn’t get to print anything:

Traceback (most recent call last):
  File "text.py", line 3, in <module>
    if grade >= 5:
       ^^^^^^^^^^
TypeError: '>=' not supported between instances of 'str' and 'int'

grade is "7", with quotes: it’s a string, just like everything input() returns. And Python has no idea whether the string "7" is greater than or equal to the number 5, so it refuses with a TypeError. Careful: with == there’d be no error ("7" == 7 is simply False), which is worse, because it would fail silently.

The fix is to convert the string before comparing:

grade = "7"
grade = float(grade)    # turns the text into a number before comparing

if grade >= 5:
    print("Pass")

Output:

Pass

Snippet 2: the age band with or

age = 8

# We want the 13 to 16 age band (can watch PG-13, not R yet)
if age >= 13 or age < 17:
    print("13-16 band: can watch PG-13")
else:
    print("Outside the 13-16 band")

With an 8-year-old, what does it print?

13-16 band: can watch PG-13

It’s my cousin’s or. age >= 13 is False, but age < 17 is True (8 is less than 17), and an or only needs one. In fact, that condition is true for any age: every number is at least 13, or below 17, or both.

The fix, with a chained comparison:

age = 8

if 13 <= age < 17:             # both at once: 13 <= age and age < 17
    print("13-16 band: can watch PG-13")
else:
    print("Outside the 13-16 band")

Output:

Outside the 13-16 band

Snippet 3: the else that went off with another if

It’s an 18+ screening. If the person is an adult, we check whether they have a ticket; if they’re under 18, they can’t come in. With age = 15, what does it print?

age = 15
has_ticket = True

# 18+ screening: the else should be the "under 18" one
if age >= 18:
    if has_ticket:
        print("Can come in to the screening")
    else:                       # which if does this else belong to?
        print("Under 18: cannot come in")
print("End of check")

Real output:

End of check

No “Under 18”, nothing: only “End of check”. The else is indented 4 spaces, level with if has_ticket:, so it’s the else of that inner if, not of the first one. With age = 15, age >= 18 is False and Python skips the whole block, else included. The diagram shows which if each else pairs with in both versions:

The fix puts the else level with the first if (and, while we’re at it, gives the inner if its own else):

age = 15
has_ticket = True

if age >= 18:
    if has_ticket:
        print("Can come in to the screening")
    else:
        print("Missing a ticket")
else:                           # level with the first if: it is ITS else
    print("Under 18: cannot come in")
print("End of check")

Output:

Under 18: cannot come in
End of check

Commented solutions

Solution exercise 1

# Exercise 1 — Can I watch this movie?
age = 15
rating = "r"                # as the user would type it
with_adult = False

rating = rating.upper()     # "r" → "R": now we only compare capitals

# 1. Minimum age and description of each rating
if rating == "G":
    min_age = 0
    description = "all audiences"
elif rating == "PG":
    min_age = 10
    description = "under 10 with an adult"
elif rating == "PG-13":
    min_age = 13
    description = "not recommended under 13"
elif rating == "R":
    min_age = 17
    description = "not recommended under 17"
elif rating == "NC-17":
    min_age = 18
    description = "18 and over only"
else:
    min_age = -1            # marker for "unknown rating"
    description = ""

print("--- Result ---")
if min_age == -1:
    print(f"Rating {rating} not recognised")
else:
    print(f"Rating {rating}: {description}")
    print(f"Your age: {age}")
    # 2. Gets in if old enough OR with an adult (except NC-17, no exceptions)
    if age >= min_age or (with_adult and rating != "NC-17"):
        print("Access: ✓ You can watch this movie")
    else:
        print("Access: ✗ You cannot watch this movie without an adult")

Output:

--- Result ---
Rating R: not recommended under 17
Your age: 15
Access: ✗ You cannot watch this movie without an adult

Why it’s done this way:

• .upper() before comparing. That way we only compare with "R", not with "R" and "r". Without it, "r" == "R" is False and the program would say “Rating r not recognised”.
• The chain only assigns. It’s the FP1 pattern: first min_age and description are decided; then a single access decision that works for every rating. If you put an access print in each branch, you’d have the same condition repeated five times.
• -1 as the “unknown” marker. No real minimum age is negative, so -1 can’t be confused with a valid rating and the variable exists in every branch (without the else, using min_age later would give a NameError with an odd rating).

The key line, zoomed in:

if age >= min_age or (with_adult and rating != "NC-17"):

The brackets aren’t decoration: they group the adult exception. Without them it would work the same (Python evaluates and before or), but with them the rule reads exactly like the statement.

Solution exercise 2

# Exercise 2 — Tax by brackets (simplified version)
salary = 28000.0

# With <= the brackets go from LOWEST to HIGHEST: the first one met is the right one
if salary <= 12450:
    rate = 19
elif salary <= 20200:            # here we already know salary > 12450
    rate = 24
elif salary <= 35200:
    rate = 30
elif salary <= 60000:
    rate = 37
else:
    rate = 45

tax = salary * rate / 100
net = salary - tax
monthly = net / 12

print("--- Simplified calculation ---")
print(f"Gross salary: {salary:.2f} €")
print(f"Rate applied: {rate} %")
print(f"Tax: {tax:.2f} €")
print(f"Net salary: {net:.2f} €")
print(f"Net per month (12 payments): {monthly:.2f} €")

Output:

--- Simplified calculation ---
Gross salary: 28000.00 €
Rate applied: 30 %
Tax: 8400.00 €
Net salary: 19600.00 €
Net per month (12 payments): 1633.33 €

Why it’s done this way:

• <= and lowest first. 28000 <= 12450 is False; 28000 <= 20200 is False; 28000 <= 35200 is True → 30 %. When we reach each elif we already know the salary is above the previous bracket, so there’s no need to write salary > 12450 and salary <= 20200.
• The else catches “more than 60,000”. No need to write salary > 60000: if all the previous ones failed, it is.
• The maths by hand: 28000 × 30 / 100 = 8400; 28000 − 8400 = 19600; 19600 / 12 = 1633.333…, which :.2f prints as 1633.33.

Solution exercise 3

# Exercise 3 — Password strength validator
password = "Python@2024"
special_chars = "!@#$%^&*"
points = 0

print("--- Password analysis ---")

# Five INDEPENDENT ifs: each criterion adds on its own (with elif only one would count)
if len(password) >= 8:
    print(f"✓ Long enough ({len(password)} characters)")
    points += 1
else:
    print(f"✗ Too short ({len(password)} characters, minimum 8)")

if any(c.isupper() for c in password):        # any capital letter?
    print("✓ Has capitals")
    points += 1
else:
    print("✗ No capitals")

if any(c.islower() for c in password):
    print("✓ Has lowercase letters")
    points += 1
else:
    print("✗ No lowercase letters")

if any(c.isdigit() for c in password):
    print("✓ Has digits")
    points += 1
else:
    print("✗ No digits")

if any(c in special_chars for c in password):     # any character from the list?
    print("✓ Has special characters")
    points += 1
else:
    print("✗ No special characters")

# Now a chain: the score falls into ONE category only
if points <= 2:
    strength = "Very weak 🔓"
elif points == 3:
    strength = "Weak 🔐"
elif points == 4:
    strength = "Strong 🔒"
else:
    strength = "Very strong 🔒"

print(f"Score: {points}/5")
print(f"Strength: {strength}")

Output:

--- Password analysis ---
✓ Long enough (11 characters)
✓ Has capitals
✓ Has lowercase letters
✓ Has digits
✓ Has special characters
Score: 5/5
Strength: Very strong 🔒

Why it’s done this way:

• Five independent ifs for the criteria. A password can meet several at once, and each one adds its point. With an elif chain, as soon as the first one (length) was met the rest wouldn’t be looked at and "Python@2024" would score 1 point.
• An elif chain for the classification. Here yes: the score falls into one category only. points <= 2 goes first to catch 0, 1 and 2 at once.
• len() inside the message. "Python@2024" has 11 characters: P-y-t-h-o-n (6), @ (1) and 2-0-2-4 (4). The program counts them for you instead of you typing the number.

Solution exercise 4

# Exercise 4 — Guess the number
# In your version:  import random  and  secret_number = random.randint(1, 100)
secret_number = 69                # fixed here so the output is always the same
guesses = [50, 75, 63, 69]        # what the player would type (in your version, input())

attempts = 0
guessed = False

print("=== GUESS THE NUMBER ===")
print("I'm thinking of a number between 1 and 100...")

while not guessed:                # repeats until guessed (loops: next topic)
    guess = guesses[attempts]     # the guess for this turn
    attempts += 1
    print(f"Attempt {attempts}: {guess}")
    if guess < secret_number:
        print("→ Too low")
    elif guess > secret_number:
        print("→ Too high")
    else:                         # neither lower nor higher: equal
        print("→ Correct! 🎉")
        guessed = True

print("--- Result ---")
print(f"You guessed it in {attempts} attempts")
if attempts <= 3:
    valoracion = "Incredible 🏆"
elif attempts <= 6:               # 4, 5 or 6: the elif already knows it is above 3
    valoracion = "Great 👏"
elif attempts <= 10:
    valoracion = "Good ✓"
else:
    valoracion = "Keep practising 💪"
print(f"Rating: {valoracion}")

Output:

=== GUESS THE NUMBER ===
I'm thinking of a number between 1 and 100...
Attempt 1: 50
→ Too low
Attempt 2: 75
→ Too high
Attempt 3: 63
→ Too low
Attempt 4: 69
→ Correct! 🎉
--- Result ---
You guessed it in 4 attempts
Rating: Great 👏

Why it’s done this way:

• A three-way if/elif/else inside the loop. Each guess is lower than, higher than or equal to the secret: three mutually exclusive cases, so it’s a chain. The else doesn’t need to say guess == secret_number: if it’s neither lower nor higher, it’s equal.
• guesses[attempts] before attempts += 1. On the first turn attempts is 0, and guesses[0] is the first guess. If you added first, you’d start at guesses[1] and skip the 50.
• The rating with <= in increasing order. “4 to 6” doesn’t need attempts >= 4 and attempts <= 6: if it reaches elif attempts <= 6, we already know it isn’t <= 3.

The heart of the program, zoomed in:

while not guessed:                # repeats until guessed (loops: next topic)
    guess = guesses[attempts]     # the guess for this turn
    attempts += 1
    print(f"Attempt {attempts}: {guess}")
    if guess < secret_number:
        print("→ Too low")
    elif guess > secret_number:
        print("→ Too high")
    else:                         # neither lower nor higher: equal
        print("→ Correct! 🎉")
        guessed = True

Turn by turn:

After the loop, 4 <= 3 is False and 4 <= 6 is True: “Great 👏”. The diagram shows what each hint does: cut down the range of possible numbers until only one is left.

Exam-style quiz

Now test yourself as in the exam. The FP1 quizzes look like this: 15 questions in 20 minutes (16 in 30 in the Sequences one), almost all single choice (each wrong answer subtracts a third of what the question is worth) and many «what does this code print?», with the odd fill in the gaps, matching or true or false. Here are 13 original questions on conditionals. Answer without running anything, press Check and read the explanation for each one. These questions are also the question bank for the FP1 theory mock exam, which will mix them with those from the other topics.

grade = 6.5
if grade >= 9:
    print("Excellent")
elif grade >= 7:
    print("Good")
elif grade >= 5:
    print("Pass")
else:
    print("Fail")

x = 15
c = 0
if x > 10:
    c = c + 1
if x > 12:
    c = c + 1
if x > 20:
    c = c + 1
print(c)

age = 17
if age >= 18:
    print("Can vote")
print("End")

t = ""
if t:
    print("has text")
else:
    print("empty")

a, b = 4, 9
if a > b:
    m = a
else:
    m = b
if m % 2 == 0:
    print(m // 2)
else:
    print(m * 2)

x = 7
if x > 5:
    if x > 10:
        print("A")
    else:
        print("B")
else:
    print("C")

a, b = 50, 25
c = 0
if a > b and b > 30:
    c = 1
elif a > b or b > 30:
    c = 2
print(c)

Watch it step by step in Python Tutor

Snippet 3 is the hardest one to see just by reading, so watch it live. On pythontutor.com, choose Python 3 and paste this program, which has both versions one after the other (A with the badly indented else and B fixed):

age = 15
has_ticket = True

# A: the else is indented inside the inner if
if age >= 18:
    if has_ticket:
        print("A: can come in")
    else:
        print("A: under 18")

# B: the else level with the first if
if age >= 18:
    if has_ticket:
        print("B: can come in")
    else:
        print("B: missing a ticket")
else:
    print("B: under 18")

The real output is a single line:

B: under 18

What to watch step by step:

1. At the first if age >= 18: (version A), the arrow jumps straight to the version B comment: with age = 15, the whole A block, else included, is skipped.
2. Notice that in version A no print is ever reached: that’s why no line with “A:” comes out.
3. In version B, the arrow goes from if age >= 18: to the else: near the end, because that else is level with the first if.
4. Change age to 20 and has_ticket to False: now version A prints “A: under 18” to an adult (the wrong message in the wrong branch) and B prints “B: missing a ticket”.

Cheat sheet: Python conditionals

The essentials in 30 seconds

• if / elif / else: colon at the end and 4 spaces of indentation in the block.
• In a chain, only the first block whose condition is True runs.
• With >=, thresholds highest first; with <=, lowest first.
• Independent checks → several ifs. Exclusive cases → elif.
• Ranges with and or chained: 0 <= grade <= 10. Never x == "a" or "b".
• Zero and empty are False; everything else, True ("0" too).
• An else belongs to the if at its own level.

I want to…

Templates from the exercises

Classify by brackets (exercises 2 and 3, the FP1 pattern):

if value <= bracket_1:        # with <=, lowest first
    result = "A"
elif value <= bracket_2:      # we already know value > bracket_1
    result = "B"
else:                         # everything left
    result = "C"

With exercise 2, value = 28000 falls into the <= 35200 bracket and gives 30 %.

Count independent criteria (exercise 3):

points = 0
if criterion_1:               # each if adds on its own
    points += 1
if criterion_2:
    points += 1

With "Python@2024", all five criteria add up and points reaches 5.

Decide with an exception (exercise 1):

if age >= min_age or (with_adult and rating != "NC-17"):
    print("Can watch it")
else:
    print("Cannot watch it")

With 15, R and no adult: False or False → “Cannot watch it”.

Symptom and likely cause

Before handing it in, ask yourself

1. Have I tested each threshold with its exact value and with the one just below?
2. Are my checks independent (several ifs) or exclusive (elif)?
3. Is each side of my ands and ors a complete comparison?
4. Is every variable I use after the chain assigned in every branch?

With conditionals mastered, the next step is repeating decisions without copying code: Python loops. And if anything in this article was hard going, go back to the theory, the practice or one step further back, to Python operators.

Did this article help you? Here is how you can support SergioLearns →