DEV Community: Mike Vincent

Quark's Outlines: Python Internal Types

Mike Vincent — Sat, 25 Apr 2026 12:21:23 +0000

Quark’s Outlines: Python Internal Types

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Internal Types

What are Python internal types?

You use Python every day to write programs, but some parts of Python stay hidden. These are called internal types. They work behind the scenes to help your code run. You do not make these objects directly, but Python creates them while it runs your program.

Some internal types include code objects, frame objects, traceback objects, and slice objects. These objects store details about your code, the stack, and how Python handles errors or slices. You can inspect them using built-in tools or system modules.

Python uses internal types to manage execution, errors, and slicing.

type(slice(1, 5, 2))  # <class 'slice'>

This line shows that slice(1, 5, 2) creates a slice object. Python builds this object when you write slicing code.

How does Python use code objects?

A code object is a block of Python instructions. Python creates a code object when you define a function. The code object holds the function's bytecode, argument names, and other parts. It does not know the function's global variables.

You can get a function's code object using the __code__ attribute.

Python stores instructions using code objects.

def greet(name): return f"Hi, {name}"
print(greet.__code__.co_varnames)  # ('name',)

This prints the list of variable names used in the function. Code objects are read-only and do not change after creation.

What are Python frame objects?

A frame object shows the state of Python when it runs a line of code. Each time Python calls a function, it builds a frame. That frame stores the current code object, the local and global variables, and the current line number.

Frames are stacked. When one function calls another, Python adds a new frame on top of the stack.

Python uses frame objects to track function calls.

import inspect
def check(): print(inspect.currentframe().f_code.co_name)
check()  # check

This prints the name of the function running in the current frame. Frames help tools like debuggers and tracers understand what your code is doing.

How does Python use traceback objects?

When your code has an error, Python creates a traceback object. The traceback shows the call stack at the time of the error. Each level of the stack gets one traceback object.

Traceback objects help Python explain where the error came from. The last one in the chain shows the line where the error happened.

Python uses traceback objects to explain errors.

import sys
try: 1 / 0
except: print(sys.exc_info()[2].tb_lineno)  # 2

This prints the line number where the error happened. You can use traceback objects to write logs or format error messages.

What is a Python slice object?

A slice object tells Python how to cut a list or a string. It stores a start, stop, and step value. Python makes a slice object when you use a colon : in brackets.

You can also create one directly using slice(start, stop, step). The values may be numbers or None.

Python uses slice objects to slice sequences.

s = slice(2, 10, 2)
print(range(20)[s])  # range(2, 10, 2)

This prints the values at index 2, 4, 6, and 8. Python reads the slice object and uses it to cut the data.

A Historical Timeline of Python Internal Types

How did Python internal types develop?

Python internal types grew from the need to manage code execution and error handling. These types are not part of daily Python use, but they support every Python program behind the scenes.

People invented stack frames and bytecode

1959 — Stack frame tracking, IBM 1401, made it easier to debug and resume execution.

1970 — Bytecode instructions, Pascal P-code, created a way to compile programs to simple portable steps.

People designed Python’s execution system

1991 — Code and frame types, Python 0.9.0, added code objects and frame objects for functions and the call stack.

2000 — Traceback objects, Python 2.0, exposed tracebacks to help with exception handling and logging.

People improved slice handling

2001 — Slice object support, Python 2.2, added the slice type and allowed extended slicing syntax.

2008 — Full Unicode traceback, Python 3.0, improved traceback readability for all users.

2025 — Internal types frozen, Python core team, made internal object formats stable for tooling.

Problems & Solutions with Python Internal Types

How do Python internal types help your program run?

Python creates internal types to hold bytecode, manage stack frames, store errors, and handle slices. These objects are not part of your script, but they shape how Python works. Each problem shows how an internal type helps solve a task that Python must handle behind the scenes.

Problem: How do you understand what your function does at runtime in Python?

You write a function that behaves strangely. You want to inspect what it does under the hood without changing its code.

Problem: How can you view the internal steps or structure of a function?

Solution: Python stores details in a code object. You can access it using __code__.

Python lets you inspect bytecode and arguments with code objects.

def double(x): return x * 2
print(double.__code__.co_varnames)  # ('x',)

This shows that the function takes one variable named x.

Problem: How do you follow what happens when a program runs in Python?

You call one function, which calls another, and so on. Something breaks, and you want to trace which part of the code is running right now.

Problem: How can you follow the stack of function calls?

Solution: Python builds frame objects to track each function call.

Python lets you view the call stack with frame objects.

import inspect
def trace(): print(inspect.currentframe().f_back.f_code.co_name)
def outer(): trace()
outer()  # outer

This prints the name of the function that called trace.

Problem: How do you locate where an error happened in Python?

You run a block of code and it crashes. You want to know exactly which line caused the crash.

Problem: How can you find the error line programmatically?

Solution: Python creates a traceback object that stores the error location.

Python gives you line numbers from traceback objects.

import sys
try: 1 / 0
except: print(sys.exc_info()[2].tb_lineno)  # 2

This prints the line where the error happened, not where the traceback is printed.

Problem: How do you use a slice with three parts in Python?

You want to extract every third value from a list between two positions. The usual slice a:b is not enough.

Problem: How can you express a slice with a step value?

Solution: Python creates a slice object with start, stop, and step.

Python lets you define steps with slice objects.

items = list(range(10))
s = slice(1, 8, 3)
print(items[s])  # [1, 4, 7]

The slice picks index 1, then 4, then 7.

Problem: How do you log what happened after an error in Python?

You run a function that fails. You want to keep a clean log that includes the path of calls and the code line where it failed.

Problem: How do you log errors with full context?

Solution: Python keeps a chain of traceback objects for the whole stack.

Python lets you trace errors step-by-step with traceback objects.

import sys, traceback
try: 1 / 0
except:
    tb = sys.exc_info()[2]
    while tb:
        print(tb.tb_frame.f_code.co_name, tb.tb_lineno)
        tb = tb.tb_next
# <module> 2

This prints the stack trace with function names and line numbers in order.

Like, Comment, Share, and Subscribe

Did you find this helpful? Let me know by clicking the like button below. I'd love to hear your thoughts in the comments, too! If you want to see more content like this, don't forget to subscribe. Thanks for reading!

Mike Vincent is an American software engineer and app developer from Los Angeles, California. More about Mike Vincent

Quark's Outlines: Python Frame Objects

Mike Vincent — Sat, 18 Apr 2026 12:19:10 +0000

Quark’s Outlines: Python Frame Objects

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Frame Objects

What is a Python frame object?

When you run a Python function, Python creates a frame object. A frame object holds everything Python needs to track that function. It stores local variables, global names, and the exact point where Python is running in the code. If a function calls another function, Python adds a new frame on top of the last one.

You can think of Python frame objects like stack cards. Each time you call a function, Python adds a new card to the stack. When the function ends, Python removes the card and goes back to the one before it.

Python lets you see the current frame using sys._getframe().

import sys

def example():
    frame = sys._getframe()
    print("Now running:", frame.f_code.co_name)

example()
# prints:
# Now running: example

The frame object stores the function’s name, code, and variables.

What does a Python frame object contain?

A Python frame holds these things: the function’s code object (f_code), a link to the previous frame (f_back), local variables (f_locals), global variables (f_globals), built-in names (f_builtins), the line number (f_lineno), and the last instruction run (f_lasti). The f_trace value can be used by a debugger to run a function every time a line runs.

Each frame is tied to one place in the program. You can follow f_back to move up the call stack and see where Python came from.

Python lets you follow the call stack using frame.f_back.

import sys

def outer():
    inner()

def inner():
    frame = sys._getframe()
    print("Called from:", frame.f_back.f_code.co_name)

outer()
# prints:
# Called from: outer

The inner frame links back to the outer frame.

A Historical Timeline of Python Frame Objects

Where do Python’s frame objects come from?

Python’s frame system follows the tradition of stack-based execution in early languages. These languages built a trace of function calls to keep track of state, then exposed the call stack to the user in rare cases like errors or debugging. Python makes this visible as part of normal execution.

People invented ways to trace running code.

1960 — Call stack frames ALGOL introduced function call stacks to track nested execution.

1972 — Execution state saved per call C stored state for each function using the system stack.

People designed Python’s internal stack.

1991 — Python 0.9.0 introduced frame objects Each function call was backed by a Python frame.

1994 — Tracebacks linked to frames Python exposed the call stack during exceptions.

People made Python frame objects visible.

1995 — sys._getframe() added Python gave users a way to see the current frame object.

2000 — Debuggers used f_trace Python 2.0 let debuggers follow execution line by line.

2025 — Python frame object structure stable Frame objects remain key to inspection, tracing, and errors.

Problems & Solutions with Python Frame Objects

How do you use Python frame objects the right way?

Python frame objects show where the code is running, what values are stored, and what called what. These problems show how you can use frame objects to understand and manage the flow of your program.

Problem: How do you find what function is running in Python?

You are writing a log system and want each function to print its name when it runs. You do not want to write the name by hand. You want Python to find it on its own.

Problem: You need to find the current function name without writing it yourself.

Solution: Use a frame object and read f_code.co_name.

Python lets you inspect the function name using a frame.

import sys

def log_me():
    frame = sys._getframe()
    print("This function is:", frame.f_code.co_name)

log_me()
# prints:
# This function is: log_me

Problem: How do you trace who called your function in Python?

You want to know what part of your code called this function. You are trying to debug a case where the same function is used in many places. You want to print the name of the caller.

Problem: You do not know who called your function.

Solution: Use the frame’s f_back link to read the caller’s name.

Python lets you trace the caller using frame.f_back.

import sys

def outer():
    inner()

def inner():
    frame = sys._getframe()
    print("Caller was:", frame.f_back.f_code.co_name)

outer()
# prints:
# Caller was: outer

Problem: How do you inspect local variables inside a frame in Python?

You are writing a tool that shows all local variables at a certain point in your code. You want to print what names exist and what values they hold.

Problem: You want to get all current local variables from running code.

Solution: Use f_locals to read the local name-value pairs.

Python lets you list local variables using frame.f_locals.

import sys

def check_vars():
    x = 10
    y = 20
    frame = sys._getframe()
    print("Local vars:", frame.f_locals)

check_vars()
# prints:
# Local vars: {'x': 10, 'y': 20, 'frame': <frame object at ...>}

Problem: How do you get the exact line Python is on in Python?

You are debugging and want to show the line number where Python is running. You want to print this each time a function runs.

Problem: You want to show the current line number from code.

Solution: Use the f_lineno value in the frame.

Python lets you print the current line using frame.f_lineno.

import sys

def show_line():
    frame = sys._getframe()
    print("Line number:", frame.f_lineno)

show_line()
# prints:
# Line number: (this line’s number)

Problem: How do you run code on every line while debugging in Python?

You are building a custom debugger. You want to run a function each time Python moves to a new line in the code. You need to hook into Python’s execution engine.

Problem: You need to run a custom action on each source line.

Solution: Use the frame’s f_trace hook.

Python lets you trace line steps using frame.f_trace.

import sys

def trace_func(frame, event, arg):
    print("Trace event:", event, "Line:", frame.f_lineno)
    return trace_func

def run():
    x = 1
    y = 2
    z = x + y

sys.settrace(trace_func)
run()
sys.settrace(None)
# prints:
# Trace event: call Line: (start)
# Trace event: line Line: (x = 1)
# Trace event: line Line: (y = 2)
# Trace event: line Line: (z = x + y)
# ...

Like, Comment, Share, and Subscribe

Mike Vincent is an American software engineer and app developer from Los Angeles, California. More about Mike Vincent

Quark's Outlines: Python Expressions

Mike Vincent — Sat, 11 Apr 2026 12:17:45 +0000

Quark’s Outlines: Python Expressions

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Expressions

What is a Python expression?

When you write a line in Python that gives a value, that line is called an expression. A Python expression is any piece of code that Python can run and produce a value. An expression can be a number, a string, a function call, or even a full equation.

When Python sees an expression, it runs it and gives the result. You can use expressions in assignments, in function arguments, and in control structures like if or while. Every expression produces a value.

Python lets you write expressions to compute values.

x = 2 + 3 * 4
print(x)
# prints:
# 14

This expression adds 2 to 3 * 4. Python runs the expression and assigns the result to x.

What kinds of Python expressions are there?

Python has many kinds of expressions. These include:

Arithmetic expressions, like 3 + 5
String expressions, like 'Hello' + 'World'
Comparison expressions, like x > 5
Function calls, like len(data)
Comprehensions, like [x*x for x in range(3)]
Boolean expressions, like x > 5 and y < 10

All of these return values. You can use expressions by themselves, or as part of a larger statement.

Python expressions include math, logic, and function calls.

name = "Ada"
greeting = "Hello, " + name
print(greeting)
# prints:
# Hello, Ada

Here, the string expression "Hello, " + name creates a new string and assigns it to greeting.

What happens when Python evaluates an expression?

Python reads an expression from left to right. It uses rules called precedence and associativity to decide the order of steps. If you use parentheses, you can control that order.

When Python runs the expression, it creates objects, combines values, and calls functions. The result is stored or returned depending on the context.

Python expressions are evaluated based on rules of order and grouping.

result = (2 + 3) * 4
print(result)
# prints:
# 20

The parentheses make Python add first, then multiply.

A Historical Timeline of Python Expressions

Where do Python’s expression rules come from?

Python expressions are shaped by rules from math, logic, and earlier programming languages. The design combines simplicity with flexibility, so you can write small pieces that build up to full programs.

People defined expressions as a way to show meaning in code

1956 — Infix notation used in early math languages to show operations like a + b.

1960 — ALGOL 60 introduced structured expressions with nested function calls and operators.

1972 — C language added typed expressions, function calls, and rich operator behavior.

People designed Python expressions for clarity and structure

1991 — Python 0.9.0 supported arithmetic, comparison, logic, function calls, and indexing in expressions.

2000 — List comprehensions allowed expressions inside loops for fast value creation.

2006 — Generator expressions added lazy evaluation to Python expressions using parentheses.

2018 — Assignment expressions using := allowed values to be assigned as part of expressions.

2025 — Python expressions now include pattern match expressions, comprehension blocks, and more — all still readable and simple.

Problems & Solutions with Python Expressions

How do you use Python expressions the right way?

Python expressions let you build results from simple rules. They work with numbers, text, logic, and many more types. These problems show how Python expressions help you get useful results with just one line.

Problem: How do you combine values into one result in Python?

You are writing a program that calculates prices. You have a quantity and a unit price. You want to multiply them and show the result, but you do not want to write many lines of code.

Problem: You want to join values into one result using math.

Solution: Python expressions let you combine numbers with operators.

Python lets you use arithmetic expressions to compute values.

price = 10
quantity = 3
total = price * quantity
print(total)
# prints:
# 30

The expression price * quantity computes the value and stores it in total.

Problem: How do you check a condition in one line in Python?

You are checking if someone is allowed to enter. You want to know if their age is 18 or older. You want the check to be clear and simple.

Problem: You want to test a value using logic.

Solution: Python expressions let you compare values and get a result.

Python lets you write comparison expressions for checks.

age = 20
print(age >= 18)
# prints:
# True

This expression returns True if the age is 18 or more. You can use it in an if block or print it directly.

Problem: How do you call a function and use the result in Python?

You have a string and you want to know how many letters it has. You do not want to write a separate function or loop.

Problem: You want to call a built-in function inside an expression.

Solution: Python expressions can include function calls.

Python lets you call a function and use its return value.

word = "hello"
length = len(word)
print(length)
# prints:
# 5

The len(word) expression returns a number, and Python assigns that value to length.

Problem: How do you create a list with one line of logic in Python?

You need a list of the first five square numbers. You do not want to write a loop. You want to write the logic in one step.

Problem: You want to build a new list from a pattern.

Solution: Python lets you use expressions inside a list comprehension.

Python lets you use list comprehensions as expressions.

squares = [x * x for x in range(5)]
print(squares)
# prints:
# [0, 1, 4, 9, 16]

The expression inside the brackets runs for each number in the range and builds the list in one line.

Problem: How do you assign and test a value at the same time in Python?

You want to get input and test it in one line. You want to avoid writing the assignment and the if check on separate lines.

Problem: You want to assign a value while checking it.

Solution: Python expressions support the := assignment expression.

Python lets you assign a value and use it at once.

text = "Hello world"
if (n := len(text)) > 5:
    print("Length is", n)
# prints:
# Length is 11

The expression (n := len(text)) sets n and returns the value. This lets you write less code and keep things clear.

Like, Comment, Share, and Subscribe

Mike Vincent is an American software engineer and app developer from Los Angeles, California. More about Mike Vincent

Quark's Outlines: Python Execution Model

Mike Vincent — Sat, 04 Apr 2026 12:17:30 +0000

Quark’s Outlines: Python Execution Model

Overview, Historical Timeline, Problems & Solutions

An Overview of the Python Execution Model

What is the Python execution model?

When you run a Python program, Python follows a process to decide what happens and in what order. This process is called the Python execution model. It controls how code is grouped, how values are stored, and what happens when things go wrong.

Python organizes your code into code blocks. Each block runs in an execution frame, which stores the block’s state and connects to the next block. Each frame uses one or more name spaces to hold names and values. When something goes wrong, Python raises an exception. These four ideas — code blocks, execution frames, name spaces, and exceptions — make up the execution model.

Python lets you run code using a frame that manages blocks, names, and errors.

def greet():
    name = "Ada"
    print("Hello,", name)

greet()
# prints:
# Hello, Ada

Here, greet() runs inside a new code block and a new execution frame. The name name is stored in the local name space for that frame.

A Historical Timeline of the Python Execution Model

Where did Python’s execution model come from?

Python’s execution model follows ideas from earlier languages like ALGOL and Lisp, but adds features for safe name handling and flexible error control. The timeline below shows how code blocks, execution frames, name spaces, and exceptions evolved in Python.

People created ways to group and control program steps

1960 — Code blocks and scopes in ALGOL introduced nested blocks and clear rules for local vs global names.

1970s — Stack-based frames in Lisp and C made call stacks and local scope rules common.

People shaped Python’s execution model

1991 — Code blocks and frames added in Python 0.9.0 to support safe function calls and modular design.

1995 — Exceptions and try blocks supported with try, except, and raise keywords.

2001 — Dynamic name space access added using globals() and locals().

2006 — exec and eval enhancements added optional name space arguments.

2025 — Execution model stable with strong support for interactive, script, and module-based code.

Problems & Solutions with the Python Execution Model

How do you use the Python execution model the right way?

Python runs code in steps. Each step follows the execution model. It creates code blocks, builds frames, uses name spaces, and raises exceptions. These problems show how that works and how you can use the model to read, write, and fix your code.

Problem: How do you see where Python runs your code?

You write a function and call it from another function. You want to understand where Python is running the code. You want to see what blocks are active and how they relate.

Problem: You want to trace how Python enters and exits each code block.

Solution: Python uses execution frames to track what block is running now.

Python lets you inspect the call stack using code blocks and frames.

import sys

def outer():
    def inner():
        frame = sys._getframe()
        print("Now running:", frame.f_code.co_name)
    inner()

outer()
# prints:
# Now running: inner

Each time Python enters a new block, it creates a new frame that holds the code object and name spaces for that block.

Problem: How do you separate local and global names in Python?

You write a function with a variable called value. You also have another value in the module. You want to understand which one Python uses when the function runs.

Problem: You need to know where Python looks for names inside a block.

Solution: Python uses two name spaces in each frame — local and global.

Python lets you use locals for function names and globals for module names.

value = "global"

def show():
    value = "local"
    print("Value is:", value)

show()
# prints:
# Value is: local

Inside a function, Python uses the local name space first. Outside, it uses the global one.

Problem: How do you reuse a block of code with its own scope in Python?

You want to run a set of lines many times. You do not want the names in that code to change values outside it. You want the names to stay inside.

Problem: You need to run a block of code in its own local space.

Solution: Python uses a new name space for each function body.

Python lets you keep values private to a block using local name spaces.

x = 1

def block():
    x = 2
    print("Inside block:", x)

block()
print("Outside block:", x)
# prints:
# Inside block: 2
# Outside block: 1

The function creates a local name space. Its names do not affect names outside the block.

Problem: How do you handle an error without stopping the program in Python?

You are running code that might fail. You want to try it and move on if it breaks. You do not want the whole program to stop.

Problem: You want to catch a problem and keep the program running.

Solution: Python uses exceptions to manage errors during execution.

Python lets you catch errors using try and except blocks.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero.")
# prints:
# Cannot divide by zero.

Python raised an exception. The code block caught it and handled the error without stopping the program.

Problem: How do you inspect the current global and local names in Python?

You want to see what values Python knows about in your code. You want to look inside the current name spaces and print the names and their values.

Problem: You want to view the contents of the global and local name space.

Solution: Python gives you built-in functions globals() and locals().

Python lets you read name spaces using built-in lookup tools.

x = 42

def show():
    y = "Ada"
    print("Globals:", list(globals().keys()))
    print("Locals:", list(locals().keys()))

show()
# prints:
# Globals: ['__name__', '__doc__', ..., 'x']
# Locals: ['y']

You can use these tools to see what names are defined in each scope.

Like, Comment, Share, and Subscribe

Mike Vincent is an American software engineer and app developer from Los Angeles, California. More about Mike Vincent

Quark's Outlines: Python Execution Frames

Mike Vincent — Sat, 28 Mar 2026 12:16:57 +0000

Quark’s Outlines: Python Execution Frames

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Execution Frames

What is a Python execution frame?

When you run a Python program, Python keeps track of each piece of code as it runs. Python does this using a structure called an execution frame. A Python execution frame is a record of one piece of code running at one moment.

You can think of it like a single page in a notebook that shows what code is running, what names are known, and what will happen next. Each time Python starts running a new code block, it creates a new execution frame. When that code finishes, the frame is removed.

Python uses an execution frame to hold the state of each code block.

import sys

def show():
    frame = sys._getframe()
    print("Running in frame for:", frame.f_code.co_name)

show()
# prints:
# Running in frame for: show

The frame tracks which function is running, the variables in use, and where to go next.

What does a Python execution frame include?

A Python execution frame includes the code block that is running, the local and global name spaces, and pointers to other frames before it. It also contains details for debugging, like the current line number and the file name.

Each frame runs one code block. This can be a module, function, class, string passed to eval(), a file passed to execfile(), or input from the interpreter.

Python uses a new frame for each block of code.

import sys

def outer():
    def inner():
        print(sys._getframe().f_back.f_code.co_name)
    inner()

outer()
# prints:
# outer

Each frame links to the one before it. This lets Python trace how your program got to the current point.

A Historical Timeline of Python Execution Frames

Where do Python’s execution frames come from?

Python frames are part of its stack-based execution model. Python follows the structure of older programming languages that used call stacks and execution records. Over time, frames in Python became a core part of debugging, tracing, and dynamic scope handling.

People invented ways to trace function calls and scope

1960 — Stack records used in ALGOL and early structured languages to store function data.

1972 — Frame-based execution in C supported nested function calls and tracked control flow.

People built Python’s execution model on frames

1991 — Python added frames to manage execution and scope during function and module execution.

2000 — Dynamic evaluation support using exec, eval, and input() created frames from strings and commands.

2001 — Frame introspection via sys._getframe() and traceback support gave users access to internal state.

2025 — Stable frame design remained in use for debuggers, profilers, and runtime tools.

Problems & Solutions with Python Execution Frames

How do you use Python execution frames the right way?

Each time a Python function runs, a new execution frame is created. The frame tracks what code is running, which names are defined, and how to continue once the code ends. These problems show how Python frames help you understand, debug, and trace code.

Problem: How do you find out which function is running in Python?

You are writing a logger. You want to show which function is currently running without writing the function name by hand in every place. You need to get this from the running code itself.

Problem: You want to log the current function name.

Solution: Python execution frames store the code object being run.

Python lets you get the function name from the current frame.

import sys

def whoami():
    print("Function:", sys._getframe().f_code.co_name)

whoami()
# prints:
# Function: whoami

The frame’s f_code.co_name gives the name of the code block currently running.

Problem: How do you trace who called your function in Python?

You want to see which function called your current function. You do not want to pass this as an argument. You want to get it from the call stack itself.

Problem: You want to find the caller of the current function.

Solution: Python execution frames link to earlier frames using f_back.

Python lets you access the previous frame with f_back.

import sys

def a():
    b()

def b():
    caller = sys._getframe().f_back
    print("Called by:", caller.f_code.co_name)

a()
# prints:
# Called by: a

Each frame links to the one before it, so you can see how the code was reached.

Problem: How do you read what variables are in use in Python?

You are writing a tool to inspect your program. You want to read the names and values of local variables while the function is running.

Problem: You want to inspect the local name space during execution.

Solution: Python execution frames include a dictionary of local names.

Python lets you read local variables from f_locals.

import sys

def inspect():
    x = 7
    y = "ok"
    print("Locals:", sys._getframe().f_locals)

inspect()
# prints:
# Locals: {'x': 7, 'y': 'ok'}

The frame gives access to local names and their current values.

Problem: How do you run code from a string and keep track of it in Python?

You are building a sandbox or dynamic runner. You want to run code from a string and keep track of what it is doing. You need Python to treat the string as a full code block.

Problem: You want to execute a string as Python code in a real frame.

Solution: Python makes a new frame when running exec() or eval().

Python makes an execution frame for string-based code.

code = "x = 5; print('X is', x)"
exec(code)
# prints:
# X is 5

Even string-based execution creates a frame with its own name spaces and control.

Problem: How do you debug by stepping through lines in Python?

You want to make a tool that watches a function line by line. You need a way to trace which line is running and keep track of changes.

Problem: You want to watch Python code as it runs.

Solution: Python lets you set a trace function on the frame using f_trace.

Python lets you trace each line of code using a frame hook.

import sys

def trace(frame, event, arg):
    if event == "line":
        print("Line", frame.f_lineno)
    return trace

def run():
    x = 1
    y = 2
    z = x + y
    return z

sys.settrace(trace)
run()
# prints:
# Line 6
# Line 7
# Line 8
# Line 9

This shows each line as it runs using the frame’s line number.

Like, Comment, Share, and Subscribe

Mike Vincent is an American software engineer and app developer from Los Angeles, California. More about Mike Vincent

Quark's Outlines: Python Exceptions

Mike Vincent — Sat, 21 Mar 2026 12:13:46 +0000

Quark’s Outlines: Python Exceptions

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Exceptions

What is a Python exception?

When you run a Python program, you may hit a problem. You may divide by zero or try to open a file that does not exist. A Python exception is a signal that something went wrong. Python stops normal work and looks for a way to handle the error.

Python lets you catch the exception and run other code instead. This helps you control what happens when there is a problem. You can raise your own exceptions. You can also handle built-in ones like ZeroDivisionError or FileNotFoundError.

Python lets you raise and handle exceptions to control errors.

try:
    x = 1 / 0
except ZeroDivisionError:
    print("You cannot divide by zero.")
# prints:
# You cannot divide by zero.

The try block runs code. If it fails, Python jumps to the except block.

How do Python exceptions work?

When a Python error happens, Python raises an exception. The exception can be caught in the same block, or it can go up to the caller. This continues until Python finds a matching except block. If there is none, Python prints a backtrace and stops the program.

You can also raise exceptions yourself using the raise statement. You can raise built-in errors or your own custom ones.

Python exceptions can be raised by code or caught with try-except.

def check(x):
    if x < 0:
        raise ValueError("x must be non-negative")

try:
    check(-1)
except ValueError as e:
    print("Error:", e)
# prints:
# Error: x must be non-negative

The raise line creates an error. The except line handles it.

What does Python do when no one catches the exception?

If Python cannot find a handler, it stops your program. It prints the name of the exception, a message, and a stack trace. This helps you find out where the problem happened.

Python prints a backtrace when no handler is found.

x = 1 / 0
# prints:
# ZeroDivisionError: division by zero

To stop this, you must use try...except to catch the error.

Can Python run code even if there is an error?

Yes. If you use try...finally, Python will run the finally block no matter what. You use this to clean up, close files, or undo steps.

Python always runs the finally block even on error.

try:
    print("Start")
    1 / 0
finally:
    print("Done")
# prints:
# Start
# Done
# ZeroDivisionError: division by zero

The finally block runs even though the try block fails.

A Historical Timeline of Python Exceptions

Where do Python’s exception rules come from?

Python uses exceptions to separate normal steps from error steps. This idea came from older languages like Lisp, C++, and Java. Python made it simple: raise and handle. This timeline shows how Python built its error model.

People invented ways to signal and handle errors

1958 — Interrupt and break mechanisms in LISP let code jump away from failures.

1972 — setjmp and longjmp in C gave programmers low-level ways to leave functions on error.

1983 — Exception classes in C++ let programs raise and catch structured errors.

People built Python’s exception model

1991 — Python 0.9.0 added exceptions with try, except, raise, and string-based identifiers.

2001 — Class-based exceptions became the standard in Python 2.2 for better clarity.

2005 — finally and cleanup rules were made more reliable.

2010 — Exception chaining was added to show related errors using __cause__ and __context__.

2018 — Simplified exception hierarchy organized common error types under Exception.

2025 — No retry-on-exception rule kept to keep control simple and clear.

Problems & Solutions with Python Exceptions

How do you use Python exceptions the right way?

Python exceptions let you skip normal steps when something goes wrong. You use try to test risky code. You use except to react to problems. These problems show how Python exceptions help you manage error cases clearly and safely.

Problem: How do you stop a program crash when an error happens in Python?

You are dividing numbers. One day the number is zero. Your program crashes. You want to stop the crash and print a friendly message instead.

Problem: You want to handle an error instead of stopping the program.

Solution: Python lets you catch the exception with try and except.

Python lets you catch exceptions and run backup code.

try:
    value = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero.")
# prints:
# Cannot divide by zero.

The except line runs when there is a ZeroDivisionError, so your program stays alive.

Problem: How do you raise your own error when data is wrong in Python?

You are checking input. If the value is wrong, you want to raise an error yourself. You want the program to stop unless someone handles that error.

Problem: You want to raise an exception when something is wrong.

Solution: Python lets you use raise to send an error.

Python lets you raise custom exceptions when needed.

def square_root(x):
    if x < 0:
        raise ValueError("x must be non-negative")
    return x ** 0.5

try:
    print(square_root(-9))
except ValueError as e:
    print("Error:", e)
# prints:
# Error: x must be non-negative

The raise command signals the error. The except command handles it.

Problem: How do you ensure cleanup runs even if Python fails in Python?

You are writing to a file. If the write fails, you want to make sure the file still closes. You do not want to leave the file open forever.

Problem: You want cleanup to run even when there is an error.

Solution: Python runs the finally block no matter what happens.

Python lets you always run final steps with finally.

try:
    f = open("data.txt", "w")
    f.write("hello")
finally:
    f.close()
    print("File closed.")
# prints:
# File closed.

The finally part runs whether the write works or not.

Problem: How do you catch multiple kinds of errors in Python?

You are trying something that may fail in more than one way. Sometimes a number is bad. Sometimes the file is missing. You want to catch both.

Problem: You want to catch different errors in the same place.

Solution: Python lets you use many except blocks or group errors.

Python lets you handle different exceptions with separate logic.

try:
    value = int("x")
    file = open("missing.txt")
except ValueError:
    print("That was not a number.")
except FileNotFoundError:
    print("The file does not exist.")
# prints:
# That was not a number.

Python checks each except block until it finds one that matches.

Problem: see what caused the error

You are debugging. An error happened, but you do not know where or why. You want to see the traceback to understand what failed.

Problem: You want to see the error and trace without stopping the program.

Solution: Python gives access to the traceback when an error is caught.

Python lets you print the full traceback using the traceback module.

import traceback

try:
    1 / 0
except ZeroDivisionError:
    traceback.print_exc()
# prints:
# Traceback (most recent call last):
#   ...
# ZeroDivisionError: division by zero

This prints the full stack trace so you can see where the error happened.

Like, Comment, Share, and Subscribe

Mike Vincent is an American software engineer and app developer from Los Angeles, California. More about Mike Vincent

Quark's Outlines: Python Emulating Numeric Types

Mike Vincent — Sat, 14 Mar 2026 12:14:41 +0000

Quark’s Outlines: Python Emulating Numeric Types

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Emulating Numeric Types

What does it mean to emulate numeric types in Python?

When you build your own Python class, you can make it act like a number. This is called emulating numeric types. Python gives you a way to define how your object behaves with arithmetic symbols like +, -, and *.

You can do this by writing special methods with names like __add__, __sub__, or __mul__. When Python sees these symbols in your code, it calls your special method to decide what happens.

Python lets you make your own objects act like numbers.

class Box:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        return Box(self.value + other.value)

    def __repr__(self):
        return f"Box({self.value})"

print(Box(3) + Box(4))
# prints:
# Box(7)

The __add__ method makes + work on Box objects. Python sees Box(3) + Box(4) and calls Box(3).__add__(Box(4)).

What other numeric behaviors can you define in Python?

Python lets you go beyond addition. You can define methods for subtraction (__sub__), multiplication (__mul__), division (__truediv__), modulus (__mod__), power (__pow__), and more.

You can also define reverse operations like __radd__, which are used when your object appears on the right side of an expression. These help Python work when mixed types are used together.

Python lets you control how your object behaves in math expressions.

class Box:
    def __init__(self, value):
        self.value = value

    def __radd__(self, other):
        return Box(self.value + other)

    def __repr__(self):
        return f"Box({self.value})"

print(10 + Box(5))
# prints:
# Box(15)

Here, Python tries 10 + Box(5), and since int does not know how to add Box, it calls Box(5).__radd__(10).

What about unary operators and type conversion?

Python supports unary operations like -x, +x, and abs(x) using methods like __neg__, __pos__, and __abs__.

You can also control how your object converts to int, float, oct, or hex using __int__, __float__, and others.

Python lets you define how your object behaves with abs() and int().

class Box:
    def __init__(self, value):
        self.value = value

    def __abs__(self):
        return abs(self.value)

    def __int__(self):
        return int(self.value)

print(abs(Box(-7)))
print(int(Box(3.9)))
# prints:
# 7
# 3

Your object can now respond to Python’s built-in numeric functions.

A Historical Timeline of Python Emulating Numeric Types

Where do Python’s numeric emulation rules come from?

Python borrowed the idea of numeric emulation from older object models that let programmers overload operators. These features made custom types easier to use in real math-like settings.

People invented operator overloading

1972 — C introduced binary operators as fixed for built-in types, but not user-defined types.

1983 — C++ added operator overloading to let classes define how symbols like + and - behave.

People built Python’s numeric emulation model

1991 — Python added __add__ and friends to allow objects to define their math behavior.

2001 — Python 2.2 added __radd__ and __coerce__ for mixed-type operations and backward compatibility.

2008 — Python 3 removed classic division and standardized behavior using __truediv__ and __floordiv__.

2012 — Custom classes supported rich emulation with clear rules for reverse and unary methods.

2025 — Python’s numeric methods remain stable for all built-in types and most user-defined numeric objects.

Problems & Solutions with Python Emulating Numeric Types

How do you use Python numeric emulation the right way?

Python lets you build your own data types and control how they behave when used in math. These problems show how to use Python’s special methods to respond to arithmetic and conversion operations.

Problem: How do you let objects use `+` in Python?

You made a class that stores numbers, but when you try to add two of them, Python shows an error. You want to write box1 + box2 and get a new box with the total value.

Problem: You want to make + work between two objects of the same class.

Solution: Python calls the __add__ method when using the + operator.

Python lets you define __add__ to support addition.

class Box:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        return Box(self.value + other.value)

    def __repr__(self):
        return f"Box({self.value})"

print(Box(2) + Box(5))
# prints:
# Box(7)

Python sees the + and runs your __add__ method. The result is a new Box.

Problem: How do you support `+` when the object is on the right in Python?

You wrote a class that works with Box(5) + 10, but 10 + Box(5) gives an error. You want your object to work when used on either side of the +.

Problem: You want your object to handle reversed addition.

Solution: Python calls the __radd__ method when your object is on the right side.

Python lets you define __radd__ to support mixed-side addition.

class Box:
    def __init__(self, value):
        self.value = value

    def __radd__(self, other):
        return Box(self.value + other)

    def __repr__(self):
        return f"Box({self.value})"

print(10 + Box(7))
# prints:
# Box(17)

Python tries the left-hand type first. If that fails, it tries __radd__ on the right-hand object.

Problem: How do you let your object return a real number in Python?

You want your class to work with the built-in int() or float() functions. You need to make sure your object knows how to return the right value when these are called.

Problem: You want to support conversion using Python’s built-in numeric types.

Solution: Python uses __int__, __float__, and related methods to perform conversion.

Python lets you define conversion behavior for int() and float().

class Box:
    def __init__(self, value):
        self.value = value

    def __int__(self):
        return int(self.value)

    def __float__(self):
        return float(self.value)

print(int(Box(3.9)))
print(float(Box(7)))
# prints:
# 3
# 7.0

These methods let your object behave more like a real number in Python code.

Problem: How do you support `abs()` for custom types in Python?

You want your object to respond to the abs() function just like a number. Right now, Python says it cannot do that. You need a way to give your class the same behavior.

Problem: You want to make abs(object) return a numeric result.

Solution: Python uses the __abs__ method for this.

Python lets you define __abs__ to support the abs() function.

class Box:
    def __init__(self, value):
        self.value = value

    def __abs__(self):
        return abs(self.value)

print(abs(Box(-8)))
# prints:
# 8

You control how the object responds to abs() by returning the correct value inside __abs__.

Problem: How do you emulate both `+` and `-` with the same logic in Python?

You want your object to handle both + and -, and maybe even *, //, and more. You do not want to write everything from scratch each time. You want a simple way to support math.

Problem: You want to define multiple arithmetic behaviors on your object.

Solution: Python uses a set of method names for each symbol. You can define as many as you need.

Python lets you define multiple methods for full arithmetic support.

class Box:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        return Box(self.value + other.value)

    def __sub__(self, other):
        return Box(self.value - other.value)

    def __mul__(self, other):
        return Box(self.value * other.value)

    def __repr__(self):
        return f"Box({self.value})"

x = Box(5)
y = Box(3)

print(x + y)
print(x - y)
print(x * y)
# prints:
# Box(8)
# Box(2)
# Box(15)

Now your object behaves like a full numeric type, supporting multiple operations as needed.

Like, Comment, Share, and Subscribe

Mike Vincent is an American software engineer and app developer from Los Angeles, California. More about Mike Vincent

Quark's Outlines: Python Emulating Callable Objects

Mike Vincent — Sat, 07 Mar 2026 12:13:38 +0000

Quark’s Outlines: Python Emulating Callable Objects

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Emulating Callable Objects

What does it mean to make a Python object callable?

When you use parentheses in Python, you are usually calling a function. But you can also make your own objects behave like functions. If you define a method called __call__ inside your class, then Python will let you “call” an instance of that class as if it were a function.

A Python callable object is any object that can be followed by parentheses and arguments. This includes functions, methods, and any object that defines a __call__() method.

Python lets you make your own objects callable by adding __call__.

class Greeter:
    def __call__(self, name):
        return f"Hello, {name}!"

greet = Greeter()
print(greet("Ada"))
# prints:
# Hello, Ada!

Even though greet is not a function, calling it with ("Ada") runs its __call__ method.

Why would you make a Python object callable?

You make objects callable when you want them to act like functions but also hold some state. This is helpful when you want an object that remembers past input, has configuration settings, or behaves differently based on how it was set up.

A callable object can replace a function when you need more control or context.

Python callable objects can hold state and act like functions.

class Counter:
    def __init__(self):
        self.total = 0
    def __call__(self, amount):
        self.total += amount
        return self.total

add = Counter()
print(add(5))
print(add(10))
# prints:
# 5
# 15

Here, the object add behaves like a function but also remembers its internal total.

A Historical Timeline of Python Emulating Callable Objects

Where does Python’s callable object behavior come from?

Python's idea of treating anything with a __call__() method as a function follows from object-oriented systems that treat behavior as part of the object. It lets you combine data and logic into one thing.

People invented the idea of treating objects as functions

1970s — Message-passing in Smalltalk inspired the idea that calling a function is just sending a message to an object.

1980 — Function objects in Lisp and Scheme let closures carry behavior and memory together.

People built Python’s callable object model

1991 — Python introduced __call__() in version 0.9.0, making objects with __call__ act like functions.

2001 — Callable check added with the built-in callable() function to test whether an object can be called.

2025 — Callable objects used in decorators and factories in most modern Python programs for extensibility.

Problems & Solutions with Python Emulating Callable Objects

How do you use Python callable objects the right way?

Python callable objects help you build tools that act like functions but do more. You can store state, wrap behavior, or customize how things respond to input. These problems show when and how to define __call__() in Python classes.

Problem: How do you make an object behave like a function in Python?

You are building a tool that should be used like a function, but it also needs to store settings. You want the object to accept input with parentheses, but you also want to keep track of how it was set up.

Problem: You want an object to respond to calls like a function.

Solution: Define a __call__() method inside the class.

Python lets you make objects callable by defining __call__.

class Adder:
    def __init__(self, n):
        self.n = n
    def __call__(self, x):
        return x + self.n

add_five = Adder(5)
print(add_five(10))
# prints:
# 15

The object add_five now works like a function. It uses the stored number when called.

Problem: How do you store state between calls in Python?

You want to create an object that counts how many times it is used. You want it to return the count each time it runs. A regular function does not keep track of state unless you use global variables or extra code.

Problem: You want your callable to remember past values.

Solution: Store state in attributes, and update them in __call__.

Python lets you build stateful callables using class attributes.

class Tracker:
    def __init__(self):
        self.calls = 0
    def __call__(self):
        self.calls += 1
        return self.calls

count = Tracker()
print(count())
print(count())
# prints:
# 1
# 2

This object remembers how many times it has been called.

Problem: How do you replace a function with a class in Python?

You are refactoring your code. A simple function is growing too complex. You want to turn it into a class that behaves the same way, so old code still works.

Problem: You need an object that acts like the function it replaced.

Solution: Define a class with __call__() and use it in place of the old function.

Python lets you swap functions for callables with the same signature.

class Square:
    def __call__(self, x):
        return x * x

f = Square()
print(f(6))
# prints:
# 36

The object f works like a function and can be passed anywhere a function is expected.

Problem: How do you customize function behavior with setup in Python?

You want to build a tool that behaves differently based on how it was created. Each instance should run the same kind of logic but with different settings.

Problem: You want to control the behavior of each callable object.

Solution: Pass setup data to __init__() and use it in __call__().

Python lets you configure callable behavior using instance state.

class Greeter:
    def __init__(self, greeting):
        self.greeting = greeting
    def __call__(self, name):
        return f"{self.greeting}, {name}!"

hi = Greeter("Hi")
hello = Greeter("Hello")

print(hi("Ada"))
print(hello("Bob"))
# prints:
# Hi, Ada!
# Hello, Bob!

Each object behaves like a different function but follows the same class pattern.

Problem: How do you test if something is callable in Python?

You have a mix of objects. Some are functions. Some are numbers. You want to run the ones that can be called, but skip the others. You need a safe way to check.

Problem: You want to test if an object can be used with parentheses.

Solution: Use Python’s built-in callable() function.

Python lets you check if an object is callable.

def f(): return 42
class C: pass
obj = C()

print(callable(f))
print(callable(obj))
# prints:
# True
# False

If the object defines __call__, callable() returns True. If not, it returns False.

Like, Comment, Share, and Subscribe

Mike Vincent is an American software engineer and app developer from Los Angeles, California. More about Mike Vincent

Quark's Outlines: Python Customizing Attribute Access

Mike Vincent — Sat, 28 Feb 2026 12:13:13 +0000

Quark’s Outlines: Python Customizing Attribute Access

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Customizing Attribute Access

What does it mean to customize attribute access in Python?

When you use x.name in Python, the language looks for that name in the object’s data. This is called attribute access. You can customize attribute access in Python by defining special methods in a class.

You can tell Python what to do when someone tries to get, set, or delete an attribute. These methods are __getattr__, __setattr__, and __delattr__. They let you control how attributes behave at runtime.

Python lets you change how attributes work using special methods.

class Example:
    def __getattr__(self, name):
        return f"Attribute {name} not found"

x = Example()
print(x.foo)
# prints:
# Attribute foo not found

Python did not find foo, so it called __getattr__. The method returned a message instead of raising an error.

What does `getattr` do in Python?

Python calls __getattr__ only when it cannot find the attribute in the usual places. That means the attribute is not in the instance and not in its class.

You use __getattr__ to compute or simulate values that are not stored directly. This is useful when building proxy objects, virtual fields, or fallbacks.

Python uses __getattr__ when a normal lookup fails.

class Example:
    def __getattr__(self, name):
        return 42

x = Example()
print(x.anything)
# prints:
# 42

This class returns 42 for any missing attribute.

What does `setattr` do in Python?

Python calls __setattr__ every time you assign to an attribute. This method overrides the normal behavior. If you do not store the value in the object’s dictionary directly, you will get a recursive call.

To avoid this, use self.__dict__[name] = value. This changes the data without calling __setattr__ again.

Python lets you intercept assignments with __setattr__.

class Track:
    def __setattr__(self, name, value):
        print(f"Setting {name} = {value}")
        self.__dict__[name] = value

x = Track()
x.speed = 100
# prints:
# Setting speed = 100

The __setattr__ method gives you full control over how attributes are stored.

What does `delattr` do in Python?

Python calls __delattr__ when you delete an attribute using del x.name. If you define __delattr__, you can log or change what happens when data is removed.

Python lets you customize deletion with __delattr__.

class Cleanup:
    def __delattr__(self, name):
        print(f"Deleting {name}")
        del self.__dict__[name]

x = Cleanup()
x.a = 10
del x.a
# prints:
# Deleting a

This example shows how Python routes deletion through the special method.

A Historical Timeline of Python Customizing Attribute Access

Where do Python’s attribute access hooks come from?

Python’s model for attribute access comes from object-oriented systems in older languages. Over time, Python added methods that let you override default behavior. These methods help you build frameworks, wrappers, and new object systems.

People built object models that respond to attribute access

1980 — Smalltalk and Lisp OOP used dynamic dispatch and method lookup to model behavior flexibly.

1983 — C++ introduced operator overloading that included overloading for member access and assignment.

People gave Python custom hooks for attributes

1991 — Python 0.9.0 supported attribute lookup via dictionaries for object state and access.

2000 — __getattr__, __setattr__, and __delattr__ formalized in Python 2.0 to override standard behavior.

2001 — Python descriptor protocol introduced to offer deeper control for classes and fields.

2015 — Property decorators and metaclass support expanded for class-level attribute logic.

2025 — Python access model remains stable with these hooks as the base for more advanced tools.

Problems & Solutions with Python Customizing Attribute Access

How do you use Python attribute hooks the right way?

Python gives you special methods to take control of what happens when an attribute is read, written, or removed. These problems show how to use that control to add features and avoid common mistakes.

Problem: How do you provide fallback values for missing attributes in Python?

You are building a lightweight object. Some attributes might not exist yet, but you do not want the code to fail when they are missing. You want to return a default value instead of raising an error.

Solution: Python calls __getattr__ when an attribute does not exist.

Python lets you return fallback values using __getattr__.

class Safe:
    def __getattr__(self, name):
        return f"{name} not set"

x = Safe()
print(x.color)
# prints:
# color not set

This object returns a message instead of crashing when an attribute is missing.

Problem: How do you log changes to an object's fields in Python?

You are tracking a program’s state. You want to print a message every time a value changes, so you can see how your object is used. You want to do this without repeating print statements.

Solution: Python calls __setattr__ every time a field is updated.

Python lets you log updates using __setattr__.

class Watch:
    def __setattr__(self, name, value):
        print(f"{name} set to {value}")
        self.__dict__[name] = value

w = Watch()
w.level = 5
# prints:
# level set to 5

This helps you understand when and how your data changes.

Problem: How do you keep some attributes read-only in Python?

You are building a configuration object. Some values should never change after the object is created. You want to raise an error if someone tries to update those fields.

Problem: You want to stop certain fields from being reassigned.

Solution: Python __setattr__ can reject changes based on the attribute name.

Python lets you prevent changes using rules in __setattr__.

class Locked:
    def __init__(self):
        self.__dict__['locked'] = True

    def __setattr__(self, name, value):
        if name == "locked":
            raise AttributeError("Cannot modify 'locked'")
        self.__dict__[name] = value

x = Locked()
x.mode = "test"
x.locked = False
# prints:
# Traceback (most recent call last):
# AttributeError: Cannot modify 'locked'

The class refuses to change protected values after they are set.

Problem: How do you respond when someone deletes an attribute in Python?

You have an object with important fields. If someone deletes a field, you want to log the deletion or stop it. You do not want to let data disappear silently.

Problem: You want to handle or block attribute deletion.

Solution: Python calls __delattr__ when del is used on a field.

Python lets you respond to deletion with __delattr__.

class Guarded:
    def __delattr__(self, name):
        if name == "key":
            raise AttributeError("Cannot delete key")
        print(f"Deleted {name}")
        del self.__dict__[name]

x = Guarded()
x.key = "value"
del x.key
# prints:
# Traceback (most recent call last):
# AttributeError: Cannot delete key

You control what happens when someone tries to remove part of your object.

Problem: How do you simulate virtual attributes in Python?

You are building a class that holds computed values. These values are not stored in the object, but you want users to access them as if they were attributes.

Problem: You want to define an attribute without storing it.

Solution: Python lets you return a value using __getattr__.

Python lets you simulate fields with __getattr__.

class Virtual:
    def __getattr__(self, name):
        if name == "area":
            return self.width * self.height
        raise AttributeError(name)

v = Virtual()
v.width = 4
v.height = 3
print(v.area)
# prints:
# 12

The area is not stored, but Python calculates it when asked.

Like, Comment, Share, and Subscribe

Mike Vincent is an American software engineer and app developer from Los Angeles, California. More about Mike Vincent

Quark's Outlines: Python Coercion Rules

Mike Vincent — Sat, 21 Feb 2026 12:13:24 +0000

Quark’s Outlines: Python Coercion Rules

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Coercion Rules

What are Python coercion rules?

When you use a binary operator like +, -, or * in Python, Python must decide how to combine two values. The values may come from different types. The process Python uses to find a common type or method is called coercion.

You can think of Python coercion rules as a way to keep the program moving when two types meet. Python checks if one object knows how to handle the operation. If not, it checks if the other object knows. In special cases, Python lets objects transform themselves to work better with others.

Python lets objects work together using coercion rules.

print(3 + 5.0)
# prints:
# 8.0

Here Python turns the integer 3 into a float so it can add it to 5.0. This is automatic coercion.

How do Python coercion rules handle special cases?

When you mix user-defined objects, Python gives your class a chance to control how it combines with others. If your object defines a method like __add__, Python will call that method first. If that does not work, Python will try the other object’s __radd__ method.

In older versions of Python, you could define a method called __coerce__ to suggest how two objects should be made compatible. This method is now gone in Python 3, but the pattern still teaches how Python thinks about mixing types.

Python checks method order to combine two objects.

class MyNumber:
    def __radd__(self, other):
        return f"Called with {other}"

print(5 + MyNumber())
# prints:
# Called with 5

Python tried to call 5.__add__() first, which failed. Then it called MyNumber().__radd__(5).

A Historical Timeline of Python Coercion Rules

Where do Python’s coercion rules come from?

Python’s coercion model came from older languages that needed to combine types. Over time, Python moved from automatic type mixing to giving each object control over how it responds to operations. This helped avoid errors and made programs easier to read and test.

People invented type conversion models

1960 — Type promotion in FORTRAN allowed combining integers and floats by converting smaller types.

1972 — Operator overloading in C++ gave user-defined types control over how operators behaved.

People added coercion to Python

1991 — Python 0.9.0 supported __coerce__ as a way for objects to convert themselves before operations.

2000 — Rich comparison and binary methods like __add__ and __radd__ replaced __coerce__.

2008 — Python 3.0 removed __coerce__, leaving only method-based coercion and implicit numeric promotion.

2025 — Operator behavior stable with __op__ and __rop__ methods used for custom types and mixed operations.

Problems & Solutions with Python Coercion Rules

How do you use Python coercion rules the right way?

Python lets you combine different values using arithmetic and other operators. Sometimes these values are built-in types like int and float. Sometimes they are user-defined objects. Python’s coercion rules help these values work together without errors. These problems show how coercion works in practice.

Problem: How do you add two numbers of different types in Python?

You want to add an integer and a float. You do not want to convert them yourself. You want Python to handle the types and give a proper result.

Problem: You are mixing numeric types and want the result to work.

Solution: Python promotes the smaller type (int) to match the larger type (float).

Python lets you add mixed numeric types using coercion.

x = 7
y = 2.5
print(x + y)
# prints:
# 9.5

Python turned 7 into 7.0 and then added 7.0 + 2.5.

Problem: How do you control how your object reacts to a number in Python?

You write a class and want to support number + object. You want Python to call your method when the number does not know what to do.

Problem: You need to define how your object responds when used on the right side.

Solution: Define the __radd__ method to let your object respond to +.

Python lets objects define __radd__ to handle left-side failure.

class Adder:
    def __radd__(self, other):
        return other + 10

a = Adder()
print(5 + a)
# prints:
# 15

Python tried 5.__add__(a) but failed. Then it used a.__radd__(5) which worked.

Problem: How do you combine two user-defined objects in Python?

You have two custom classes. You want them to work together with +. You want the first object to try the operation. If that fails, the second object should try instead.

Problem: You want two objects to cooperate in a binary operation.

Solution: Python tries __add__ first, then __radd__ if needed.

Python lets two objects try methods in order: left then right.

class A:
    def __add__(self, other):
        return "A handles it"

class B:
    def __radd__(self, other):
        return "B handles it"

print(A() + B())
# prints:
# A handles it

Here, A.__add__ worked, so Python did not call B.__radd__.

Problem: How do you support `%` with strings in Python?

You want to use the % operator to format strings with values. You want to avoid custom formatting logic and use Python’s built-in behavior.

Problem: You want to insert a value into a string using %.

Solution: Python uses special rules for string formatting with %.

Python lets strings format values using the % operator.

name = "Ada"
print("Hello, %s!" % name)
# prints:
# Hello, Ada!

If the left side of % is a string, Python formats it and skips other coercion logic.

Problem: How do you multiply a list by a number in Python?

You want to repeat a list or string several times. You want Python to handle it without writing a loop.

Problem: You want to use multiplication with a sequence and a number.

Solution: Python defines a special rule for sequence * int.

Python lets you repeat a sequence using *.

print([1, 2] * 3)
print("ha" * 2)
# prints:
# [1, 2, 1, 2, 1, 2]
# haha

Python knows that * means repeat if one side is a list or string and the other is a number.

Like, Comment, Share, and Subscribe

Mike Vincent is an American software engineer and app developer from Los Angeles, California. More about Mike Vincent

Quark's Outlines: Python Code Objects

Mike Vincent — Sat, 14 Feb 2026 12:13:34 +0000

Quark’s Outlines: Python Code Objects

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Code Objects

What is a Python code object?

When you write a Python function or module, Python first turns your code into a special internal object. This is called a code object. A Python code object holds the compiled version of your code before it runs. It includes bytecode, variable names, line numbers, and more.

You do not create a code object by hand. Python makes one when you define a function or compile a block of code. This object does not run by itself. It needs a frame or a function to run it.

Python stores compiled bytecode in a code object.

def add(x, y):
    return x + y

print(add.__code__.co_code)

This prints the compiled bytecode instructions for the add function.

What does a Python code object contain?

A code object contains details about the function’s arguments, local variables, constants, and instructions. It also stores metadata like the file name, line numbers, and the original source string. These parts help Python run the code correctly.

The code object does not store global variables or default values. Those are held by the function object itself. A code object is fixed. You cannot change it after Python makes it.

Python uses code objects to store compiled instructions and metadata.

def greet(name):
    return f"Hello, {name}"

print(greet.__code__.co_varnames)  # ('name',)
print(greet.__code__.co_consts)    # ('Hello, ', None)

The code object tells you which variables and constants the function uses.

Problem: How do you access a Python code object in Python?

When you define a function, Python adds a __code__ attribute to it. This attribute points to the function’s code object. You can inspect the object’s parts by using attributes like co_argcount, co_code, or co_names.

Python gives you this access to support tools like debuggers, disassemblers, or linters. Most programs never need to read a code object, but tools that study Python behavior often do.

Python gives every function a code object in __code__.

def f(x): return x * 2
print(f.__code__.co_argcount)   # 1
print(f.__code__.co_names)      # ()

You can explore how Python sees your function behind the scenes.

Why are Python code objects important?

Python uses code objects to run your code. A code object gives Python all the parts it needs to execute a function or a module. It keeps the logic fixed and stored in bytecode.

Tools that inspect, analyze, or modify Python code often use code objects. They let Python work efficiently. They also help when you need to trace errors or debug how something runs.

Python depends on code objects to run your code step by step.

def square(n): return n * n
print(square(4))  # 16

Behind this line, Python is using the code object to run bytecode that multiplies the value.

A Historical Timeline of Python Code Objects

Where do Python code objects come from?

Python code objects follow from early efforts to separate code from data. These objects hold compiled instructions and support tools that analyze, trace, or transform code. This timeline shows how Python shaped the idea of code objects over time.

People separated compiled code from runtime state.

1958 — Early bytecode formats, Lisp and FORTRAN separated compiled code from runtime data.

1970 — Stack frame models, early VMs introduced stack frames to store function execution states.

People designed Python’s first code object format.

1991 — Function and code split, Python 0.9.0 separated function logic into immutable code objects.

1994 — Dis module introduced, Python added tools to inspect and disassemble code objects.

People expanded code object metadata and control.

2001 — Metadata introspection, Python 2.2 added flags and structure to describe argument kinds.

2010 — Bytecode trace tools, Python 3.x improved support for debugging using code object internals.

2019 — Precise line tracking, Python 3.8 added better line number support and instruction offsets.

Problems & Solutions with Python Code Objects

How do you use Python code objects the right way?

Python code objects are internal, but you still use them when you write functions or inspect behavior. These problems show how understanding code objects helps you explore and understand how Python runs your code.

Problem: How do you find out how many arguments a function takes in Python?

You are reading a function and want to know how many arguments it requires. The function is used many times in your program. You want to avoid errors from calling it with the wrong number of arguments.

Problem: How do you check the number of required arguments without reading all the source code?

Solution: Python stores this number in the function’s code object using the co_argcount attribute.

Python shows function argument counts using code objects.

def divide(x, y): return x / y
print(divide.__code__.co_argcount)  # 2

This prints 2, showing the function expects two arguments.

Problem: How do you inspect what names a function uses in Python?

You are working with a helper function from another file. You want to see which variables it uses so you can reuse it safely in a new context. You do not want to miss any required inputs.

Problem: How do you list the variable names used in the function body?

Solution: Python keeps variable names in co_varnames and external names in co_names.

Python lists variable and symbol names inside code objects.

def calc(a, b): return a + b + pi
print(calc.__code__.co_varnames)  # ('a', 'b')
print(calc.__code__.co_names)     # ('pi',)

This shows that a and b are local, while pi is expected from the global scope.

Problem: How do you debug line numbers in an error in Python?

You run a program that fails inside a function. The traceback says there is an error on a line, but you are not sure which line the function started on. You want to know where to look.

Problem: How do you find the first line number in the original source?

Solution: Python stores this in the co_firstlineno attribute of the code object.

Python stores line numbers to help locate function code.

def square(x):
    return x * x

print(square.__code__.co_firstlineno)  # prints the line number

This tells you where in the file the function starts, useful when scanning tracebacks.

Problem: How do you compare two functions' bytecode in Python?

You are optimizing two functions. They do similar things, but you want to know if Python compiles them to the same instructions. You want to see the exact bytecode each one uses.

Problem: How do you view and compare the compiled bytecode?

Solution: Python stores bytecode in the co_code attribute as a sequence of bytes.

Python gives you raw bytecode using the code object.

def f(x): return x + 1
def g(x): return x + 2

print(f.__code__.co_code)
print(g.__code__.co_code)

The bytecode will differ based on the constants and operations. This lets you compare how Python compiles logic.

Problem: How do you find out what constants a function uses in Python?

You are trying to extract all hardcoded values from your code. You want to scan each function and find the constant strings, numbers, or None values it uses.

Problem: How do you get the list of constants a function includes?

Solution: Python stores all literals in the co_consts tuple inside the code object.

Python lists all constant values inside code objects.

def hello(): return "Hi", None

print(hello.__code__.co_consts)  # ('Hi', None)

This shows every literal in the function. You can use this to search for fixed values.

Like, Comment, Share, and Subscribe

Mike Vincent is an American software engineer and app developer from Los Angeles, California. More about Mike Vincent

Quark's Outlines: Python Code Blocks

Mike Vincent — Sat, 07 Feb 2026 12:13:50 +0000

Quark’s Outlines: Python Code Blocks

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Code Blocks

What is a Python code block?

When you write a Python program, you group statements together. This group is called a Python code block. A code block is a section of code that Python can run as one unit. It can be as short as one line or as long as a full module.

You use code blocks in many places. A function body is a code block. A class definition is a code block. Each module you import is also a code block. Python reads these blocks and sets up the right space to run them.

Python lets you group statements into code blocks that run together.

def greet(name):
    print("Hello,", name)

greet("Ada")
# prints:
# Hello, Ada

The function body is a code block. Python runs it when you call greet().

Where do Python code blocks appear?

You use code blocks in many parts of Python. Some blocks run once, like a module. Some blocks run many times, like a function. Python sees each block as its own unit, even if it lives inside another.

You also write code blocks in the Python shell, in scripts, or by passing strings to eval() or exec().

Python sees each script, function, class, or command as a code block.

x = 5
print(x + 2)
# prints:
# 7

If you type this into a shell or script, each line is part of the same code block.

A Historical Timeline of Python Code Blocks

Where do Python’s code blocks come from?

The idea of code blocks comes from early structured programming. Over time, blocks became the way to group logic and manage scope. Python kept this model but used indentation, not braces or symbols, to mark blocks.

People invented structured code blocks

1960 — Structured code flow in ALGOL introduced the idea of blocks with their own scope and control flow.

1972 — Braced blocks in C grouped statements using {} and used semicolons to end each line.

People designed Python’s code block system

1991 — Indented blocks in Python 0.9.0 used colons and whitespace to group code without braces.

1994 — Interactive code blocks in Python shell treated each command as a block with its own scope.

2000 — String-based blocks added support for exec(), eval(), and input() as ways to run blocks from strings.

2010 — Function scopes improved with clear separation between local and global name spaces.

2025 — Code block rules stable and remain central to how Python runs structured code.

Problems & Solutions with Python Code Blocks

How do you use Python code blocks the right way?

Python code blocks let you group logic, run sections of code, and control how names are stored. These problems show how Python blocks behave in real scripts, shells, and function calls.

Problem: How do you group several lines to run together in Python?

You are writing a function to perform a task. You want to run a few lines together every time you call the function. You need Python to treat these lines as one block.

Problem: You need a way to run several statements together.

Solution: Python lets you define a code block using indentation under a def or class.

Python lets you create a code block inside a function using indentation.

def compute():
    x = 2
    y = 3
    print("Result:", x + y)

compute()
# prints:
# Result: 5

All indented lines under def belong to the same code block. Python runs them together.

Problem: How do you define a block that runs once when imported in Python?

You are writing a module that holds helper functions. You want it to run a small block of code the first time it is imported. This block should not run again.

Problem: You want to define a code block that runs once.

Solution: Python treats the module file itself as a code block.

Python lets each module act as a single code block that runs when imported.

print("Running my_module.py")
# prints:
# Running my_module.py (on first import only)

When Python loads a module, it runs its code block once. Later imports skip it.

Problem: How do you run a block from a string in Python?

You are building a tool that takes user input and runs it as Python code. You want to run full expressions or statements from strings, not just from files.

Problem: You want to turn a string into a running code block.

Solution: Python lets you use exec() to treat a string as a code block.

Python lets you run code blocks from strings using exec().

code = "x = 7\nprint('x is', x)"
exec(code)
# prints:
# x is 7

The string is treated like its own code block. Python runs it in the current scope.

Problem: How do you run each line in the Python shell as a block in Python?

You are typing commands into the Python shell. Each line you type runs by itself, but some lines must be grouped (like an if block). You want Python to know when the block ends.

Problem: You want to run multi-line blocks in the shell.

Solution: Python treats each top-level command or group as its own code block.

Python runs each group of typed lines as its own code block.

x = 4
if x > 2:
    print("Big")
# prints:
# Big

Python uses indentation to know when the block is complete before it runs it.

Problem: How do you tell where a block ends in Python?

You are reading or editing code. You want to know where a block begins and ends. You want to avoid mistakes from wrong spacing.

Problem: You need to see code block boundaries clearly.

Solution: Python uses colons and indentation to mark code blocks.

Python uses indentation after colons to define the start of each code block.

def show():
    print("Inside block")
print("Outside block")

show()
# prints:
# Inside block
# Outside block

Only the indented line belongs to the show() block. The next line with no indent is outside.

Like, Comment, Share, and Subscribe

Mike Vincent is an American software engineer and app developer from Los Angeles, California. More about Mike Vincent