02 — Variables & Data Types

# Every Python object starts with a C-level PyObject header:
#   struct PyObject { Py_ssize_t ob_refcnt; PyTypeObject *ob_type; }
# `id()` returns the address of this struct — that's why `is` is a pointer compare.

import sys, ctypes

# ── Refcount introspection ──
# Every object tracks how many names/containers reference it.
# When refcnt hits 0, CPython IMMEDIATELY deallocates (no GC pause needed).
obj = [1, 2, 3]
print(sys.getrefcount(obj))   # 2 — `obj` + the temporary arg passed to getrefcount

alias = obj                    # refcnt → 3
print(sys.getrefcount(obj))   # 3

import weakref
weak = weakref.ref(obj)       # weakref does NOT increment refcnt
print(sys.getrefcount(obj))   # still 3 — weak references don't keep objects alive

# ── The cycle-collecting generational GC ──
# Refcounting can't handle reference cycles. A separate 3-generation GC handles those.
import gc
gc.disable()                  # pause GC to observe refcount-only behavior

a = {}; b = {}
a["link"] = b                 # a → b: b.refcnt = 2 (b + a['link'])
b["link"] = a                 # b → a: a.refcnt = 2 (a + b['link'])
del a; del b                   # both refcnts are now 1 — they reference EACH OTHER but nothing references them
                               # refcounting can't free them — only the cycle GC can
gc.enable()
collected = gc.collect()       # manually triggers cycle detection — frees the orphaned cycle
print(f"GC collected {collected} objects in cycles")

# ── Production: zero-copy data exchange via the buffer protocol ──
# Different types (bytes, bytearray, array.array, numpy.ndarray, memoryview)
# can share raw memory without copying — the buffer protocol exposes the C-level pointer.

import array, struct

# Pack binary data into an array — contiguous C memory, not Python int objects
buf = array.array('I', [0xDEADBEEF, 0xCAFEBABE, 0x12345678])
view = memoryview(buf)          # zero-copy view — no data copied, just a pointer + length

# Cast the view to bytes to inspect raw memory layout (little-endian on x86)
raw = view.cast('B')            # reinterpret as unsigned bytes
print(bytes(raw[:4]))           # b'\xef\xbe\xad\xde' — DEADBEEF in LE

# Modify through the view — original buffer changes, no copy
view[0] = 0xFFFFFFFF
print(buf[0])                   # 4294967295 — mutated through the view

x = 42          # x refers to an int
x = "forty-two" # now x refers to a str — perfectly legal
x = [42]        # now a list

"3" + 3
# TypeError: can only concatenate str (not "int") to str

int("3") + 3      # 6
"3" + str(3)      # "33"

import sys, struct, ctypes

# ── int: arbitrary precision via digit arrays ──
# Small ints (-5..256) are pre-allocated singletons — `is` accidentally works.
# Large ints are PyLongObject with an array of 30-bit digits.
print(sys.getsizeof(0))           # 24 bytes — base PyObject overhead
print(sys.getsizeof(1))           # 28 bytes — one digit
print(sys.getsizeof(2**30))       # 32 bytes — one 30-bit digit
print(sys.getsizeof(2**60))       # 36 bytes — two 30-bit digits
print(sys.getsizeof(2**1000))     # 160 bytes — ~34 digits, no overflow ever

# The small-int cache is observable — and is a CPython implementation detail, not a guarantee
a, b = 256, 256
print(a is b)                     # True — both resolve to the cached singleton
a, b = 257, 257
print(a is b)                     # False (usually) — separate allocations outside cache range
# NEVER use `is` for value comparison — use `==`. `is` on ints is a latent bug.

# ── float: IEEE-754 binary64, 8 bytes ──
# Sign(1) + exponent(11) + mantissa(52) = 64 bits
x = -0.0
packed = struct.pack('>d', x)     # big-endian IEEE-754 bytes
print(packed.hex())               # 8000000000000000 — sign bit set, rest zero
print(x == 0.0)                   # True — -0.0 == 0.0 per IEEE-754
print(struct.pack('>d', 0.0).hex())  # 0000000000000000 — different bit pattern, same value

# float('inf'), float('nan') are valid IEEE-754 special values
inf = float('inf')
print(inf > 1e308)                # True
print(inf + 1 == inf)             # True — infinity absorbs addition
nan = float('nan')
print(nan == nan)                 # False! NaN is never equal to itself — use math.isnan()
print(nan is nan)                 # True — same object, but == is False

# ── bool: a subclass of int with singleton instances ──
# True and False are the ONLY two bool instances. bool inherits ALL int operations.
print(isinstance(True, int))      # True — bool IS-A int in the type hierarchy
print(True + True + True)         # 3 — bool arithmetic produces int
print(sum([True, False, True]))   # 2 — bools are 1/0 in numeric contexts

# ANTI-PATTERN: using `isinstance(x, int)` to validate a "count" — bools pass!
def bad_count_validator(x):
    if isinstance(x, int):
        return x               # True/False silently accepted as 1/0
    raise TypeError

# CORRECT: exclude bool explicitly when the distinction matters
def good_count_validator(x):
    if isinstance(x, int) and not isinstance(x, bool):
        return x
    raise TypeError(f"expected int, got {type(x).__name__}")

def get_config(key):
    config = {"debug": False, "timeout": 0}
    return config.get(key)  # returns None if key is absent

value = get_config("missing_key")
if value == 0:
    print("This never runs — None != 0")
if value is None:
    print("Correct check")   # this runs

class Animal:
    pass

class Dog(Animal):
    pass

d = Dog()

print(type(d) == Dog)          # True
print(type(d) == Animal)       # False — type() is exact, no inheritance awareness
print(isinstance(d, Animal))   # True — isinstance() respects the class hierarchy
print(isinstance(d, Dog))      # True
print(isinstance(True, int))   # True — bool IS-A int
print(type(True) == int)       # False — exact type is bool, not int

# isinstance also accepts a tuple of types
def normalize(value):
    if isinstance(value, (int, float)):
        return float(value)
    if isinstance(value, str):
        return value.strip().lower()
    raise TypeError(f"Unsupported type: {type(value).__name__}")

class Duck:
    def quack(self):
        return "Quack!"

class Person:
    def quack(self):
        return "I'm quacking (I'm a person)"

def make_it_quack(thing):
    # No isinstance check at all — we just trust it has .quack()
    return thing.quack()

print(make_it_quack(Duck()))
print(make_it_quack(Person()))

# LBYL — checks first, then acts (race conditions possible, verbose)
if hasattr(obj, "quack") and callable(obj.quack):
    obj.quack()

# EAFP — idiomatic Python: try it, handle failure
try:
    obj.quack()
except AttributeError:
    print("Object can't quack")

x = "42"
print(type(x))          # <class 'str'>
print(int(x))            # 42          — parses a numeric string
print(int("3.14"))       # ValueError: invalid literal for int() with base 10: '3.14'
print(int(float("3.14"))) # 3          — go through float first, truncates toward zero
print(str(42))            # "42"
print(bool(""))            # False — empty string is falsy
print(bool("False"))       # True  — NON-empty string, even "False", is truthy!

values = [0, 1, "", "0", [], [0], {}, None, False, True, 0.0, -0.0]
for v in values:
    print(f"{v!r:>8} -> {bool(v)}")

       0 -> False
       1 -> True
      '' -> False
     '0' -> True
      [] -> False
     [0] -> True
      {} -> False
    None -> False
   False -> False
    True -> True
     0.0 -> False
    -0.0 -> False

# Valid identifiers: letters, digits, underscore; can't start with a digit
valid_name = 1
_private_by_convention = 2
__name_mangled_in_classes = 3
CONSTANT_STYLE = 4          # convention only — Python has no true constants

# Invalid:
# 1st_place = "x"    # SyntaxError — can't start with digit
# my-var = "x"       # SyntaxError — hyphen is the subtraction operator

a = 256
b = 256
print(a is b)     # ?

c = 257
d = 257
print(c is d)     # ?

e = -5
f = -5
print(e is f)     # ?

g = -6
h = -6
print(g is h)     # ?