What is the common pitfall with Using `== None` Instead of `is None`?

Custom classes can override __eq__ to return unexpected booleans. `is None` is guaranteed and faster. Exam trap note: PEP 8 explicitly mandates checking singletons with `is None` or `is not None`.

What are the core concepts of Python Operators?

Equality operator (==) checks whether two objects have equivalent contents by delegating to `__eq__()`. Identity operator (`is`) checks whether two references point to the exact same memory address: `id(a) == id(b)`. CPython pre-allocates and caches small integers (-5 to 256) and interned string literals for memory efficiency.

← Previous: Python Booleans & Logical Evaluation All Modules Next: Python Lists (Arrays) →

MOD-08 · Sequence #8 · Python Logic

Python Operators

Q: What does `a is b` evaluate in Python?

The `is` operator checks memory identity: whether both references point to the same physical object in heap. (Correct: Checks if id(a) == id(b) (same memory address))

Understanding operator categories: arithmetic, bitwise, comparison, logical, identity (`is` vs `==`), and membership (`in`). The distinction between object equality (==) and identity (is) is one of the most frequently tested topics in undergraduate exams.

Live Interactive Code Snippet (Python 3.12 CPython WASM) Open in Practice Mode →

x = [1, 2]
y = [1, 2]
print(x == y)  # True (equal values)
print(x is y)  # False (different heap identities)

Core Principles & Mental Models

1. Identity (`is`) vs. Equality (`==`)

Memory Pointer vs. Value Equivalence

Equality operator (==) checks whether two objects have equivalent contents by delegating to `__eq__()`.
Identity operator (`is`) checks whether two references point to the exact same memory address: `id(a) == id(b)`.
CPython pre-allocates and caches small integers (-5 to 256) and interned string literals for memory efficiency.

list1 = [1, 2, 3]
list2 = [1, 2, 3]
print("list1 == list2:", list1 == list2)  # True (equal contents)
print("list1 is list2:", list1 is list2)  # False (distinct heap objects!)

# Comparing to None must always use 'is'
x = None
print("x is None:", x is None)

💡 Key Takeaway: Always use `==` for comparing values, and reserved `is` strictly for singleton checks like `x is None`.

2. Membership Operators (`in` and `not in`)

Time Complexity Differences Across Data Structures

The `in` operator checks if an item exists within a container.
In lists and tuples: `item in my_list` takes O(N) linear time search.
In sets and dictionaries: `key in my_dict` takes O(1) average constant time hash table lookup.

valid_roles = {"admin", "instructor", "ta"}
print("'student' in valid_roles:", "student" in valid_roles)  # O(1) lookup!

💡 Key Takeaway: Choose sets over lists when performing frequent membership checks in large datasets.

Interactive Walkthrough Examples

Chained Comparison Operators (Basic)

Using mathematical chained comparisons unique to Python.

x = 15
# In C/Java: (10 < x) && (x < 20)
# In Python: clean mathematical chain
is_in_range = 10 < x < 20
print("10 < 15 < 20:", is_in_range)

Explanation: Python chains comparisons seamlessly: `a < b < c` translates to `a < b and b < c`.

Common Misconceptions & Exam Traps

Common Pitfall: Using `== None` Instead of `is None`

Custom classes can override __eq__ to return unexpected booleans. `is None` is guaranteed and faster.

Buggy Code

if result == None:  # Flawed: classes can override __eq__ to return True deceptively!
    pass

Correct Solution

if result is None:  # PEP 8 standard: guaranteed identity check
    pass

Exam Trap Note: PEP 8 explicitly mandates checking singletons with `is None` or `is not None`.

Conceptual Knowledge Self-Check Quiz

Q1: What does `a is b` evaluate in Python?

Checks if a and b have the same data values
Checks if id(a) == id(b) (same memory address)
Checks if a is a subclass of b
Checks if a and b have the same length

The `is` operator checks memory identity: whether both references point to the same physical object in heap.

Algorithmic Practice Challenges

Idiomatic Best Practices

✅ Never compare numbers or strings with `is` — always use `==`.
✅ Leverage chained comparisons (0 <= grade <= 100) for readable condition statements.

← Python Booleans & Logical Evaluation Take Assessed Test → Python Lists (Arrays) →

All 26 Curriculum Modules

MOD-01: Python Syntax & Indentation — Whitespace blocks, execution statements, and semicolon absence in Python.
MOD-02: Python Comments — Single-line comments (#) and multiline docstrings.
MOD-03: Python Variables & Dynamic Binding — Variable creation, dynamic typing, unpacking, and multiple assignment.
MOD-04: Python Data Types — Built-in fundamental types: int, float, str, bool, list, tuple, dict, set, None.
MOD-05: Python Numbers & Type Casting — Int, float, complex numbers, and casting via int(), float(), str().
MOD-06: Python Strings & Slicing — String arrays, indexing [start:stop:step], negative indices, and string methods.
MOD-07: Python Booleans & Logical Evaluation — Boolean truth values, truthy vs falsy values, and logical operators.
MOD-08: Python Operators — Arithmetic, assignment, comparison, logical, identity (is), and membership (in).
MOD-09: Python Lists (Arrays) — Ordered, mutable sequences, indexing, append, insert, remove, pop, and list comprehensions.
MOD-10: Python Tuples — Ordered, immutable sequences, unpacking, and tuple hashing for dictionary keys.
MOD-11: Python Sets — Unordered, unindexed collections of unique elements; union, intersection, difference.
MOD-12: Python Dictionaries — Key-value associative mappings, keys(), values(), items(), and dict comprehensions.
MOD-13: Python If...Else & Branching — Conditional branching, elif ladder, nested conditions, and ternary conditional operators.
MOD-14: Python While Loops — Conditional loops, break, continue, and the while...else loop construct.
MOD-15: Python For Loops & Range — Sequence iteration, range(start, stop, step), enumerate(), and zip().
MOD-16: Python Functions & Parameters — def declarations, positional args, keyword args, *args, **kwargs, and return statements.
MOD-17: Python Lambda Functions — Anonymous inline functions, map(), filter(), and sorted(key=lambda).
MOD-18: Python Classes & Objects (OOP) — Class definition, the __init__ constructor, the self receiver, and instance methods.
MOD-19: Python Inheritance & Polymorphism — Subclassing, super() initializer, method overriding, and polymorphism.
MOD-20: Python Iterators & Generators — __iter__ and __next__ protocols, and generator functions with the yield keyword.
MOD-21: Python Scope & LEGB Rule — Local, Enclosing, Global, and Built-in namespaces; global and nonlocal keywords.
MOD-22: Python Modules & Packages — import, from ... import ..., as alias, dir() inspection, and __name__ == "__main__".
MOD-23: Python Dates & Math — datetime module (now, strftime, strptime) and math functions (pow, sqrt, ceil, floor).
MOD-24: Python JSON & Regular Expressions — json.loads(), json.dumps(), and the re module (search, findall, sub, split).
MOD-25: Python Try...Except & Error Handling — Exception catching with try, except, else, finally, and raising custom exceptions.
MOD-26: Python File Handling — File open modes ("r", "w", "a", "x"), with context manager, and os removal.