Introspecting Python Objects

Python
class Animal:
    """Base class for animals."""
    pass

class Dog(Animal):
    """A dog."""
    pass

d = Dog()

d.__class__          # <class '__main__.Dog'>
d.__dict__           # {} (instance attribute dict)
Dog.__name__         # 'Dog'
Dog.__qualname__     # 'Dog'
Dog.__mro__          # (Dog, Animal, object)
Dog.__bases__        # (Animal,)
Dog.__doc__          # 'A dog.'
Dog.__module__       # '__main__'

Progress:

• Identify what kind of introspection is needed (identity, hierarchy, namespace, or metadata)
• Pick the correct special attribute(s) for that object type
• Handle attributes that may not exist (use getattr with defaults or hasattr)
• Distinguish instance-level vs class-level attribute access
• Validate results against edge cases (built-ins, slots, dynamic classes)

Step 1: Identify the introspection goal

Step 2: Choose instance vs. class access

• type(obj).__mro__ works; obj.__mro__ does not (MRO is a class-only attribute).
• obj.__dict__ gives per-instance attributes; type(obj).__dict__ gives the class namespace (a mappingproxy, read-only).
• Objects using __slots__ have no __dict__ unless __dict__ is explicitly included in slots.

Step 3: Guard against missing attributes

Not all objects define every special attribute (e.g., built-in types, __slots__ classes lack __dict__; lambdas have __qualname__ like <locals>.<lambda>). Always prefer getattr(obj, '__dict__', None) or hasattr in generic tooling.

Example 1: Inspecting instance vs class dict Input:

Python
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(1, 2)

Output:

Python
p.__dict__          # {'x': 1, 'y': 2}
Point.__dict__       # mappingproxy({'__init__': <function...>, '__dict__': <attribute...>, '__weakref__': <attribute...>, '__doc__': None})

Example 2: Walking the MRO for a diamond hierarchy Input:

Python
class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass

D.__mro__

Output:

Python
(<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)

Example 3: Qualname vs name for nested definitions Input:

Python
class Outer:
    class Inner:
        def method(self): pass

Outer.Inner.method.__name__
Outer.Inner.method.__qualname__

Output:

Python
'method'
'Outer.Inner.method'

Example 4: Slots preventing dict Input:

Python
class Slotted:
    __slots__ = ('x',)

s = Slotted()
s.x = 5
s.__dict__

Output:

Python
AttributeError: 'Slotted' object has no attribute '__dict__'