Summary  
This chapter covers logical operators (and, or, not) for combining and negating Boolean conditions, explains their precedence and truth tables, and shows how short-circuit evaluation can return operands instead of just True/False.

General domain of usage  
Conditional decision making and control flow.

People say **yes and yes**, **yes or no**, **definitely not**. In Python, the logical operators **`and`**, **`or`**, and **`not`** express these ideas formally and produce Booleans (`True`/`False`) you'll use with comparisons in `if`/`while`.

Watch this video for a clear explanation of logical operators in Python. You'll see how `and`, `or`, and `not` work in real code, how short-circuiting happens, and how to use these operators to control program flow. The video includes practical examples and visualizations to help you master logical expressions and their results.

### Precedence
`not` binds tighter than `and`, which binds tighter than `or` (`not > and > or`). Use parentheses when in doubt.

For instance, `age >= 18 and has_id` is `True` only if both checks succeed:

age = 21
has_id = True
print(age >= 18 and has_id)   # True

## Truth Table

A **truth table** lists all possible truth values of inputs and shows the resulting output of a logical expression. It's a compact way to reason about logic without running code.


### Using the Table
If `X` is `False` and `Y` is `True`, then `X and Y` is `False`, `X or Y` is `True`, and `not X` is `True`.


## Return Values & Short-Circuiting (Together)

`and` and `or` don't always yield the words `True`/`False`, they return **one of their operands**, and Python may stop early once the result is known.

* `A and B`:

  * If `A` is falsey, the whole expression is false and the result is `A` (Python does not evaluate `B`);
  * If `A` is truthy, the result depends on `B` and the expression evaluates to `B`.

* `A or B`:

  * If `A` is truthy, the expression is true and the result is `A` (Python does not evaluate `B`);
  * If `A` is falsey, the result depends on `B` and the expression evaluates to `B`.

* `not X` always returns an actual Boolean: `True` or `False`.

# Choosing a display name for a user profile
username = ""             # user didn't set a custom name
print(username or "Guest")   # "Guest" → fallback to default name

username = "Alice"
print(username or "Guest")   # "Alice" → custom name is used

# Checking login attempts and access permissions
login_attempts = 0
access_level = 123
print(login_attempts and access_level)  # 0 → login not yet attempted

login_attempts = 5
print(login_attempts and access_level)  # 123 → user has access after attempts

# Checking empty and non-empty values
print(not 0, not "Hello")  # True False → 0 is falsey, non-empty string is truthy

Which statement matches classical logic for "neither X nor Y"?

Logical Operators

What Each Operator Means

Precedence

Truth Table

Using the Table

Return Values & Short-Circuiting (Together)

1. Fill the blanks with `True` or `False`). Let `X = True`, `Y = False`.

2. Which statement matches classical logic for "neither X nor Y"?

3. What does the expression return?