1   Boolean Operators: and, or, not

In Article 3, every condition was a single comparison: score >= 90, "@" in email. But conditions can be combined using three boolean operators that work just like their English equivalents.

2   The and Operator

and requires all conditions to be true before the whole expression is true. Think of it as a series of gates — every gate must be open to pass through.

age = 20
has_ticket = True

if age >= 18 and has_ticket:
    print("You may board the flight.")
else:
    print("You cannot board.")

Python evaluates age >= 18 (True) and has_ticket (True). Both are true, so the whole condition is True and the first branch runs.

2.1   Truth Table for and

A truth table shows every possible combination of inputs and the resulting output. For and, the only way to get True is if both sides are True:

2.2   A Practical Example

username = "alex"
password = "python99"

entered_user = input("Username: ")
entered_pass = input("Password: ")

if entered_user == username and entered_pass == password:
    print("Login successful.")
else:
    print("Incorrect username or password.")

Notice that both conditions must pass — correct username and correct password. A correct username with the wrong password is still denied.

3   The or Operator

or requires at least one condition to be true. Even if only one side is true, the whole expression is true.

day = "Saturday"

if day == "Saturday" or day == "Sunday":
    print("It is the weekend — no school!")
else:
    print("It is a school day.")

3.1   Truth Table for or

The only way or gives False is when both sides are False:

3.2   A Practical Example

file_type = input("Enter file extension (without dot): ")

if file_type == "jpg" or file_type == "png" or file_type == "gif":
    print("This is an image file.")
else:
    print("This is not a recognised image format.")

if file_type in ["jpg", "png", "gif"]:
    print("This is an image file.")

4   The not Operator

not flips a boolean value. True becomes False, and False becomes True. It applies to a single condition and reverses whatever it evaluates to.

4.1   Truth Table for not

4.2   Using not in Practice

is_logged_in = False

if not is_logged_in:
    print("Please log in to continue.")

# not also works with in:
blocked_users = ["spammer99", "troll42"]
username = "alex"

if username not in blocked_users:
    print("Access granted.")

You have already seen not in in Article 3 — that is actually the not operator combined with in. Python lets you write it as one readable phrase.

5   Combining Multiple Operators

You can chain and, or, and not together in one condition. This is where things get powerful — but also where logic bugs tend to hide.

5.1   Operator Precedence

Just like maths has an order of operations (multiplication before addition), Python has an order for boolean operators:

This means not binds tightest, and comes next, and or is evaluated last. Consider this expression:

is_student = True
has_id = False
is_staff = True

# What does this evaluate to?
result = is_student and has_id or is_staff
print(result)    # True

Python reads this as (is_student and has_id) or is_staff — because and has higher priority than or. So it first evaluates True and False → False, then False or True → True.

5.2   Use Parentheses to Be Clear

Relying on operator precedence makes code hard to read and easy to get wrong. Use parentheses to make your intent explicit. Parentheses are always evaluated first — just like in maths.

# Ambiguous — relies on precedence rules
if is_student and has_id or is_staff:
    print("Entry allowed")

# Clear — parentheses show exactly what is grouped
if (is_student and has_id) or is_staff:
    print("Entry allowed — staff or verified student.")

# A different meaning entirely:
if is_student and (has_id or is_staff):
    print("Entry allowed — student with ID or staff status.")

6   Nested Conditionals

A nested conditional is an if statement placed inside another if statement. The inner condition only runs if the outer condition is already true — like a second gate that only appears after you pass the first.

age = 20
is_vip = True

if age >= 18:
    print("Age check passed.")
    if is_vip:
        print("Welcome to the VIP area.")
    else:
        print("You may enter the general area.")
else:
    print("Entry denied — you must be 18 or older.")

Notice the indentation: the inner if/else is indented one level further in than the outer if. Python uses that indentation to know which block belongs to which conditional.

6.1   Tracing a Nested Conditional

Let's trace this program with two different inputs and see what happens:

6.2   When to Use Nesting vs. and

Sometimes you can achieve the same result with nesting or with and. They are not always interchangeable — but knowing when each applies is important.

7   Guard Clauses: Handling Problems First

A guard clause is a technique where you check for problem cases right at the top of a block of code and exit early — before doing any of the main work. It is one of the most useful habits in professional programming.

7.1   Without a Guard Clause

Here is a program that calculates a student's grade — written without guard clauses. Notice how the "main" logic is buried inside nested conditionals:

score = int(input("Enter score: "))

if score >= 0:
    if score <= 100:
        if score >= 90:
            print("Grade: A")
        elif score >= 80:
            print("Grade: B")
        elif score >= 70:
            print("Grade: C")
        else:
            print("Grade: F")
    else:
        print("Error: score cannot be above 100.")
else:
    print("Error: score cannot be negative.")

This works — but the actual grading logic is buried two levels deep. Every time you read it, you have to mentally "unwrap" the nesting to find the main work.

7.2   With Guard Clauses

Now look at the same program written with guard clauses. The error cases are handled first, and the main logic sits flat — no nesting needed:

score = int(input("Enter score: "))

if score < 0:
    print("Error: score cannot be negative.")
elif score > 100:
    print("Error: score cannot be above 100.")
elif score >= 90:
    print("Grade: A")
elif score >= 80:
    print("Grade: B")
elif score >= 70:
    print("Grade: C")
else:
    print("Grade: F")

The logic is identical — but now there is no nesting at all. The invalid cases are dealt with immediately, and the grading runs cleanly in the remaining elifs.

8   Putting It All Together

Here is a program that uses everything from this article — and from Article 3 — in one realistic scenario: a simple event ticket checker. Read it carefully, trace it for a few inputs, then answer the questions below.

VALID_CODES = ["GOLD2026", "SILVER2026", "PRESS2026"]
MIN_AGE = 16

name = input("Name: ")
age = int(input("Age: "))
code = input("Ticket code: ").upper()    # .upper() makes comparison case-insensitive

# Guard clauses — check for bad input first
if not name:
    print("Error: name cannot be empty.")
elif age < 0 or age > 120:
    print("Error: that age does not look right.")

# Main logic
elif age < MIN_AGE:
    print("Sorry,", name + ". You must be at least", MIN_AGE, "to attend.")
elif code not in VALID_CODES:
    print("Sorry,", name + ". That ticket code is not valid.")
else:
    # Passed all checks — now determine access level
    if code == "GOLD2026":
        print("Welcome,", name + "! You have GOLD access — enjoy the front row.")
    elif code == "PRESS2026":
        print("Welcome,", name + "! Press credentials confirmed.")
    else:
        print("Welcome,", name + "! Standard admission confirmed.")

Things to notice:

• The first two elif blocks are guard clauses — they catch bad data before any real logic runs.
• age < MIN_AGE and code not in VALID_CODES use a comparison and <strong>not in</strong> to filter out invalid cases.
• age < 0 or age > 120 uses <strong>or</strong> to catch two different impossible values in one line.
• The inner nested if/elif/else at the bottom only runs after all guard clauses have been cleared — it can safely assume the input is valid.
• .upper() normalises the ticket code so "gold2026" and "GOLD2026" both work.

9   Final Check: The Big Picture

10   Quick-Reference Summary