Python Variables and Data Types — Language Specification¶

# Arithmetic dunders (binary operations return NotImplemented if not supported)
__add__(self, other)       # self + other
__radd__(self, other)      # other + self (reflected)
__iadd__(self, other)      # self += other (in-place; returns self)
__sub__, __rsub__, __isub__
__mul__, __rmul__, __imul__
__truediv__, __rtruediv__, __itruediv__    # /
__floordiv__, __rfloordiv__, __ifloordiv__ # //
__mod__, __rmod__, __imod__               # %
__pow__, __rpow__, __ipow__               # **
__matmul__, __rmatmul__, __imatmul__      # @
__neg__(self)        # unary -
__pos__(self)        # unary +
__abs__(self)        # abs()
__invert__(self)     # ~
__round__(self[, n]) # round()
__trunc__(self)      # math.trunc()
__floor__(self)      # math.floor()
__ceil__(self)       # math.ceil()

__lt__(self, other)  # <
__le__(self, other)  # <=
__eq__(self, other)  # ==  (default: identity)
__ne__(self, other)  # !=  (default: not __eq__)
__gt__(self, other)  # >
__ge__(self, other)  # >=

__int__(self)    -> int
__float__(self)  -> float
__complex__(self)-> complex
__index__(self)  -> int    # used by slices and bin()/oct()/hex()
__str__(self)    -> str
__repr__(self)   -> str
__bool__(self)   -> bool
__bytes__(self)  -> bytes

# PEP 604 — X | Y union type
type.__or__(cls, other)  # int | str -> Union[int, str]

a = 256
b = 256
print(a is b)   # True  (CPython small int cache: [-5, 256])

a = 257
b = 257
print(a is b)   # False in general (may be True in same code object)

nan = float('nan')
print(nan == nan)   # False  (IEEE 754)
print(nan != nan)   # True
import math
print(math.isnan(nan))   # True  (use this to check for NaN)

print(True + True)    # 2
print(True * 10)      # 10
print(False + 1)      # 1
print(isinstance(True, int))   # True

x: int          # annotates x but does NOT bind x
# print(x)     # NameError: name 'x' is not defined

class Foo:
    x: int      # adds 'x' to Foo.__annotations__ but does not create attribute

# Correct: use 'is' for None checks
if value is None:
    ...
if value is not None:
    ...

# Incorrect: '==' can be overridden by __eq__
if value == None:   # works but not idiomatic or safe
    ...

# TRAP: default argument is evaluated once at function definition time
def append_to(item, lst=[]):
    lst.append(item)
    return lst

print(append_to(1))   # [1]
print(append_to(2))   # [1, 2]  — same list object!

# Correct pattern:
def append_to_safe(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

# In Python, 1 < x < 10 is equivalent to (1 < x) and (x < 10)
# Each operand is evaluated only once
x = 5
print(1 < x < 10)   # True

# But be careful:
print(1 < 3 > 2)    # True   (1 < 3) and (3 > 2)

type Vector = list[float]       # creates a TypeAliasType object
type Matrix[T] = list[list[T]]  # generic type alias

# ----------------------------------------------------------------
# 1. Basic variable binding and rebinding
# ----------------------------------------------------------------
x = 42
print(type(x))    # <class 'int'>
x = "hello"       # rebinding — x now points to a str object
print(type(x))    # <class 'str'>


# ----------------------------------------------------------------
# 2. Standard numeric types
# ----------------------------------------------------------------
i = 1_000_000          # int with underscore separator (PEP 515)
f = 3.14_159           # float
c = 2 + 3j             # complex
b = True               # bool (subclass of int)

print(isinstance(b, int))   # True
print(int(b))               # 1
print(f * 2)                # 6.28318


# ----------------------------------------------------------------
# 3. Integer arbitrary precision
# ----------------------------------------------------------------
big = 2 ** 100
print(big)          # 1267650600228229401496703205376
print(type(big))    # <class 'int'>


# ----------------------------------------------------------------
# 4. float IEEE 754 edge cases
# ----------------------------------------------------------------
inf = float('inf')
nan = float('nan')
print(inf > 1e308)           # True
print(nan == nan)            # False  (IEEE 754)
import math
print(math.isnan(nan))       # True
print(math.isinf(inf))       # True


# ----------------------------------------------------------------
# 5. str: immutable, Unicode
# ----------------------------------------------------------------
s = "Hello, \u4e16\u754c"    # Unicode code points
print(s)                      # Hello, 世界
print(len(s))                 # 8  (code points, not bytes)
print(s.encode("utf-8"))      # b'Hello, \xe4\xb8\x96\xe7\x95\x8c'


# ----------------------------------------------------------------
# 6. bytes vs bytearray
# ----------------------------------------------------------------
b_imm = b"\x41\x42\x43"    # bytes (immutable)
b_mut = bytearray(b_imm)    # bytearray (mutable)
b_mut[0] = 0x61             # change 'A' to 'a'
print(b_mut)                # bytearray(b'aBC')
print(b_imm)                # b'ABC'  — unchanged


# ----------------------------------------------------------------
# 7. Type annotation (PEP 526) — metadata only
# ----------------------------------------------------------------
name: str = "Alice"
age: int               # annotated but NOT bound
scores: list[float] = [9.5, 8.0, 7.5]

print(__annotations__)   # shows annotations in module scope


# ----------------------------------------------------------------
# 8. Union type syntax (PEP 604, Python 3.10+)
# ----------------------------------------------------------------
def stringify(value: int | float | None) -> str:
    if value is None:
        return "nothing"
    return str(value)

print(stringify(42))     # "42"
print(stringify(3.14))   # "3.14"
print(stringify(None))   # "nothing"


# ----------------------------------------------------------------
# 9. isinstance with union types (Python 3.10+)
# ----------------------------------------------------------------
val = 42
print(isinstance(val, int | float))   # True


# ----------------------------------------------------------------
# 10. Type alias with 'type' statement (Python 3.12, PEP 695)
# ----------------------------------------------------------------
type Point = tuple[float, float]
type Matrix[T] = list[list[T]]

# At runtime:
print(type(Point))    # <class 'typing.TypeAliasType'>
print(Point.__value__)  # tuple[float, float]


# ----------------------------------------------------------------
# 11. Augmented assignment: mutable vs immutable
# ----------------------------------------------------------------
# Immutable: rebind
n = 10
original_id = id(n)
n += 1
print(id(n) == original_id)   # False — new int object

# Mutable: in-place
lst = [1, 2, 3]
original_id = id(lst)
lst += [4, 5]   # calls __iadd__
print(id(lst) == original_id)   # True — same list object


# ----------------------------------------------------------------
# 12. None as sentinel
# ----------------------------------------------------------------
def connect(host: str, port: int | None = None) -> str:
    if port is None:
        port = 443
    return f"{host}:{port}"

print(connect("example.com"))        # example.com:443
print(connect("example.com", 8080))  # example.com:8080