Python If Statements and Boolean Logic

A comparison asks a question about values. Its result is a Boolean value: True or False. These are values of type bool, written with capital first letters and no quotes. "True" is text; lowercase true is a name and raises NameError when it has not been defined.

Choose the operator that matches the rule

The two-character operators stay together, with = last. Write <=, not =<. An integer and a float can compare equal: 7 == 7.0 gives True because their numeric values agree.

A comparison is an expression, so you can print its result or store it:

x = 7
is_big = x > 5
print(is_big)

Python evaluates x > 5, gets True, and assigns that value to is_big. The output is True. A name such as is_big or has_ticket makes a Boolean variable read like a yes/no question.

Keep assignment and comparison separate

x = 5 stores a new value in x. x == 5 checks the current value without changing it. Writing if x = 5: is a syntax error. The reverse mistake can be harder to notice:

x = 7
x == 5
print(x)

In a script, the comparison result is unused. The output remains 7; that middle line never assigns 5.

Work out arithmetic before comparing

In 2 + 3 > 4, Python first adds to get 5, then compares 5 > 4. The result is True. A useful whole-number test is n % 2 == 0: % gives the remainder after division, and even numbers leave remainder 0 when divided by 2.

For n = 10, the steps are 10 % 2, then 0 == 0, giving True. For n = -7, -7 % 2 is 1, so the even-number test is False. With the positive divisor 2, Python's remainder for an odd integer is 1, including a negative odd integer.

Decide whether the edge belongs

"At least 18" includes 18: age >= 18. "Over 18" excludes it: age > 18. Likewise, "under 13" is age < 13, and "no more than 3" is bags <= 3. Test the boundary itself when choosing an operator. At age = 18, the first age test is true and the second is false.

Allow for tiny float differences

Many decimal fractions have only approximate binary representations. Python stores 0.1 + 0.2 as 0.30000000000000004, so 0.1 + 0.2 == 0.3 is False.

For a comparison with an absolute tolerance of 1e-9, use:

print(abs((0.1 + 0.2) - 0.3) < 1e-9)

abs() gives the size of the difference without its sign. That difference is smaller than one billionth, so this test prints True. The tolerance states how much difference this check accepts; it is not exact equality.

The values on both sides of a comparison matter as much as the operator. Text can look like a number while still following string rules.

Compare text exactly

String equality checks every character, including case and spaces. "yes" == "Yes" is False, and "yes" == "yes " is also False. To accept ordinary differences in capitalization and surrounding spaces, compare a cleaned copy:

answer = " Yes "
print(answer.strip().lower() == "yes")

strip() removes whitespace at both ends. lower() changes letters to lowercase. The cleaned text is "yes", so the result is True. The stored answer stays unchanged unless you assign the cleaned value to it.

Understand string order

Python compares strings from left to right using Unicode code points, the numbers assigned to characters. It stops at the first unequal pair. With unaccented English letters in the same case, this follows alphabetical order: "apple" < "banana" is True. When one string is the start of the other, the shorter comes first: "cat" < "catalog" is True.

This is not a full dictionary sorting rule. A through Z have code points 65–90, and a through z have 97–122. Thus "Zebra" < "apple" is True. The accented é also comes after z, so "zebra" < "éclair" is True.

Digits in strings follow the same character rule. "10" < "9" is True: the first comparison is between "1" and "9", not between the numbers ten and nine.

Convert input for numeric decisions

input() returns a string. If someone types 5, "5" == 5 gives False; equality does not convert the text. Ordering is different: "5" < 10 raises TypeError because Python cannot order that string and integer together.

age = int(input("Age: "))
print(age >= 18)

For the typed text "18", int() produces the integer 18, and the test prints True. Use float() when the input represents a decimal value.

Use a chain for a range

0 <= score <= 100 requires both neighboring comparisons to be true. It means 0 <= score and score <= 100. For score = 105, the lower test passes but the upper test fails, so the whole chain is False.

A chain compares neighbors only. 1 < 3 > 2 is True because 1 < 3 and 3 > 2 are both true; it does not compare 1 directly with 2.

Pick membership or identity when needed

The membership operators test whether text occurs inside text. "nan" in "banana" is True; "Ban" in "banana" is False. "x" not in "banana" is True.

None represents no value. Check it with result is None or result is not None. The operator is asks about the very same object, while == asks about equal values. Use == for numeric and string equality: an identity test such as x is 5 is unreliable for that purpose and produces a SyntaxWarning.

An if statement runs a block only when its condition is true. The header begins with if, gives the condition, and ends with a colon. The lines underneath are indented to show that they belong to its body.

Follow a one-way decision

temperature = 31
if temperature > 30:
    print("Hot day")
    print("Drink water")
print("Done")

At the header, Python reads the current value of temperature. The comparison 31 > 30 is True, so both indented lines run. The program then reaches the line outside the block. Its output is:

Hot day
Drink water
Done

Change the first line to temperature = 25. Now 25 > 30 is False, so Python skips the whole body. Only Done prints. The condition is tested once when Python reaches the header; an if does not keep checking it.

Let indentation show membership

By convention, use 4 spaces for each indentation level. Lines at the same level belong to the same block. Returning to the outer level ends it. If you indent print("Done") by 4 spaces, it moves into the if body and prints only when the condition passes.

A flowchart shows the same choice with a diamond. The True path enters the body, the False path goes around it, and the paths meet at the next statement outside the block.

Python may report SyntaxError, IndentationError, or TabError for these problems. Start with the header and the indentation around the reported line. Parentheses around the condition are optional; if temperature > 30: is the usual form.

A body cannot be empty. While leaving a place for an action, write an indented pass. It is a valid statement that does nothing:

if temperature > 30:
    pass

Separate checks are independent

score = 95
if score >= 50:
    print("Pass")
if score >= 90:
    print("Excellent")

Python reaches both headers. Both conditions are true, so it prints both messages. Separate if statements fit rules whose actions can all apply to the same input.

Give later code a value it can use

A name assigned only in the body may never be created:

x = 0
if x > 0:
    message = "positive"
print(message)

In a fresh script, the body is skipped and message has no value, so the last line raises NameError. One repair supplies a starting value before the choice:

x = 0
message = "not positive"
if x > 0:
    message = "positive"
print(message)

Now the later line has a value on both paths. For zero it prints not positive; for a positive x, the body replaces that text with positive.

An if–else statement chooses one of two blocks. When the condition is true, Python runs the if body. Otherwise it runs the else body. Exactly one runs when execution reaches this decision.

Align the alternatives

number = int(input("Enter a whole number: "))
if number % 2 == 0:
    print(number, "is even")
else:
    print(number, "is odd")

For input 14, the remainder is 0, so the output is 14 is even. For input -7, the remainder is 1, so the output is -7 is odd. The else belongs to the if at the same indentation level. Its body has its own indentation.

There is no condition after else: it means that the earlier condition was false. else number < 0: is a syntax error. Keep the clause directly after the if body; an unrelated unindented statement between the two breaks the structure.

Check what "everything else" includes

With if answer == "yes":, an else does not mean only "no". It also accepts "maybe", "Yes", and "", because none equals "yes". This is useful when every remaining input deserves the same action. If several rejected inputs need different responses, they need further tests.

Assign on both paths

A shipping rule gives free shipping for totals of at least 50 dollars and charges 5.99 dollars otherwise:

total = 42.50
if total >= 50:
    shipping = 0
else:
    shipping = 5.99
print(total + shipping)

First, 42.50 >= 50 gives False. Python skips the assignment of 0, runs the else, and stores 5.99. The last line is outside both bodies and prints 48.49. Change total to 60: the first body stores 0, the other is skipped, and the last line prints 60. Both routes define shipping before it is used.

Choose a value with a conditional expression

When the only difference is the value to assign, a conditional expression can say it in one line:

shipping = 0 if total >= 50 else 5.99

Its form is value_if_true if condition else value_if_false. Although the true value appears first on the page, Python evaluates the condition first. It evaluates only the chosen value, then assigns the result to shipping.

Another example is label = "even" if n % 2 == 0 else "odd". For n = 14, it selects "even". For n = -7, it selects "odd".

The expression requires both values. x = 1 if flag is incomplete and raises SyntaxError because there is no else value. A full if statement may omit else because it can simply take no action on the false path; an expression must still produce a value.

Use elif, short for "else if," to add another test to a decision. Python tries the conditions from top to bottom. The first true condition wins, and the rest of that chain is skipped.

Trace a grade decision

score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"
print(grade)

The first test, 85 >= 90, is false. The second, 85 >= 80, is true, so Python stores "B". It does not test the remaining conditions and does not enter else. The output is B.

Use what earlier failures tell you

Reaching elif score >= 80: already tells you that the score is below 90. For whole-number scores, this branch covers 80 through 89. Adding and score < 90 would repeat a check the program has already settled.

The order matters because these ranges overlap. If score >= 60 comes first, it catches 85 and 95 before their higher-grade tests are reached. For lower-bound tests with >=, put the highest threshold first. For upper-bound tests with <, begin with the lowest threshold.

Keep one choice as one chain

Replacing the elif keywords with if changes the behavior. With a score of 85, the test for 80 assigns "B", the test for 70 then assigns "C", and the test for 60 assigns "D". The final value is "D". Each new if starts an independent decision.

This distinction also affects else. In a group of separate if statements, a final else belongs only to its matching if, not to the entire group. Keep the branches joined when they represent one classification.

Make room for boundaries and unmatched input

An elif chain may have any number of further tests, and its final else is optional. Without a catch-all, it may run no body:

temp = 20
if temp < 18:
    print("Cool")
elif temp > 24:
    print("Warm")

Neither condition passes. Add else: with an indented print("Comfortable") if every temperature needs a message. Likewise, t < 18 followed by t > 18 leaves exactly 18 unmatched. At grade thresholds, writing score > 90 would send 90 to the "B" branch.

Text menus use the same structure: test choice == "1", then choice == "2", and give anything else an "Unknown option" response. These checks compare strings because input() returns text. When many tests compare one value with fixed choices, match offers another way to lay out the decision.

The Boolean operators and, or, and not let you build a condition from simpler conditions. Python spells them as lowercase words.

Read all the possibilities

For Boolean inputs, and gives True only when both inputs are true. or gives True when at least one is true, including when both are true. This is an inclusive or.

not reverses a truth value: not True gives False, and not False gives True. A truth table lists every combination of Boolean inputs. Two inputs need four rows; three need eight. Each extra independent Boolean input doubles the combinations.

For A and not B, first reverse B, then combine it with A. In the row A = True, B = False, not B is True, so the result is True. The other three rows give False.

Translate a rule into complete tests

A museum discounts admission for visitors under 12 or aged 65 and over:

has_discount = age < 12 or age >= 65

At age 10, the first comparison passes. At 65, the second passes. Ages 30 and 64 pass neither. Using and would require the same age to be under 12 and at least 65, which cannot happen.

A ride requires a height of at least 120 centimeters and no heart condition:

can_ride = height >= 120 and not has_heart_condition

The two requirements must hold together. At the minimum height with has_heart_condition = False, both parts pass. If either requirement fails, can_ride is False.

Distinguish inside from outside a range

The inside test needs both limits. The outside test needs either failure. score < 0 and score > 100 can never be true for one number.

Each comparison needs both sides. score >= 0 and <= 100 is incomplete syntax. A subtler problem runs without an error:

if answer == "y" or "yes":
    print("Accepted")

Python sees (answer == "y") or "yes". When the comparison is false, the non-empty string "yes" still makes the condition truthy. Repeat the comparison: answer == "y" or answer == "yes".

Everyday wording needs the same care. "Closed on Saturday and Sunday" means day == "Saturday" or day == "Sunday"; one day need not be both names at once. For a Boolean variable, negate it directly with not is_member. A negated comparison such as not (age >= 18) can also be written more simply as age < 18. Python's operators here are words, not &&, ||, or !.

A longer condition has two questions to settle: how its parts are grouped, and which parts Python actually evaluates. Operator precedence answers the first. Short-circuit evaluation answers the second.

Read the grouping first

For the operators used here, precedence goes from tighter to looser:

1. Exponentiation: **.
2. Multiplication, division, floor division, remainder: *, /, //, %.
3. Addition and subtraction: +, -.
4. Comparisons, including in, not in, is, and is not.
5. not, then and, then or.
6. The conditional expression: a if condition else b.

Parentheses change the grouping. For example, x > 3 or x < 0 and x != 5 groups as x > 3 or (x < 0 and x != 5). At x = 5, the left comparison is true and the whole right-hand group is skipped. The result is True.

With (x > 3 or x < 0) and x != 5, the parentheses instead make the first group one operand of and. At x = 5, that group is true, but x != 5 is false, so the result is False.

This is why is_weekend or is_holiday and is_sunny accepts every weekend, even in rain. For the rule "a day off that is also sunny," write (is_weekend or is_holiday) and is_sunny.

Follow evaluation from left to right

For and, a false first part has already ruled out the whole requirement. For or, a true first part has already met it. Precedence does not force Python to calculate a skipped operand just because it contains tighter operators.

You can use this to place a guard before an operation that would fail:

count = 0
total = 50
is_large_average = count != 0 and total / count > 10
print(is_large_average)

count != 0 is false, so Python never attempts 50 / 0. It stores and prints False. Reversing the operands attempts the division first and raises ZeroDivisionError; the later check cannot protect earlier work.

Push not through a grouped test

De Morgan's laws rewrite a negation by reversing each part and switching the joining operator:

"Not a teenager" can be tested as not (age >= 13 and age <= 19). The equivalent direct test is age < 13 or age > 19. Ages 12 and 20 pass; 13, 16, and 19 do not.

Keeping and after negating both parts changes the rule. At A = True, B = False, not (A and B) is true, but not A and not B is false. Compare every truth-table row when checking two Boolean forms for equivalence.

For a variable that already holds a Boolean, write if is_valid: or if not is_valid:. Comparing it with True or False adds a test the condition does not need.

A nested conditional puts one decision inside a branch of another. The inner decision is reached only when execution enters that outer branch. Each nesting level adds 4 spaces of indentation.

Trace the outer choice before the inner choice

has_ticket = True
age = 15
if has_ticket:
    if age >= 13:
        print("Enjoy the movie")
    else:
        print("This movie needs an adult")
else:
    print("Please buy a ticket first")

First, has_ticket is true, so Python enters the outer body. Then it tests 15 >= 13, gets true, and prints Enjoy the movie. The inner and outer else bodies are both skipped.

Change the age to 10 while keeping the ticket. Python still enters the outer body, but the inner condition fails, so it prints This movie needs an adult. With has_ticket = False, the age test is never reached; the outer else prints Please buy a ticket first.

Pair each else by indentation

An else belongs to the if at its own indentation level. Moving it can change the behavior even if the script remains valid. Consider this smaller variant:

if has_ticket:
    if age >= 13:
        print("Enter")
else:
    print("Buy a ticket")

The else belongs to if has_ticket:. A 10-year-old with a ticket gets no message. Move that else and its body inward one level, and it belongs to if age >= 13: instead. Now the same child gets Buy a ticket, while someone without a ticket gets no message. The changed layout expresses a different rule.

In the full movie example, the inner if already has an else. Moving the outer else inward there would create two alternatives for the same if and cause a syntax error.

Flatten a pair of requirements

When there is only one action and neither level has an else, and often removes a nesting level:

if is_member and total >= 50:
    print("Free shipping")

This runs the same action as an outer if is_member: containing an inner if total >= 50:. Both requirements must pass, and the second is reached only after the first passes. Keep nesting when the outer branches need their own different actions, as with buying a ticket.

An else whose only action is another if–else can become an elif chain. For positive, negative, and zero, the flat form is if x > 0:, then elif x < 0:, then else:. It keeps the same three outcomes with less indentation.

Validate before classifying

A grade decision needs to reject scores outside its allowed range before assigning a letter:

if 0 <= score <= 100:
    if score >= 90:
        print("A")
    else:
        print("Below A")
else:
    print("Score must be between 0 and 100")

At score = 150, the outer check fails, so no grade is assigned. Nesting also exposes impossible paths: an inner if x < 5: under if x > 10: can never pass. When indentation grows deep, look for combined requirements, an elif chain, or an earlier validation check that makes the remaining paths clearer.

Python can test a value directly in a condition. Its truthiness decides whether the body runs. This saves comparisons, but the value's truthiness may differ from what its text seems to say.

Recognize falsy values

For the built-in types here, False, None, numeric zero, empty strings, and empty collections are falsy. Nonzero numbers and non-empty strings or collections are truthy.

bool() converts a value to its Boolean truth value. In a condition, if value: makes the same branch choice as if bool(value):. It does not change the stored value into a Boolean.

Test empty input without misreading it

name = input("Name: ")
if name:
    print("Hello", name)
else:
    print("No name entered")

Pressing Enter without typing gives "", so the second body runs. A name made entirely of spaces is non-empty and passes the first test. if name.strip(): instead tests the text after removing surrounding whitespace, so a spaces-only answer fails too.

A yes/no answer needs a different question. if answer: runs for "no" and "False" because both contain characters. To recognize agreement, compare the text, for example answer == "yes". Truthiness checks emptiness, not the meaning of a word.

Keep a valid zero separate from missing data

Suppose quantity is None before a value is supplied and may legitimately be 0. if quantity: rejects both. Use quantity is not None to ask whether a value is present; this accepts zero.

For an actual Boolean variable, direct testing is clear. For other values, x == True does something different from if x:. With x = 5, the truthiness test passes but 5 == True is false; numeric equality treats True as equal to 1, not to every nonzero number.

and and or return a value they inspect

These operators return an operand, which may not be a Boolean:

For or, Python returns the left value if it is truthy; otherwise it evaluates and returns the right value. For and, it returns the left value if it is falsy; otherwise it evaluates and returns the right value.

display_name = name or "Guest" supplies a default for empty input. The same pattern with quantity or 1 replaces a real zero with 1. Use a default this way only when every falsy value means missing. not behaves differently: it always returns True or False. If a stored flag must be Boolean, has_name = bool(name or nickname) converts the selected text to a truth value.

A script can run without a syntax error and still choose the wrong branch. Tracing follows one execution by hand. Testing runs chosen inputs and compares the observed result with the result the rule requires.

Plan and trace a path

Before writing code, state the choices in plain-language steps, or pseudocode. A flowchart puts each condition in a diamond with True and False arrows. Both paths need a clear next step or end.

To trace code, write the starting values, evaluate each reached condition, record assignments, and copy the output exactly. For the grade chain at score = 72:

"Not evaluated" is different from false. Python has already selected a branch, so it does not need the later comparisons.

Cover every branch and boundary

A four-branch chain needs at least four inputs to make every branch run once. Pick them by the intended routes, not by how varied the numbers look. Several high scores may all exercise the same first body.

Branch coverage alone can miss a wrong boundary. For age >= 18, test 17, 18, and 19. A mistaken > passes the outer two checks just as expected but rejects the exact limit. For a grade threshold of 90, compare 89, 90, and 91; do the same at the other thresholds. For decimal inputs, choose nearby values appropriate to the measurement's precision.

Find branches that cannot run

if score >= 60:
    print("Pass")
elif score >= 90:
    print("Excellent")

The second branch is unreachable. Any score at least 90 already passed the first test. Put the more restrictive threshold first, or change the ranges to match the intended rule.

A gap leaves an intended case unhandled: t < 0 followed by t > 0 skips zero. An overlap can make several independent actions run: separate tests t >= 0 and t <= 10 both pass for 5. A chain permits only its first true branch, but its order still decides which overlapping condition wins.

Include awkward inputs

Test negative values, zero, empty text, and uppercase answers when the script expects lowercase. If only "y" and "n" are accepted, give any other text a clear response such as "Please answer y or n".

When a test behaves unexpectedly, inspect the value and its type before evaluating the suspect comparison:

print(repr(age), type(age))

For age = "18", this prints '18' <class 'str'>. Convert the text before trying age >= 18; putting the faulty comparison inside that same debugging print() would raise TypeError before the diagnostic output appears. For structural problems, inspect indentation and the syntax error message.

Finally, a comparison can set a Boolean flag directly: is_adult = age >= 18. It replaces two branches whose only assignments are True and False. Use bool() when the underlying expression may return a different kind of value.

A match statement, available in Python 3.10 and later, tries one value against a series of patterns. That value is the subject. Each case supplies a pattern and an indented body.

Follow the first matching case

command = "stop"
match command:
    case "start":
        print("Starting")
    case "stop":
        print("Stopping")
    case _:
        print("Unknown command")
print("Ready")

The subject is "stop". It does not match "start", so Python tries the next case. "stop" matches, and the body prints Stopping. Python then leaves the entire match and prints Ready. Only one case body runs; there is no fall-through into the next body and no break is needed.

A subject of "jump" reaches the final wildcard pattern, _, which accepts any value. The output is Unknown command, then Ready. Without that case, an unmatched subject simply runs no case body and continues after the statement.

Keep the layout and catch-all in order

The case headers are indented 4 spaces under match, and their bodies another 4 spaces. Every header ends with a colon. An unguarded case _: must be last, because it accepts everything. Putting more cases after it raises SyntaxError: those later patterns could never be reached.

A guarded wildcard can appear earlier because its extra condition may fail. A match in a straight-line script also cannot contain break; that statement requires a surrounding loop.

Understand how literals match

A literal pattern uses a fixed number, string, True, False, or None. String patterns are exact and case-sensitive: "stop" does not match "Stop". Numeric patterns use equality, so case 1: matches 1, 1.0, and True, which equals 1.

The patterns True, False, and None use identity instead. Thus case True: matches the Boolean True but not integer 1. Pattern order matters if a numeric case and a Boolean case could both accept the subject.

Join fixed alternatives with a bar

An OR pattern joins alternatives with |:

day = int(input("Day number: "))
match day:
    case 6 | 7:
        print("Weekend")
    case 1 | 2 | 3 | 4 | 5:
        print("Weekday")
    case _:
        print("Not a day number")

For 6, the first body runs; for 3, the second runs; for 9, the wildcard runs. Without int(), typed "6" stays a string and does not match numeric 6.

Use the pattern separator |, not the Boolean word or. case "y" or "yes": is invalid; case "y" | "yes": is valid.

For fixed commands, an equality-based if–elif chain can produce the same outputs. Choose the layout that makes the cases easiest to read.

Patterns can do more than check a fixed literal. A pattern may give the subject a name, and a guard may check an extra condition before the case is accepted.

Capture first, then check the guard

A capture pattern is a bare name such as n. It accepts any subject and assigns that subject to the name. A guard follows the pattern with if condition; the body runs only if the pattern matches and the guard is true.

temperature = -5
match temperature:
    case 0:
        print("Exactly freezing")
    case t if t < 0:
        print("Below freezing by", -t, "degrees")
    case _:
        print("Above freezing")

At -5, the first literal does not match. The next pattern captures -5 in t, then tests t < 0. The guard is true, so the output is Below freezing by 5 degrees.

At 0, the literal case wins before the capture is tried. At 12, the capture succeeds but the guard fails, so Python tries the wildcard and prints Above freezing. A failed guard does not end the search for a case.

A bare name does not look up a constant

Suppose QUIT = "q". It is tempting to write case QUIT: to check whether the subject equals that value. But a bare name is always a capture, even when uppercase. The case accepts any subject and overwrites QUIT with it.

If further cases follow an unguarded capture, Python reports a syntax error because the capture makes them unreachable. If the capture is last, the mistake can run silently. Compare explicitly with a guard:

QUIT = "q"
key = "x"
match key:
    case k if k == QUIT:
        print("Quit")
    case _:
        print("Keep working")

Here k captures "x". The guard compares it with the existing "q", fails, and lets the wildcard print Keep working. A literal case "q": is simpler when the fixed value can be written directly.

Distinguish a dotted value pattern

A dotted name such as math.pi is a value pattern, not a capture. It looks up an existing value and compares the subject with it using ==. Named constants supplied by modules or classes can use this form. The distinction to recognize is the dot: case n: assigns a name; a dotted pattern checks an existing value.

Name a successful specific match with as

answer = "y"
match answer:
    case "y" | "yes" as accepted:
        print("Accepted:", accepted)
    case _:
        print("Please answer y or yes")

The OR pattern checks the allowed strings, and as stores the subject that matched in accepted. For "y", the output is Accepted: y. It does not replace the input with a standard word: "yes" would store "yes". "Yes" matches neither string because case still matters.

One or two guards can fit naturally among fixed cases. When almost every case is a range test or uses different variables, an if–elif chain is usually clearer. Either structure needs a final catch-all when every input must receive a response.