DEV Community: Mike Vincent

Quark's Outlines: Python User-defined Functions

Mike Vincent — Sat, 30 May 2026 12:33:50 +0000

Quark’s Outlines: Python User-Defined Functions

Overview, Historical Timeline, Problems & Solutions

An Overview of Python User-Defined Functions

What is a Python user-defined function?

You can define your own function in Python using the def keyword. A Python user-defined function is made when you write a def block in your code. When Python runs this block, it creates a function object.

A function object has special parts. These include its name, its list of default values, and its code. It also keeps a link to the global names from the file where it was made. You can use this object to call the function later with any valid input.

Python lets you create named function objects with the def keyword.

def greet(name="friend"):
    return "Hello, " + name

print(greet())
print(greet("Mike"))
# prints:
# Hello, friend
# Hello, Mike

The function greet is now a user-defined function. Python stores its name, code, and default values for later use.

What are the special parts of a Python function?

A Python function holds many facts about itself. These are called attributes. For example, __name__ holds the function name. __defaults__ is a tuple of default values. __globals__ holds the global names it can see. __code__ is a special object that stores the function’s bytecode.

Python functions store their details in special attributes.

def square(x=2):
    return x * x

print(square.__name__)
print(square.__defaults__)
print(square.__code__.co_varnames)
# prints:
# square
# (2,)
# ('x',)

These parts let Python understand and run your function later.

A Historical Timeline of Python User-Defined Functions

Where do Python’s user-defined functions come from?

User-defined functions in Python build on ideas from earlier languages. They let you name blocks of code and reuse them. Over time, Python added new parts to function objects—like closures, default values, and metadata—to make them more powerful.

People designed ways to name and reuse logic

1958 — Functions in LISP let users define reusable logic blocks for the first time.

1972 — Procedures in C gave a fixed way to declare and call code blocks with arguments.

People added first-class functions to Python

1991 — Python adds def keyword, making user-defined function objects.

1994 — Python functions gain __name__ and __doc__ attributes.

2000 — Nested functions and closures added with lexical scoping in Python 2.1.

2004 — __code__ object exposed to let functions be inspected.

2015 — Function annotations added for argument hints and return types.

2025 — Function structure stable, with introspection, closures, and metadata all supported.

Problems & Solutions with Python User-Defined Functions

How do you use Python user-defined functions the right way?

Python functions are blocks of code you can name and reuse. These examples show how functions are stored, how their defaults work, how you can inspect them, and how to understand what happens when they are created and called.

Problem: How do you reuse the same logic with different inputs in Python?

You want to avoid repeating the same code. You want to give it a name, reuse it, and pass in different values each time. You need to define a function and call it when needed.

Problem: You want to make code reusable and easy to change.

Solution: Python lets you define a function using def and call it with arguments.

Python lets you reuse logic by defining and calling a function.

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

print(add(2, 3))
print(add(10, -5))
# prints:
# 5
# 5

The add function gives a simple way to reuse addition logic with any numbers.

Problem: How do you define a function with default values in Python?

You want to make a function that works with or without an input. If no value is given, it should still run using a fallback value. You want a safe default when nothing is passed.

Problem: You want a function to work even if no input is given.

Solution: Python lets you set default argument values in your function.

Python lets you define functions with default argument values.

def greet(name="friend"):
    return "Hello, " + name

print(greet())
print(greet("Sam"))
# prints:
# Hello, friend
# Hello, Sam

The function uses the default value "friend" unless another name is given.

Problem: How do you check what a function holds in Python?

You want to look inside a function and see what Python remembers. You want to see its name, its default values, and the code it will run. You want to inspect the function object.

Problem: You need to understand what a function knows about itself.

Solution: Python gives function objects special attributes you can inspect.

Python lets you inspect functions using built-in attributes.

def square(x=3):
    return x * x

print(square.__name__)
print(square.__defaults__)
print(square.__code__.co_varnames)
# prints:
# square
# (3,)
# ('x',)

These attributes show the function name, default values, and variable names.

Problem: How do you store a function for later use in Python?

You want to save a function inside a variable or pass it to another function. You do not want to run it yet. You only want to store the logic until later.

Problem: You want to treat functions as values and pass them around.

Solution: Python lets you store function objects in variables or pass them to others.

Python lets you assign function objects to names and pass them around.

def shout(word):
    return word.upper() + "!"

s = shout
print(s("hello"))
# prints:
# HELLO!

You can treat the shout function like any value and use it under another name.

Problem: How do you check a function's global names in Python?

You are inside a function and want to know which global names it can see. You want to inspect where it was defined and what global values it uses. This helps when debugging or writing tools.

Problem: You want to trace which global names a function depends on.

Solution: Python stores the global dictionary in the function’s __globals__.

Python lets you inspect the global scope used by a function.

message = "Hi"

def say():
    return message

print(say.__globals__['message'])
# prints:
# Hi

The __globals__ attribute shows the dictionary of names from the module.

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

Mike Vincent — Sat, 23 May 2026 12:29:01 +0000

Quark’s Outlines: Python Traceback Objects

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Traceback Objects

What is a Python traceback object?

When you run a Python program and an error happens, Python shows you a stack trace. A stack trace shows where the error came from. It tells you what function failed and which line caused it. A Python traceback object holds that information.

Each traceback object shows one step in the chain of function calls that led to the error. Python builds this chain as it unwinds the stack. The traceback includes the function’s frame, the line number, and the bytecode instruction that failed.

Python lets you examine what went wrong using traceback objects.

import traceback

try:
    1 / 0
except ZeroDivisionError as e:
    tb = e.__traceback__
    print("Line:", tb.tb_lineno)

This traceback shows the line where the error happened. You can follow it to see how Python reached that point.

What does a Python traceback object contain?

A traceback object stores the frame that was active at the time of the error. It also stores the line number and the last instruction run in that frame. If there were more calls before the error, the traceback links to the next earlier traceback using tb_next.

You can think of a traceback as a trail of breadcrumbs that shows how the program moved from one function to the next before it failed.

Python traceback objects form a chain of frames leading to the error.

def a():
    b()

def b():
    1 / 0

try:
    a()
except ZeroDivisionError as e:
    tb = e.__traceback__
    print("Error in:", tb.tb_frame.f_code.co_name)

This prints the name of the function where the error happened. You can also walk backward using tb_next.

A Historical Timeline of Python Traceback Objects

Where do Python’s traceback objects come from?

Python traceback objects follow the idea of stack traces from earlier programming tools. They allow you to see what went wrong and where. This timeline shows how traceback support in Python grew over time.

People invented ways to trace error locations

1960 — Stack trace messages first appeared in debugging tools for compiled languages.

1970s — Structured error reporting became common in tools for ALGOL and Pascal.

People designed traceback support in Python

1991 — Python added exceptions and built-in stack traces for all uncaught errors.

1994 — Traceback module added to let users walk through exceptions by hand.

2000 — __traceback__ attribute added to exceptions to hold traceback objects.

2010 — Chained exceptions allowed Python to preserve traceback links across raise from.

2020 — Traceback access improved in tools like traceback.TracebackException for structured error analysis.

Problems & Solutions with Python Traceback Objects

How do you use Python traceback objects the right way?

Python traceback objects help you see where an error started, where it happened, and what Python was doing. When an error happens, Python builds a traceback. This traceback helps you trace the flow of execution and fix the problem. Each of these problems shows how to use traceback objects in real code.

Problem: How do you get the line where an error occurred in Python?

You are running some code that raises an error. You want to find the exact line number where the problem happened. You want to get that number from Python, not by reading the stack trace on screen.

Problem: You need to get the line number of the error programmatically.

Solution: Python traceback objects give the line number using tb_lineno.

Python lets you read the error line number from a traceback object.

try:
    int("nope")
except ValueError as e:
    tb = e.__traceback__
    print("Line number:", tb.tb_lineno)
# prints:
# Line number: 2

The tb_lineno attribute gives you the exact line where Python stopped with an error.

Problem: How do you find the function where the error happened in Python?

You are debugging a complex program. You want to know which function caused the error without reading the full traceback printout.

Problem: You want the name of the function where the error occurred.

Solution: Python traceback objects include the frame, which has the code object and its name.

Python lets you get the function name from the traceback’s frame.

def crash():
    return 1 / 0

try:
    crash()
except ZeroDivisionError as e:
    tb = e.__traceback__
    print("Function:", tb.tb_frame.f_code.co_name)
# prints:
# Function: crash

The frame tells you which function was running when the error happened.

Problem: How do you follow all the steps that led to an error in Python?

You are debugging a failure that goes through several functions. You want to walk back through all of them and see which path Python took.

Problem: You need to trace the full call stack leading to an error.

Solution: Python traceback objects form a chain using tb_next.

Python lets you walk the full traceback using tb_next.

def a():
    b()

def b():
    c()

def c():
    1 / 0

try:
    a()
except ZeroDivisionError as e:
    tb = e.__traceback__
    while tb:
        print("Function:", tb.tb_frame.f_code.co_name)
        tb = tb.tb_next
# prints:
# Function: c
# Function: b
# Function: a

You can walk the call chain backwards from the point of error using the tb_next link.

Problem: How do you print a traceback yourself in Python?

You are writing a tool that logs errors to a file. You want to include the full stack trace, not just the error message.

Problem: You want to format and print the traceback manually.

Solution: Python has a traceback module that can format tracebacks from objects.

Python lets you print full tracebacks using the traceback module.

import traceback

try:
    open("/this/does/not/exist.txt")
except Exception as e:
    traceback.print_tb(e.__traceback__)
# prints:
#   File "example.py", line 3, in <module>
#     open("/this/does/not/exist.txt")

This gives you a clean traceback without exiting the program.

Problem: How do you access traceback information from outside an `except` block in Python?

You are running code in a notebook or tool. You want to access the last traceback after the program stops. You did not save the error at the time.

Problem: You want to read the last exception traceback after the program ends.

Solution: Python keeps the last traceback in sys.last_traceback when run interactively.

Python lets you access the last traceback using the sys module.

import sys

# Only works in interactive mode:
# sys.last_traceback

This lets you recover traceback details even if the program already stopped. It only works if Python is running in interactive mode and the error was uncaught.

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 Special Method Names

Mike Vincent — Sat, 16 May 2026 12:29:40 +0000

Quark’s Outlines: Python Special Method Names

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Special Method Names

What are Python special method names?

When you use built-in syntax in Python, like +, [], or len(), Python checks if the object has a matching method with a special name. These are called Python special method names. They let your class behave like other built-in types.

Each special method has a name with two underscores before and after it. For example, __add__ lets your object respond to +, and __getitem__ lets your object respond to indexing like obj[2].

Python lets classes use special method names to behave like built-in types.

class Item:
    def __getitem__(self, index):
        return index * 2

x = Item()
print(x[3])
# prints:
# 6

When you use x[3], Python runs x.__getitem__(3) because the class defined that method.

Why use Python special method names?

You use special method names to give your object custom behavior when used in common expressions. You can define how your object adds, subtracts, prints, or compares. These names give you control without writing extra code for every case.

You do not call special methods directly in normal code. Python calls them for you when your object is used with special syntax.

Python calls special method names automatically when using common syntax.

class Greeter:
    def __str__(self):
        return "Hello!"

g = Greeter()
print(g)
# prints:
# Hello!

The print() function uses str(g), which calls g.__str__() to get the string value.

A Historical Timeline of Python Special Method Names

Where do Python’s special method names come from?

Python special method names come from earlier object models that used hidden function calls to support operators and custom syntax. Python exposed those methods with a clear naming pattern so users could build objects that act like built-ins.

People created ways to override behavior in custom types

1970 — Simula and Smalltalk introduced object methods to control print, math, and access.

1983 — C++ operator overloading let programmers define how +, ==, and [] work for their own classes.

People added readable hooks to Python objects

1991 — Python object model introduced dunder methods (like __getitem__) to let user-defined classes support special syntax.

2000 — New-style classes in Python 2.2 unified the object model, making all types use special methods.

2013 — Function annotations and class introspection used __annotations__, __class__, and other internal names.

2025 — Stable core dunder names became essential for all custom types and data classes, with no new names added in recent releases.

Problems & Solutions with Python Special Method Names

How do you use Python special method names the right way?

Python special method names let your class support syntax that feels natural. These problems show how to use them to add math, indexing, string conversion, length, and iteration to your custom classes. Each solution shows how Python lets you control behavior using the correct special method.

Problem: How do you support `+` for your object in Python?

You are making a custom class that holds a number. You want to let users add two of your objects with the + symbol, the same way they add numbers. But Python does not know how to add your objects unless you tell it how.

Problem: You want your class to support +.

Solution: Python calls __add__() when two objects are added.

Python lets you define __add__() to support +.

class Box:
    def __init__(self, value):
        self.value = value
    def __add__(self, other):
        return Box(self.value + other.value)
    def __str__(self):
        return str(self.value)

a = Box(5)
b = Box(3)
c = a + b
print(c)
# prints:
# 8

The method __add__() lets your class handle +. The result is another Box with the new total.

Problem: How do you make your object show custom text with `print()` in Python?

You want your object to show a friendly message when someone prints it. By default, Python shows the memory address. You want it to show a message instead.

Problem: You want your object to return a message when printed.

Solution: Python uses __str__() to get the string for print().

Python lets you define __str__() to control how objects print.

class Pet:
    def __str__(self):
        return "This is your pet."

p = Pet()
print(p)
# prints:
# This is your pet.

The __str__() method lets you return a string that print() will show.

Problem: How do you let your object be used like a list in Python?

You made a custom data class. You want people to use square brackets [] to get values, just like with lists. But Python does not know how unless you define a method.

Problem: You want your object to support indexing.

Solution: Python calls __getitem__() when using brackets.

Python lets you define __getitem__() to allow square bracket access.

class Pair:
    def __getitem__(self, i):
        return ["left", "right"][i]

p = Pair()
print(p[1])
# prints:
# right

The __getitem__() method lets your object handle p[1] like a list or string.

Problem: How do you let your object work with `len()` in Python?

You want your class to tell how many items it holds. You want to use len(obj), but Python cannot do that unless your object supports it.

Problem: You want to let len(obj) work with your object.

Solution: Python calls __len__() when you use len().

Python lets you define __len__() to support length checks.

class Trio:
    def __len__(self):
        return 3

t = Trio()
print(len(t))
# prints:
# 3

This method makes len(t) return 3 because you defined it that way.

Problem: How do you make your object work in a for-loop in Python?

You want users to loop over your object with for x in obj:. Right now Python does not know how. You want to return one value at a time from inside your object.

Problem: You want your object to be used in a loop.

Solution: Python uses __iter__() and __next__() to support loops.

Python lets you define __iter__() to support iteration.

class CountDown:
    def __init__(self, start):
        self.current = start
    def __iter__(self):
        return self
    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current + 1

for n in CountDown(3):
    print(n)
# prints:
# 3
# 2
# 1

When used in a loop, Python runs __iter__() to get the object and calls __next__() to get each value.

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

Mike Vincent — Sat, 09 May 2026 12:27:23 +0000

Quark’s Outlines: Python Slice Objects

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Slice Objects

What is a Python slice object?

When you want to take part of a list or string in Python, you use a slice. A Python slice object is what Python uses behind the scenes when you use slice notation like a[1:4].

You can also create a slice object yourself using the built-in slice() function. A slice object has three parts: a start, a stop, and a step. These tell Python where to begin, where to end, and how far to jump between values.

Python lets you describe parts of a sequence using slice objects.

s = slice(1, 5, 2)
print(s.start, s.stop, s.step)
# prints:
# 1 5 2

You can pass this object to any indexable type that accepts slices, such as lists, strings, or tuples.

Problem: How do you use Python slice objects with lists in Python?

You can apply a slice object directly to a list. This gives you a way to reuse the same slice pattern across different lists or strings. A slice object is used the same way as writing a[start:stop:step] in normal slice notation.

Python slice objects can be used as reusable slicing tools.

data = ['a', 'b', 'c', 'd', 'e']
part = slice(1, 4)
print(data[part])
# prints:
# ['b', 'c', 'd']

This helps when you want to define the slice once and use it many times.

What are extended Python slice objects?

Python slice objects can express more than just start and stop. They can also use a step. This allows you to skip values, move backwards, or extract patterns in regular steps.

Slice objects with steps are often called extended slices. You can write them with double colons like a[::2] or make them with slice(start, stop, step).

Python lets you use slice steps to skip or reverse items.

data = [0, 1, 2, 3, 4, 5, 6]
print(data[::2])
# prints:
# [0, 2, 4, 6]

The step of 2 means every other item is included. A negative step moves backwards.

A Historical Timeline of Python Slice Objects

Where do Python’s slice objects come from?

Python slice objects were created to make sequence access flexible and readable. Python built on older ideas from languages like ALGOL and C but added rich slicing as a first-class concept. The timeline shows how slices grew from syntax into objects.

People built tools to slice sequences in math and code

1960 — Array slicing in ALGOL 60 let programmers work with parts of arrays using range syntax.

1972 — Pointer arithmetic in C let programmers access memory in flexible steps but with more risk.

People designed Python slice syntax and objects

1991 — Slice notation added in Python 0.9.0 using a[start:stop] for lists and strings.

2001 — Slice objects created in Python 2.2 with the slice() function and support for start, stop, and step.

2006 — Ellipsis added to slicing, allowing a[..., 1:3] in advanced data types like NumPy arrays.

2015 — Slicing with custom classes supported when classes defined __getitem__ with slice detection.

2025 — Slice behavior stable with built-in support for slicing strings, bytes, ranges, and user-defined types.

Problems & Solutions with Python Slice Objects

How do you use Python slice objects the right way?

Python slice objects give you a way to describe how to take part of a sequence. These problems show how slice objects can help you break up data, skip items, move backward, and reuse slice logic across different parts of your program.

Problem: How do you reuse the same slice across different data in Python?

You are working with two lists and a string. You want to take the same part of each one. You do not want to write the same start:stop slice over and over. You want a way to define the slice once and use it many times.

Problem: You want to reuse slice logic across different sequences.

Solution: Python lets you create a slice object with slice() and use it like obj[slice_obj].

Python lets you apply the same slice object to many values.

part = slice(2, 5)
words = ['zero', 'one', 'two', 'three', 'four', 'five']
text = "abcdefg"

print(words[part])
print(text[part])
# prints:
# ['two', 'three', 'four']
# cde

The slice object works the same way for strings and lists. You define the slice once and reuse it.

Problem: How do you extract every other item in Python?

You have a list with many items. You only want every second item. You could use a loop, but that takes more lines and more thought. You want a quick way to skip items while slicing.

Problem: You need to select values in regular steps.

Solution: Python lets you set the step part of a slice to skip items.

Python lets you use steps in slices to skip values.

data = [10, 20, 30, 40, 50, 60]
print(data[::2])
# prints:
# [10, 30, 50]

The slice ::2 means "start at the beginning and take every second item."

Problem: How do you move through a list backwards in Python?

You want to read a list from end to start. You do not want to reverse it in place or make a copy. You want to get the reversed values using slice logic.

Problem: You need to move through a list in reverse order.

Solution: Python slices accept negative step values.

Python lets you move backwards using a slice step of -1.

nums = [1, 2, 3, 4, 5]
print(nums[::-1])
# prints:
# [5, 4, 3, 2, 1]

The slice [::-1] means "start at the end and move backward one step at a time."

Problem: How do you pass a slice into a function in Python?

You have a utility function that should return a portion of any list. You want to pass the slice as a parameter instead of hard-coding it.

Problem: You want to pass slice behavior as a value.

Solution: Python lets you pass a slice object as an argument.

Python lets you pass slice objects into functions.

def get_part(data, s):
    return data[s]

items = ['a', 'b', 'c', 'd', 'e']
s = slice(1, 4)
print(get_part(items, s))
# prints:
# ['b', 'c', 'd']

Now you can change the slice logic outside the function and keep the function simple.

Problem: How do you describe a slice without knowing the type in Python?

You are working with custom objects that support slicing. You want to describe a slice without using normal [:] syntax. You want a way to create slices even if the data type is not a list or string.

Problem: You want a general way to describe a slice in code.

Solution: Python lets you make a slice object using the built-in slice() function.

Python lets you build slice objects without using [].

s = slice(0, 3)
print(s.start, s.stop, s.step)
# prints:
# 0 3 None

This object can be used on any sequence-like type that accepts slices, including user-defined classes with special methods.

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

Mike Vincent — Sat, 02 May 2026 12:25:50 +0000

Quark’s Outlines: Python Name Spaces

Overview, Historical Timeline, Problems & Solutions

An Overview of Python Name Spaces

What is a Python name space?

When you write code in Python, you give names to values. A Python name space is the place where those names are stored. It is like a labeled shelf that holds objects. When you ask for a name, Python looks in the shelf to find it.

A name space is a mapping between names and objects. In Python, that mapping is usually a dictionary. Each name space stores the current known names and their values.

Python lets you manage names by storing them in name spaces.

x = 5
print(globals()["x"])
# prints:
# 5

The globals() function returns the current global name space. You can look up a name and find its value.

How many name spaces does Python use?

Python uses three main name spaces when running code: local, global, and built-in. Each one is searched in order when Python tries to find a name. Local is the first shelf. Global is the next shelf. Built-in is the last shelf.

Each function or block of code runs in its own execution frame. The frame sets the local and global name spaces.

Python searches for names in a fixed order: local, global, built-in.

def demo():
    x = 10
    print(locals()["x"])

demo()
# prints:
# 10

Here, locals() returns the local name space of the demo() function. Python found the name x there.

How do names become local or global?

When Python sees a name, it decides if that name is local or global by looking at how you use it. If you assign a value to the name in a code block, Python makes it local. If you use global, Python treats it as global. The same rule applies to nonlocal for nested functions.

You cannot assign to a global name without saying so. You must declare it first with global.

Python lets you control where a name lives using global or nonlocal.

count = 0

def add():
    global count
    count += 1

add()
print(count)
# prints:
# 1

Without the global statement, the name count would be treated as a new local name and not affect the global value.

A Historical Timeline of Python Name Spaces

Where do Python’s name space rules come from?

Python name spaces follow from long traditions in structured programming. They help manage how values are stored and found. This timeline shows how Python shaped its name space model by building on earlier systems and simplifying control.

People designed scope and name systems in programming

1960 — Block scope in ALGOL introduced local variables and nested name visibility.

1972 — Global and local stacks in C separated function-level and file-level scope.

People built Python’s three-level name space model

1991 — Python 0.9.0 introduced global, local, and built-in name spaces tied to execution frames.

2000 — Dynamic features like exec and eval worked with customizable name space dictionaries.

2003 — Global and nonlocal statements became required to rebind outer names safely.

2010 — Function scoping stabilized with improved shadowing rules and traceability.

2025 — Stable execution model kept the name space structure clear and unchanged.

Problems & Solutions with Python Name Spaces

How do you use Python name spaces the right way?

Python uses name spaces to keep values organized while code runs. Each code block runs inside a frame, and each frame has local and global name spaces. These problems show how name spaces affect what Python sees and what it cannot see.

Problem: How do you modify a name in the outer scope in Python?

You define a value and use it inside a function. But when you run the function, Python says the name does not exist. You expected Python to use your global variable, but it made a new local one.

Problem: You want to share a name between a function and the outer scope.

Solution: Python lets you mark the name as global to make it refer to the same value everywhere.

Python lets you bind names to global space using global.

counter = 0

def step():
    global counter
    counter += 1

step()
print(counter)
# prints:
# 1

Without the global line, Python would raise an error because counter += 1 would try to read an uninitialized local name.

Problem: How do you see what names are in use in Python?

You are writing a function that changes many variables. You want to see what names are active inside the function as it runs. You also want to inspect the global names.

Problem: You want to examine the current local and global name spaces.

Solution: Python provides locals() and globals() to return the current mappings.

Python lets you see active names using built-in inspection tools.

x = 100

def report():
    y = 200
    print("Local:", locals())
    print("Global:", "x =", globals()["x"])

report()
# prints:
# Local: {'y': 200}
# Global: x = 100

Python shows the two separate name spaces so you can know which values are in each.

Problem: How do you avoid accidental name changes in Python?

You write a helper function that uses the same name as one of your main program variables. Now your main value is changed unexpectedly after calling the helper.

Problem: You want to keep helper names separate from program names.

Solution: Python keeps local name spaces separate by default. Avoid global names inside functions unless needed.

Python keeps function names isolated using local name spaces.

value = "main"

def helper():
    value = "helper"
    print("Inside:", value)

helper()
print("Outside:", value)
# prints:
# Inside: helper
# Outside: main

Each block has its own space. Reusing a name locally does not affect the global value unless you declare it as global.

Problem: How do you use `eval()` safely in Python?

You want to evaluate a string as code. You want to control what names the string sees when it runs.

Problem: You want to give custom name spaces to code run with eval().

Solution: Python lets you pass dictionaries to control global and local name spaces in eval().

Python lets you set name space mappings for dynamic code.

scope = {"x": 2, "y": 3}
print(eval("x * y", scope))
# prints:
# 6

The string "x * y" is evaluated using the custom scope dictionary. Python does not use the default globals or locals.

Problem: handle name lookup when a name is missing

You write code that refers to a name, but you forget to define it. When Python runs, it stops with an error. You want to understand what error this is and how Python looks for names.

Problem: You want to know what happens when a name is not found.

Solution: Python looks in local, then global, then built-in name spaces. If no match is found, it raises a NameError.

Python raises an error when name lookup fails in all name spaces.

try:
    print(missing_name)
except NameError as e:
    print("Caught error:", e)
# prints:
# Caught error: name 'missing_name' is not defined

Python checks each shelf of names in order. If the name is not on any shelf, it stops and reports the problem.

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

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

DEV Community: Mike Vincent

Quark's Outlines: Python User-defined Functions

Quark’s Outlines: Python User-Defined Functions

An Overview of Python User-Defined Functions

What is a Python user-defined function?

What are the special parts of a Python function?

A Historical Timeline of Python User-Defined Functions

People designed ways to name and reuse logic

People added first-class functions to Python

Problems & Solutions with Python User-Defined Functions

Problem: How do you reuse the same logic with different inputs in Python?

Problem: How do you define a function with default values in Python?

Problem: How do you check what a function holds in Python?

Problem: How do you store a function for later use in Python?

Problem: How do you check a function's global names in Python?

Like, Comment, Share, and Subscribe

Quark's Outlines: Python Traceback Objects

Quark’s Outlines: Python Traceback Objects

An Overview of Python Traceback Objects

What is a Python traceback object?

What does a Python traceback object contain?

A Historical Timeline of Python Traceback Objects

People invented ways to trace error locations

People designed traceback support in Python

Problems & Solutions with Python Traceback Objects

Problem: How do you get the line where an error occurred in Python?

Problem: How do you find the function where the error happened in Python?

Problem: How do you follow all the steps that led to an error in Python?

Problem: How do you print a traceback yourself in Python?

Problem: How do you access traceback information from outside an except block in Python?

Like, Comment, Share, and Subscribe

Quark's Outlines: Python Special Method Names

Quark’s Outlines: Python Special Method Names

An Overview of Python Special Method Names

What are Python special method names?

Why use Python special method names?

A Historical Timeline of Python Special Method Names

People created ways to override behavior in custom types

People added readable hooks to Python objects

Problems & Solutions with Python Special Method Names

Problem: How do you support + for your object in Python?

Problem: How do you make your object show custom text with print() in Python?

Problem: How do you let your object be used like a list in Python?

Problem: How do you let your object work with len() in Python?

Problem: How do you make your object work in a for-loop in Python?

Like, Comment, Share, and Subscribe

Quark's Outlines: Python Slice Objects

Quark’s Outlines: Python Slice Objects

An Overview of Python Slice Objects

What is a Python slice object?

Problem: How do you use Python slice objects with lists in Python?

What are extended Python slice objects?

A Historical Timeline of Python Slice Objects

People built tools to slice sequences in math and code

People designed Python slice syntax and objects

Problems & Solutions with Python Slice Objects

Problem: How do you reuse the same slice across different data in Python?

Problem: How do you extract every other item in Python?

Problem: How do you move through a list backwards in Python?

Problem: How do you pass a slice into a function in Python?

Problem: How do you describe a slice without knowing the type in Python?

Like, Comment, Share, and Subscribe

Quark's Outlines: Python Name Spaces

Quark’s Outlines: Python Name Spaces

An Overview of Python Name Spaces

What is a Python name space?

How many name spaces does Python use?

How do names become local or global?

A Historical Timeline of Python Name Spaces

People designed scope and name systems in programming

People built Python’s three-level name space model

Problems & Solutions with Python Name Spaces

Problem: How do you modify a name in the outer scope in Python?

Problem: How do you see what names are in use in Python?

Problem: How do you avoid accidental name changes in Python?

Problem: How do you use eval() safely in Python?

Problem: handle name lookup when a name is missing

Like, Comment, Share, and Subscribe

Quark's Outlines: Python Internal Types

Quark’s Outlines: Python Internal Types

Problem: How do you access traceback information from outside an `except` block in Python?

Problem: How do you support `+` for your object in Python?

Problem: How do you make your object show custom text with `print()` in Python?

Problem: How do you let your object work with `len()` in Python?

Problem: How do you use `eval()` safely in Python?