CPython internals & the GIL

objects.py# Everything is an object: a value, a type, and (in CPython) a refcount.
import sys

x = 42
print("value :", x)
print("type  :", type(x))                 # <class 'int'>
print("id    :", type(id(x)))             # id() -> an int (the address in CPython)
print("is int an object? ", isinstance(int, object))   # True: the TYPE is an object
print("type of int       ", type(int))                 # <class 'type'>

# A function is an object too — you can attach attributes to it.
def greet(name):
    return f"hi {name}"

greet.category = "io"                       # functions carry a __dict__
print("function attr:", greet.category)
print("function type:", type(greet))        # <class 'function'>

# 'everything is an object' means even modules and classes are values you can pass.
print("module is object:", isinstance(sys, object))

disassemble.pyimport dis

def add(a, b):
    total = a + b
    return total

dis.dis(add)

names.py# A name is a label; the object lives on the heap. Assignment rebinds the label.
a = [1, 2, 3]
b = a                 # b labels the SAME list object (no copy)
b.append(4)
print("a:", a)        # a sees the change: [1, 2, 3, 4]
print("same object:", a is b, " id equal:", id(a) == id(b))

a = a + [5]           # + builds a NEW list; a now labels it, b still the old one
print("a:", a)        # [1, 2, 3, 4, 5]
print("b:", b)        # [1, 2, 3, 4]
print("still same?", a is b)   # False

identity.py# is  -> same object (identity, compares id()).   ==  -> equal value.
c = int("1000")       # built at runtime
d = int("1000")       # a DIFFERENT object with the same value
print("c == d:", c == d)        # True  (equal value)
print("c is d:", c is d)        # False (two separate objects)

# CPython caches the small integers -5..256, so these ARE the same object:
m = 100
n = 100
print("100 is 100:", m is n)    # True — cached (an implementation detail!)

# Strings: identical literals are interned by the compiler...
s1 = "hello"
s2 = "hello"
print("literal intern:", s1 is s2)          # True

# ...but strings BUILT at runtime are not automatically interned:
r1 = "".join(["h", "e", "l", "l", "o"])
r2 = "hel" + "lo"
print("runtime is:", r1 is r2, " runtime ==:", r1 == r2)   # False True

refcount.pyimport sys

data = ["a", "b", "c"]
# getrefcount reports one MORE than you might expect: the argument passed to
# getrefcount is itself a temporary reference while the call runs.
print("refs to data:", sys.getrefcount(data))   # 2  (the name + the temp arg)

alias = data                                     # a second name -> +1
print("after alias  :", sys.getrefcount(data))   # 3

del alias                                        # drop that reference -> -1
print("after del     :", sys.getrefcount(data))  # 2

cycles.pyimport gc, weakref

class Node:
    def __init__(self, name):
        self.name = name
        self.ref = None

gc.collect()          # start clean
gc.disable()          # turn OFF the cyclic collector to see refcounting alone

a = Node("a"); b = Node("b")
a.ref = b; b.ref = a   # a <-> b : a reference CYCLE
watch = weakref.ref(a) # a weak ref does NOT keep the object alive

del a, b               # drop our names, but a and b still reference each other
print("alive after del?      ", watch() is not None)  # True: refcount never hit 0

collected = gc.collect()   # the cyclic collector finds and frees the cycle
print("objects reclaimed >=2:", collected >= 2)
print("alive after gc.collect?", watch() is not None) # False
gc.enable()

gil_demo.pyimport time, threading
from multiprocessing import Pool

def cpu_bound(n):
    total = 0
    for i in range(n):
        total += i * i
    return total

N = 20_000_000

# 1) sequential: do the work twice, one after the other
t0 = time.perf_counter()
cpu_bound(N); cpu_bound(N)
seq = time.perf_counter() - t0

# 2) two THREADS: they cannot run Python bytecode at the same time — the GIL
#    lets only one thread hold the interpreter at a time.
t0 = time.perf_counter()
ts = [threading.Thread(target=cpu_bound, args=(N,)) for _ in range(2)]
for t in ts: t.start()
for t in ts: t.join()
thr = time.perf_counter() - t0

# 3) two PROCESSES: each has its OWN interpreter and its OWN GIL -> real parallelism
if __name__ == "__main__":
    t0 = time.perf_counter()
    with Pool(2) as pool:
        pool.map(cpu_bound, [N, N])
    proc = time.perf_counter() - t0

    print(f"sequential   : {seq:.2f}s")
    print(f"2 threads    : {thr:.2f}s   speedup x{seq/thr:.2f}")
    print(f"2 processes  : {proc:.2f}s   speedup x{seq/proc:.2f}")