Summary  
This chapter introduces logical operators (`and`, `or`, `not`) in Python, explaining their precedence, truth-table behavior, and short-circuit evaluation that can return operands instead of just `True`/`False`.  

General domain of usage  
User authentication and default value handling (e.g., login checks and profile name fallbacks)

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`.

### 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"?

Gain a solid understanding of Python's core data types and learn how to work with them effectively. Explore numbers, booleans, and strings through hands-on exercises and practical examples. Build confidence in performing basic operations and develop the foundational skills needed to write clean and efficient Python code.

Discover the essentials of numerical data types in Python and learn how to work with integers and floating-point numbers. Master basic arithmetic operations, explore the concept of immutability, and get hands-on experience using Python's built-in functions and tools to handle numbers efficiently in real-world scenarios.

Gain a clear understanding of the Boolean data type, a specialized subtype of numeric data that represents truth values. Although it may seem challenging at first, mastering Booleans is essential for writing logical and efficient programs. This section will help you confidently apply Boolean logic to real-world programming scenarios.

Strings allow you to work with text in Python, from displaying messages to processing user input. You'll explore how to create, modify, and manipulate strings effectively. Understanding strings is essential for writing interactive programs and communicating information clearly through your code.

Learn how to handle data types effectively to ensure accuracy and consistency in your programs. Convert values to the appropriate type, clean text before comparison, and separate numeric operations from text formatting. You'll also discover how to manage missing data deliberately and handle human-readable text differently from raw input, achieving reliable, consistent, and easy-to-read results.

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?