Python Internals Deep Dive

import dis

def add_numbers(a, b):
    return a + b

# Disassemble the function
dis.dis(add_numbers)

import dis

# Approach 1: Using append in loop
def sum_with_append():
    result = []
    for i in range(5):
        result.append(i * 2)
    return result

print("=== Approach 1: append in loop ===")
dis.dis(sum_with_append)

import dis

# Approach 2: List comprehension
def sum_with_comprehension():
    return [i * 2 for i in range(5)]

print("=== Approach 2: list comprehension ===")
dis.dis(sum_with_comprehension)

import dis

def check_value(x):
    if x > 10:
        return "large"
    else:
        return "small"

dis.dis(check_value)

import dis

def outer(x):
    def inner(y):
        return x + y  # 'x' is a closure variable
    return inner

closure_func = outer(10)

# The cell repr carries memory addresses, so read what it holds instead
print(f"Closure variables: {closure_func.__code__.co_freevars}")
print(f"Captured value: {closure_func.__closure__[0].cell_contents}")

dis.dis(closure_func)

def example(a, b):
    x = a + b
    return x * 2

# Access the code object
code = example.__code__

print(f"Function name: {code.co_name}")
print(f"Argument count: {code.co_argcount}")
print(f"Local variables: {code.co_varnames}")
print(f"Bytecode: {code.co_code}")
print(f"Constants: {code.co_consts}")
print(f"Line numbers: {code.co_firstlineno}")

import inspect

def outer():
    x = 10
    inner()

def inner():
    y = 20
    # Inspect the current frame
    frame = inspect.currentframe()

    print(f"Current function: {frame.f_code.co_name}")
    # f_locals holds the frame object itself too, and its repr carries an
    # address, so print the names rather than the whole dict
    print(f"Local names: {sorted(frame.f_locals)}")
    print(f"y is still: {frame.f_locals['y']}")
    print(f"Line number: {frame.f_lineno}")

    # Walk up the call stack
    caller_frame = frame.f_back
    print(f"\nCaller function: {caller_frame.f_code.co_name}")
    print(f"Caller locals: {caller_frame.f_locals}")

outer()

import inspect

def print_call_stack():
    """Print the call stack manually"""
    frame = inspect.currentframe()

    print("Call Stack:")
    while frame:
        code = frame.f_code
        # code.co_filename is available too, but it is an absolute path,
        # so print the names to keep the output the same on every machine
        print(f"  {code.co_name} (line {frame.f_lineno})")
        frame = frame.f_back

def level3():
    print_call_stack()

def level2():
    level3()

def level1():
    level2()

level1()

import threading
import time

# Global counter (shared between threads)
counter = 0

def increment():
    global counter
    for _ in range(20_000):
        temp = counter
        time.sleep(0)   # hands the GIL to the other thread, mid-update
        counter = temp + 1

# Run with two threads
threads = [threading.Thread(target=increment) for _ in range(2)]
start = time.perf_counter()

for t in threads:
    t.start()
for t in threads:
    t.join()

end = time.perf_counter()

print(f"Final counter: {counter}")
print(f"Time: {end - start:.3f}s")

# Without the time.sleep(0) this prints exactly 40000 every run, which is
# misleading. "counter += 1" compiles to three separate bytecodes
# (LOAD_GLOBAL, ADD, STORE_GLOBAL) and a thread switch can land between any
# two of them. The GIL only guarantees that one thread runs bytecode at a
# time; it does not make a multi-step update atomic.

import threading
import time

def cpu_bound():
    """CPU-bound task (GIL held)"""
    total = 0
    for i in range(10_000_000):
        total += i
    return total

def io_bound():
    """I/O-bound task (GIL released)"""
    time.sleep(0.1)  # Simulates I/O
    return "done"

def timed(fn, n, threaded):
    """Run fn n times, either on n threads or one after another"""
    start = time.perf_counter()
    if threaded:
        threads = [threading.Thread(target=fn) for _ in range(n)]
        for t in threads:
            t.start()
        for t in threads:
            t.join()
    else:
        for _ in range(n):
            fn()
    return time.perf_counter() - start

for label, fn, n in [("CPU-bound", cpu_bound, 2), ("I/O-bound", io_bound, 10)]:
    parallel = timed(fn, n, threaded=True)
    serial = timed(fn, n, threaded=False)
    print(f"{label}: {parallel:.3f}s threaded vs {serial:.3f}s sequential "
          f"-> {serial / parallel:.1f}x")

import sys

# sys.modules is a dict of every module already imported
print(f"Total modules loaded: {len(sys.modules)}")

# 'os' is a poor example of "not yet imported": the interpreter loads it
# during startup, so it is already in sys.modules before your first line.
print(f"'os' imported: {'os' in sys.modules}")

# Use a module the interpreter does not preload to see the difference:
print(f"'json' imported: {'json' in sys.modules}")

import json
print(f"'json' imported now: {json.__name__ in sys.modules}")
print(f"Total modules loaded: {len(sys.modules)}")

import os

# Get the module object. In 3.11+ 'os' is frozen into the binary, so its
# repr says (frozen) rather than naming a file, but __file__ still resolves.
os_module = sys.modules['os']
print(f"Module object: {os_module}")
print(f"Same object the name 'os' is bound to: {os_module is os}")
print(f"Module file: {os_module.__file__}")

import sys

# sys.path is a list of directories Python searches for modules, in order
print("Module search paths:")
for path in sys.path[:5]:  # Show first 5
    print(f"  {path}")

# Add a custom path (useful for development)
before = len(sys.path)
sys.path.insert(0, '/my/custom/modules')

# Now Python will search /my/custom/modules first
print(f"First entry: {sys.path[0]}")
print(f"Entries added: {len(sys.path) - before}")

import sys
from importlib.abc import MetaPathFinder, Loader
from importlib.machinery import ModuleSpec

class CustomLoader(Loader):
    """Loader that generates module code on-the-fly"""

    def exec_module(self, module):
        # Generate code dynamically
        code = """
def generated_function():
    return "This module was generated dynamically!"
"""
        exec(code, module.__dict__)

class CustomFinder(MetaPathFinder):
    """Finder that intercepts imports for 'dynamic_' prefix"""

    def find_spec(self, fullname, path, target=None):
        if fullname.startswith("dynamic_"):
            return ModuleSpec(
                fullname,
                CustomLoader(),
                origin="custom-importer"
            )
        return None

# Install the custom finder
sys.meta_path.insert(0, CustomFinder())

# There is no dynamic_module.py anywhere on disk, yet this import resolves
import dynamic_module

print(dynamic_module.generated_function())
print(f"Loaded from: {dynamic_module.__spec__.origin}")

import importlib
import pathlib
import sys
import tempfile

# Create a real module on disk so the reload below has something to re-read
tmp = pathlib.Path(tempfile.mkdtemp())
(tmp / "my_module.py").write_text("VALUE = 'first version'\n")
sys.path.insert(0, str(tmp))

# Standard import
import my_module
print(my_module.VALUE)

# The file changes on disk...
(tmp / "my_module.py").write_text("VALUE = 'second version'\n")

# ...but importing again just hands back the cached object in sys.modules
import my_module
print(my_module.VALUE)

# reload() re-executes the file and updates that same module object in place
importlib.reload(my_module)
print(my_module.VALUE)

# Useful for development/debugging without restarting Python

import importlib
import sys
import time

# Measure import time. asyncio stands in for a heavy third-party library
# here so the snippet runs anywhere: it drags in selectors, socket, ssl
# and about a hundred more modules. import_module is what the plain
# "import asyncio" statement calls into, and it is easier to time.
before = len(sys.modules)
start = time.perf_counter()
importlib.import_module("asyncio")
end = time.perf_counter()

print(f"Import time: {end - start:.3f}s")
print(f"Modules pulled in: {len(sys.modules) - before}")

# Asking for it a second time is a dict lookup in sys.modules, nothing more
start = time.perf_counter()
importlib.import_module("asyncio")
print(f"Second import: {time.perf_counter() - start:.6f}s")

# Lazy imports (defer until needed) keep that cost off your startup path
def process_data():
    import pandas as pd  # Only imported when the function is called
    return pd.DataFrame()

import ast

code = """
def add(a, b):
    return a + b
"""

# Parse code into AST
tree = ast.parse(code)

# Pretty print the AST
print(ast.dump(tree, indent=2))

import ast

class FunctionVisitor(ast.NodeVisitor):
    """Find all function definitions"""

    def visit_FunctionDef(self, node):
        print(f"Found function: {node.name}")
        print(f"  Arguments: {[arg.arg for arg in node.args.args]}")
        print(f"  Line: {node.lineno}")
        self.generic_visit(node)  # Continue visiting child nodes

code = """
def foo(x):
    return x * 2

def bar(y, z):
    return y + z
"""

tree = ast.parse(code)
visitor = FunctionVisitor()
visitor.visit(tree)

import ast

class FunctionDebugger(ast.NodeTransformer):
    """Add print statement at start of every function"""

    def visit_FunctionDef(self, node):
        # Create a print statement: print(f"Calling {function_name}")
        print_stmt = ast.Expr(
            value=ast.Call(
                func=ast.Name('print', ctx=ast.Load()),
                args=[ast.Constant(f"Calling {node.name}")],
                keywords=[]
            )
        )

        # Insert print at start of function body
        node.body.insert(0, print_stmt)

        return node

# Original code
code = """
def greet(name):
    return f"Hello, {name}"

def calculate(x):
    return x * 2
"""

# Parse, transform, and compile
tree = ast.parse(code)
transformer = FunctionDebugger()
new_tree = transformer.visit(tree)
ast.fix_missing_locations(new_tree)  # Required after modification

# Compile and execute
compiled = compile(new_tree, '<ast>', 'exec')
namespace = {}
exec(compiled, namespace)

# The functions now announce themselves, though the source never said so
greet = namespace['greet']
calculate = namespace['calculate']

print(greet("Alice"))
print(calculate(10))

import ast

# Build AST programmatically
module = ast.Module(
    body=[
        ast.FunctionDef(
            name='multiply',
            args=ast.arguments(
                args=[ast.arg('x'), ast.arg('y')],
                defaults=[]
            ),
            body=[
                ast.Return(
                    value=ast.BinOp(
                        left=ast.Name('x', ctx=ast.Load()),
                        op=ast.Mult(),
                        right=ast.Name('y', ctx=ast.Load())
                    )
                )
            ],
            decorator_list=[]
        )
    ],
    type_ignores=[]
)

# Fix locations and compile
ast.fix_missing_locations(module)
code = compile(module, '<generated>', 'exec')

# Execute
namespace = {}
exec(code, namespace)

multiply = namespace['multiply']
print(multiply(5, 3))

import sys

x = []
print(f"Initial refcount: {sys.getrefcount(x)}")  # x + getrefcount's own arg

y = x  # Another reference
print(f"After y = x: {sys.getrefcount(x)}")

del y
print(f"After del y: {sys.getrefcount(x)}")

# When refcount reaches 0, CPython calls tp_dealloc (C function)
# This is how automatic memory management works