Using Python Built In Constants

Python
# Correct usage patterns for Python built-in constants

# None: absence of a value, always compare with `is`
def find_user(id):
    result = None
    return result

if result is None:
    print("not found")

# True/False: instances of bool, subclass of int
assert True == 1 and False == 0
assert isinstance(True, int)

# NotImplemented: returned from special methods, not raised
class Vector:
    def __eq__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return self.x == other.x

# Ellipsis (...): placeholder in slicing, stubs, type hints
def stub_function() -> int:
    ...

matrix[..., 0]  # slice shorthand for multi-dim arrays

# __debug__: True unless run with -O flag
if __debug__:
    print("debug mode checks run")
assert some_condition  # skipped entirely when -O is used

# Site-module constants (interactive shell only, not for scripts)
# quit, exit, copyright, credits, license

Progress:

• Identify which constant fits the semantic need (null vs boolean vs unimplemented vs placeholder)
• Use correct comparison idiom (is/is not for None, NotImplemented)
• Never use site-module constants (quit, exit, copyright, etc.) in production code
• Use __debug__ for development-only assertions, not for security or business logic
• Return NotImplemented (don't raise it) inside dunder methods when operation isn't supported

Step 1: Distinguish the six core constants

Step 2: Apply idiomatic patterns

None checks:

Python
if value is None:      # correct
if value == None:      # avoid — triggers __eq__, can misbehave

NotImplemented in operator overloading:

Python
def __lt__(self, other):
    if not isinstance(other, MyClass):
        return NotImplemented   # let Python try other.__gt__ or raise TypeError
    return self.value < other.value

Never do if x == NotImplemented or use it as a boolean — treat it strictly as a return sentinel.

Ellipsis for stubs and slicing:

Python
def not_yet_implemented(): ...

# numpy-style slicing
arr[..., 0]   # equivalent to arr[:, :, 0] for 3D array

debug for assert-guarded code:

Python
if __debug__:
    _validate_invariants()  # stripped out entirely under python -O

Never rely on __debug__/assert for security checks — they vanish under -O.

Step 3: Handle site-module constants correctly

quit, exit, copyright, credits, license are added by the site module only in interactive interpreter sessions. They:

• Are NOT guaranteed to exist in scripts, embedded interpreters, or when run with -S
• Should never be used programmatically (e.g., exit() in a script) — use sys.exit() instead
• Exist purely for human convenience at the REPL

Python
# Bad: script relying on interactive-only builtins
exit()  # may not exist if site module wasn't imported

# Good:
import sys
sys.exit(0)

Example 1: Input: Function should return None when no match is found, and caller needs to check. Output:

Python
def find(items, target):
    for item in items:
        if item == target:
            return item
    return None

result = find([1, 2, 3], 5)
if result is None:
    print("Not found")

Example 2: Input: Implement __eq__ for a custom class that should support comparison only with same type. Output:

Python
class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented
        return self.x == other.x and self.y == other.y

Example 3: Input: Write a type stub file (.pyi) function signature with no body. Output:

Python
def process(data: list[int]) -> dict[str, int]: ...

Example 4: Input: Code has assert isinstance(x, int) used to validate untrusted user input for a security check. Output: Flag as pitfall — replace with explicit runtime check:

Python
if not isinstance(x, int):
    raise TypeError("x must be int")

Reason: assert and reliance on __debug__ are removed with -O, so security-critical validation must never depend on them.