Object Model
CPython treats almost every value as an object, so attribute lookup, method calls, mutability, identity, `__slots__`, and many performance tradeoffs all connect back to the object model.
Quick takeaway: a CPython object is useful to picture as "reference count + pointer to type + value fields." Type objects and slots drive attribute access, operator behavior, and method binding.
Start With the Structure
What a Bound Method Carries
class User:
def greet(self) -> str:
return "hello"
user = User()
method = user.greet
print("bound method type:", type(method).__name__)
print("method.__self__ is user:", method.__self__ is user)
print("method.__func__ is User.greet:", method.__func__ is User.greet)When you access a function through an instance, CPython creates a bound method object that carries both the original function and the bound instance.
When __slots__ Helps
class RegularUser:
def __init__(self, name: str, age: int) -> None:
self.name = name
self.age = age
class SlottedUser:
__slots__ = ("name", "age")
def __init__(self, name: str, age: int) -> None:
self.name = name
self.age = age__slots__can reduce per-instance memory by removing the instance dictionary.- It also changes flexibility and some introspection behavior.
- That makes it a targeted optimization tool, not a default style.
Why Mutability and Identity Matter Together
- immutable objects make sharing easier
- mutable objects separate identity from changing value
- cache keys, shared state, and default-argument surprises all connect here
Practical Connections
- attribute-heavy domain models
- when to consider
__slots__ - intuition for method dispatch cost
Checklist
Attribute access has a cost model
Readable syntax still goes through descriptors, instance dictionaries, and class lookup.
Bound methods are objects too
Repeated method access has a small but real object-model cost.
Use `__slots__` intentionally
It is a memory and layout optimization, not a universal best practice.
Keep identity separate from value
That distinction becomes important whenever mutable state is shared or cached.