Forem: 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

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 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

Quark's Outlines: Python Built-in Methods

Mike Vincent — Sat, 31 Jan 2026 12:13:19 +0000

Quark’s Outlines: Python Built-in Methods

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Built-in Methods

What is a Python built-in method?

You may already know Python has built-in functions like len() and type(). A Python built-in method is similar but attached to a built-in object. For example, you do not write append(list, x)—you call list.append(x).

Built-in methods are written in C. They live inside Python’s core types, like list, dict, and str. Each method is tied to the object it changes or reads from. That object is passed to the method automatically.

Python lets you use built-in methods to work with built-in types.

x = [1, 2]
x.append(3)
print(x)
# prints:
# [1, 2, 3]

The method append() is built into the list type. It changes the list by adding an item to the end.

How do Python built-in methods work?

When you call a built-in method, Python calls a C function. That C function receives the object as its first input, but you do not need to pass it yourself. Python does it for you.

This only works for built-in objects. For example, when you write s.upper() on a string, Python knows to pass s to the C code that changes it.

Python built-in methods act like special tools tied to each type.

word = "hello"
print(word.upper())
# prints:
# HELLO

Here, upper() is not a free function—it is a method of the string object.

A Historical Timeline of Python Built-in Methods

Where do Python’s built-in methods come from?

Python built-in methods came from the need to make object types more useful. In the early years, Python had functions for most tasks. But as Python grew, types like list, dict, and str got their own tools. These tools became methods tied to the object’s shape and purpose.

People built tools to change objects directly

1990 — Python used plain functions for most tasks, like len(x) and type(x).

1991 — Python 0.9.1 added built-in types like list, dict, and str, each with methods for changing them.

1995 — Python 1.3 expanded string methods like find, replace, and split.

2001 — Python 2.2 made all built-in types into new-style classes, allowing full method support.

2008 — Python 3.0 removed old functions and unified the method system under a consistent object model.

2025 — Python built-in methods now include dozens of methods across types like set, bytes, and memoryview.

Problems & Solutions with Python Built-in Methods

How do you use Python built-in methods the right way?

Python built-in methods help you work with strings, lists, dictionaries, and other core types. You can call them on the object directly. These examples show how built-in methods solve real needs when working with Python data.

Problem: How do you add an item to a list in Python?

You have a list of items. You want to add one more. You could make a new list, but that takes time and memory. You want to change the list directly.

Problem: You need to add a new item to a list in place.

Solution: Python gives you the built-in method append() for lists.

Python lets you grow a list with the append() built-in method.

fruits = ['apple', 'banana']
fruits.append('cherry')
print(fruits)
# prints:
# ['apple', 'banana', 'cherry']

The method changes the list directly. It adds the item to the end without making a new one.

Problem: How do you update a value in a dictionary in Python?

You are using a dictionary to track counts. You want to set or change a value for a key. You could use square brackets, but that can fail if the key is missing.

Problem: You want to set a key’s value safely in a dictionary.

Solution: Python lets you use the update() built-in method.

Python lets you set or change many values with the update() method.

scores = {'Alice': 3}
scores.update({'Bob': 5})
print(scores)
# prints:
# {'Alice': 3, 'Bob': 5}

The method adds the key if it is missing or updates it if it is there.

Problem: How do you remove whitespace from a string in Python?

You have a string from user input. It has extra spaces before or after the text. You want to remove them before using the string.

Problem: You need to trim spaces from the ends of a string.

Solution: Python has the strip() built-in method on strings.

Python lets you clean string edges with the strip() method.

name = "  Mike  "
print(name.strip())
# prints:
# Mike

The method keeps the middle of the string and drops only the outside spaces.

Problem: How do you make a list flat in Python?

You have a list with many repeated items. You want to remove the duplicates while keeping one of each. You also want the result in place if possible.

Problem: You want to remove repeated items from a list.

Solution: Python has the set() function, but to keep order, use list(dict.fromkeys()).

Python lets you flatten a list by combining built-in methods.

nums = [1, 2, 2, 3, 1]
flat = list(dict.fromkeys(nums))
print(flat)
# prints:
# [1, 2, 3]

The method dict.fromkeys() keeps the first seen of each item. You then convert it back to a list.

Problem: How do you find a letter in a word in Python?

You have a string and want to know if it includes a certain letter. You want the position where the letter first appears, or nothing if it is not there.

Problem: You want to search inside a string for a letter.

Solution: Python gives you the find() method on strings.

Python lets you search strings with the find() built-in method.

text = "banana"
print(text.find("n"))
# prints:
# 2

The method gives the index of the first match or -1 if not found.

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 Built-in Functions

Mike Vincent — Sat, 24 Jan 2026 12:12:12 +0000

Quark’s Outlines: Python Built-in Functions

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Built-in Functions

What is a Python built-in function?

You often need to do simple things in your code like find a number’s length or sort a list. Python gives you many built-in functions to help with these tasks. These functions work without importing any modules. They are always ready to use.

A Python built-in function is a name like len, print, or sum. It maps to a function written in the C language. These functions are part of the Python core. They run fast and follow strict rules for the number and types of values they accept.

Python lets you use fast, core functions like len() without imports.

name = "Ada"
print(len(name))  # prints: 3

The number of letters in the string is returned using len, a built-in function.

How are Python built-in functions different from user-defined ones?

You can make your own functions using the def keyword. Built-in functions are not made this way. They are written in C and added to Python when it runs. They are stored in a place called the built-in namespace.

Built-in functions often have special behavior that cannot be done in Python code. Some have limits on the kinds of values they can use. Each built-in function is a wrapper around a C function, not a Python function.

Python built-in functions are made in C, not with def.

print(callable(len))  # prints: True

The function len is callable, but not defined in Python code. It is built-in.

A Historical Timeline of Python Built-in Functions

Where do Python’s built-in functions come from?

Built-in functions are part of Python’s core. They reflect both programming needs and the language’s design values. Over time, Python added more of these functions, grouped them for clarity, and made their behavior consistent across data types.

People created core functions for math and strings

1989 — Python’s earliest sketches include ideas for functions like len, range, and print.

1991 — Python 0.9.0 released with early built-in functions: len, type, print, range, int, and str.

2000 — Python 2.0 introduced zip, filter, and map as built-in functions.

People cleaned up and grouped the built-ins

2008 — Python 3.0 removed apply, cmp, and others to make the built-in list shorter and more clear.

2010 — input replaced raw_input, and print became a proper function in Python 3.

2018 — The list of built-in functions was finalized to about 70 entries.

2024 — Python’s built-in functions are stable, fast, and documented in one place.

Problems & Solutions with Python Built-in Functions

How do you use Python built-in functions the right way?

Python gives you built-in functions to do everyday tasks like checking types, counting items, or changing data. These problems show how to use built-in functions instead of writing your own logic.

Problem: How do you find the length of a value in Python?

You are working with a list of names. You want to know how many names are in it. You do not want to use a loop or counter. You want the answer with a single command.

Problem: You want to count items in a list without writing your own loop.

Solution: Python lets you use the built-in function len() to return the number of items.

Python lets you count items with len().

names = ['Ada', 'Grace', 'Linus']
print(len(names))  # prints: 3

The len() function returns the count of items in the list.

Problem: How do you check if a value is a number in Python?

You are reading values from user input. You want to check if each value is an integer. You want to avoid crashes when users type the wrong thing.

Problem: You want to know if a value has a certain type.

Solution: Python lets you use the built-in function isinstance() to check types.

Python lets you test types with isinstance().

age = 30
print(isinstance(age, int))  # prints: True

This confirms that age is an integer before you do math with it.

Problem: How do you turn a string into a number in Python?

You have a string like "42" and you want to use it as a number. You do not want to write your own parser. You want a simple and safe way to convert it.

Problem: You want to convert text to a number.

Solution: Python lets you use int() or float() to turn strings into numbers.

Python lets you convert strings to numbers with int() and float().

text = "42"
print(int(text))  # prints: 42

The string is turned into a number you can use in math.

Problem: How do you get the largest value in a list in Python?

You are comparing numbers from a set of results. You want to know the highest score. You want a simple command to get it.

Problem: You need to find the largest number without writing a loop.

Solution: Python lets you use the max() function to return the biggest value.

Python lets you find the biggest value with max().

scores = [88, 95, 70, 100]
print(max(scores))  # prints: 100

The max() function returns the largest number in the list.

Problem: How do you run code when you don't know the function name yet in Python?

You are writing a program that picks a function at runtime. The function name is stored in a variable. You want to call it without writing a long if-statement.

Problem: You want to call a function that is stored in a variable.

Solution: Python lets you call any callable object with (), including built-in functions.

Python lets you store and call functions like values.

f = len
print(f("Alan"))  # prints: 4

You can pass len around and use it like any other value.

Like, Comment, Share, and Subscribe

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

Forem: Mike Vincent

Quark's Outlines: Python Expressions

Quark’s Outlines: Python Expressions

An Overview of Python Expressions

What is a Python expression?

What kinds of Python expressions are there?

What happens when Python evaluates an expression?

A Historical Timeline of Python Expressions

People defined expressions as a way to show meaning in code

People designed Python expressions for clarity and structure

Problems & Solutions with Python Expressions

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

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

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

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

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

Like, Comment, Share, and Subscribe

Quark's Outlines: Python Execution Model

Quark’s Outlines: Python Execution Model

An Overview of the Python Execution Model

What is the Python execution model?

A Historical Timeline of the Python Execution Model

People created ways to group and control program steps

People shaped Python’s execution model

Problems & Solutions with the Python Execution Model

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

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

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

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

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

Like, Comment, Share, and Subscribe

Quark's Outlines: Python Execution Frames

Quark’s Outlines: Python Execution Frames

An Overview of Python Execution Frames

What is a Python execution frame?

What does a Python execution frame include?

A Historical Timeline of Python Execution Frames

People invented ways to trace function calls and scope

People built Python’s execution model on frames

Problems & Solutions with Python Execution Frames

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

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

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

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

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

Like, Comment, Share, and Subscribe

Quark's Outlines: Python Exceptions

Quark’s Outlines: Python Exceptions

An Overview of Python Exceptions

What is a Python exception?

How do Python exceptions work?

What does Python do when no one catches the exception?

Can Python run code even if there is an error?

A Historical Timeline of Python Exceptions

People invented ways to signal and handle errors

People built Python’s exception model

Problems & Solutions with Python Exceptions

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

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

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

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

Problem: see what caused the error

Like, Comment, Share, and Subscribe

Quark's Outlines: Python Emulating Numeric Types

Quark’s Outlines: Python Emulating Numeric Types

An Overview of Python Emulating Numeric Types

What does it mean to emulate numeric types in Python?

What other numeric behaviors can you define in Python?

What about unary operators and type conversion?

A Historical Timeline of Python Emulating Numeric Types

People invented operator overloading

People built Python’s numeric emulation model

Problems & Solutions with Python Emulating Numeric Types

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

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

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

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

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

Like, Comment, Share, and Subscribe

Quark's Outlines: Python Emulating Callable Objects

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

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

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

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

What does `getattr` do in Python?

What does `setattr` do in Python?

What does `delattr` do in Python?

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