Adding custom attributes in Python - Deep Dive

Overview - Adding custom attributes

What is it?

Adding custom attributes means giving extra information or properties to objects in Python. These attributes are like labels or data points attached to an object that describe it or store values. You can add these attributes to built-in objects, your own classes, or instances to make them more useful. This helps you keep track of more details about your objects beyond their default features.

Why it matters

Without the ability to add custom attributes, objects would be limited to only their built-in properties, making them less flexible and less descriptive. Adding custom attributes lets you tailor objects to your specific needs, making your code more organized and powerful. It allows you to store extra data directly on objects, which can simplify your programs and reduce the need for separate data structures.

Where it fits

Before learning this, you should understand what objects and classes are in Python. After mastering custom attributes, you can explore more advanced topics like property decorators, descriptors, and metaclasses that control attribute behavior in deeper ways.

Mental Model

Core Idea

Custom attributes are like sticky notes you attach to objects to store extra information that the object doesn't have by default.

Think of it like...

Imagine a plain suitcase (object) that you can stick colorful labels (custom attributes) on to remember what's inside or where it should go. These labels don't change the suitcase itself but add useful details for you.

Object
  ├─ Built-in attributes
  └─ Custom attributes (added by you)

Example:
  MyObject
  ├─ name: 'Alice' (built-in)
  └─ favorite_color: 'blue' (custom)

Build-Up - 7 Steps

1

Foundation

Understanding Python objects basics

Concept: Learn what Python objects are and how they have attributes.

In Python, everything is an object. Objects have attributes, which are like variables attached to them. For example, a string object has attributes and methods like .upper() or .lower(). You can see attributes using the dir() function.

Result

You understand that objects hold data and behavior through attributes.

Knowing that objects have attributes is the base for adding your own extra information to them.

2

Foundation

Creating classes and instances

Concept: Learn how to define your own classes and create objects (instances) from them.

A class is like a blueprint for objects. You define a class with the class keyword and create instances by calling the class. Instances can have attributes that store data specific to them.

Result

You can make your own objects with custom data fields.

Understanding classes and instances is essential because custom attributes are often added to instances.

3

Intermediate

Adding attributes dynamically to instances

🤔Before reading on: do you think you can add new attributes to an object after it is created? Commit to your answer.

Concept: You can add new attributes to an object at any time by assigning to them using dot notation.

After creating an instance, you can add a new attribute by writing object.attribute = value. For example: class Dog: pass my_dog = Dog() my_dog.name = 'Buddy' my_dog.age = 5 Now my_dog has two custom attributes: name and age.

Result

The object now holds extra data you added dynamically.

Knowing that attributes can be added anytime makes Python objects very flexible and adaptable.

4

Intermediate

Using __init__ to set attributes on creation

🤔Before reading on: do you think attributes can only be added after creation, or also during creation? Commit to your answer.

Concept: You can define an __init__ method in your class to set attributes when an object is created.

The __init__ method runs automatically when you create an instance. You can use it to set initial attributes: class Car: def __init__(self, make, year): self.make = make self.year = year my_car = Car('Toyota', 2020) Now my_car has make and year attributes set at creation.

Result

Objects start with custom attributes already set.

Using __init__ helps organize attribute setup and ensures objects have needed data from the start.

5

Intermediate

Adding attributes to built-in objects

🤔Before reading on: do you think you can add custom attributes to built-in Python objects like strings or lists? Commit to your answer.

Concept: Some built-in objects allow adding custom attributes, but many do not because they are implemented in C and are immutable or fixed.

For example, you cannot add attributes to a string: s = 'hello' s.color = 'red' # This causes an AttributeError But you can add attributes to a user-defined object or some mutable built-in types like lists if subclassed.

Result

You learn which objects support custom attributes and which do not.

Knowing this prevents errors and helps you choose when to use custom classes.

6

Advanced

Using __slots__ to control attributes

🤔Before reading on: do you think Python objects can limit which attributes they allow? Commit to your answer.

Concept: The __slots__ feature lets you restrict which attributes an object can have, saving memory and preventing accidental additions.

By defining __slots__ in a class, you tell Python to only allow certain attribute names: class Point: __slots__ = ['x', 'y'] def __init__(self, x, y): self.x = x self.y = y p = Point(1, 2) p.z = 3 # Raises AttributeError This prevents adding attributes not listed in __slots__.

Result

Objects have fixed attribute sets, improving performance and safety.

Understanding __slots__ helps you write efficient and predictable classes in large programs.

7

Expert

Customizing attribute access with __getattr__ and __setattr__

🤔Before reading on: do you think you can control what happens when attributes are accessed or set? Commit to your answer.

Concept: You can override special methods __getattr__ and __setattr__ to customize how attributes are retrieved or assigned.

By defining __getattr__(self, name), you can provide values for attributes that don't exist. __setattr__(self, name, value) lets you control or validate attribute assignments. Example: class Config: def __init__(self): self._data = {} def __getattr__(self, name): return self._data.get(name, 'default') def __setattr__(self, name, value): if name == '_data': super().__setattr__(name, value) else: self._data[name] = value c = Config() c.theme = 'dark' print(c.theme) # Outputs 'dark' print(c.font) # Outputs 'default'

Result

You gain full control over attribute behavior, enabling advanced patterns.

Mastering these methods unlocks powerful ways to manage object state and behavior dynamically.

Under the Hood

Python objects store attributes in a dictionary called __dict__ by default. When you access or assign an attribute, Python looks it up or sets it in this dictionary. Special methods like __getattr__ and __setattr__ intercept attribute access and assignment, allowing custom behavior. Using __slots__ replaces the __dict__ with a fixed structure, saving memory and restricting attributes.

Why designed this way?

Python's flexible attribute system was designed to make objects highly dynamic and easy to extend. The __dict__ allows adding attributes at runtime, which fits Python's philosophy of simplicity and flexibility. __slots__ was introduced later to optimize memory usage for large numbers of objects. Special methods for attribute access provide hooks for advanced customization without changing the core object model.

Object
  ├─ __dict__ (stores attributes as key-value pairs)
  ├─ attribute access
  │    ├─ check __getattribute__
  │    ├─ if missing, call __getattr__
  ├─ attribute assignment
  │    ├─ call __setattr__
  └─ __slots__ (optional fixed attribute storage)

Myth Busters - 4 Common Misconceptions

Quick: Can you add any attribute to any Python object at any time? Commit to yes or no.

Common Belief: You can always add any custom attribute to any Python object whenever you want.

Reality: Some built-in types like strings, integers, and tuples do not allow adding new attributes because they are immutable and implemented in C.

Why it matters: Trying to add attributes to such objects causes errors and confusion, wasting time debugging.

Quick: Does defining __slots__ mean you cannot add any attributes at all? Commit to yes or no.

Common Belief: Using __slots__ completely disables adding any new attributes to an object.

Reality: __slots__ restricts attributes to a fixed set but does not disable attributes entirely; you can still use the listed ones.

Why it matters: Misunderstanding __slots__ can lead to unnecessary avoidance of this useful feature or incorrect code.

Quick: Does __getattr__ get called for every attribute access? Commit to yes or no.

Common Belief: __getattr__ is called every time you access any attribute on an object.

Reality: __getattr__ is only called when the attribute is not found by normal means.

Why it matters: Misusing __getattr__ can cause performance issues or unexpected behavior if you expect it to run always.

Quick: Can you rely on adding attributes to built-in objects for production code? Commit to yes or no.

Common Belief: Adding attributes to built-in objects like lists or dicts is safe and common in production.

Reality: It is generally discouraged because it can cause confusing bugs and is not supported for many built-in types.

Why it matters: Relying on this can make code fragile and hard to maintain.

Expert Zone

1

Custom attributes added dynamically do not appear in __slots__-defined classes, which can cause subtle bugs if mixing both.

2

Overriding __setattr__ requires careful use of super() to avoid infinite recursion when setting attributes.

3

Using __getattr__ to provide default values can hide bugs where attributes are misspelled or missing unintentionally.

When NOT to use

Avoid adding custom attributes to immutable built-in types or objects where attribute control is critical. Instead, use wrapper classes or composition. For performance-critical code, prefer __slots__ or namedtuple. When you need strict attribute validation, use properties or descriptors instead of free-form attributes.

Production Patterns

In real-world code, custom attributes are often used to store metadata, cache results, or track state on objects. Frameworks like Django use custom attributes extensively for model fields and querysets. Advanced libraries use __getattr__ and __setattr__ to implement lazy loading, proxies, or dynamic APIs.

Connections

Object-oriented programming

Custom attributes build on the idea of objects having state and behavior.

Understanding custom attributes deepens your grasp of how objects encapsulate data and how you can extend them.

Memory optimization

Using __slots__ connects attribute management to memory efficiency techniques.

Knowing attribute storage helps you write programs that use less memory and run faster.

Human memory and note-taking

Adding custom attributes is like adding notes to objects, similar to how people add sticky notes to remember details.

This connection shows how programming concepts often mirror natural human strategies for managing information.

Common Pitfalls

#1 Trying to add attributes to immutable built-in types causes errors.

Wrong approach:

s = 'hello'
s.color = 'red' # AttributeError

Correct approach:

class MyString:
def __init__(self, text):
self.text = text
self.color = 'red'

s = MyString('hello')

Root cause:

Immutable built-in types do not support dynamic attribute assignment.

#2 Forgetting to call super() in __setattr__ causes infinite recursion.

Wrong approach:

def __setattr__(self, name, value):
self.__dict__[name] = value # This calls __setattr__ again, causing recursion

Correct approach:

def __setattr__(self, name, value):
super().__setattr__(name, value)

Root cause:

Directly assigning to self.attribute inside __setattr__ triggers itself recursively.

#3 Misusing __getattr__ to always return a default hides bugs.

Wrong approach:

def __getattr__(self, name):
return 'default' # Returns default even for typos

Correct approach:

def __getattr__(self, name):
if name in allowed:
return 'default'
else:
raise AttributeError(f"{name} not found")

Root cause:

Blindly returning defaults can mask errors and make debugging hard.

Key Takeaways

Adding custom attributes lets you extend objects with new data anytime, making your code more flexible.

Not all Python objects support adding attributes; built-in immutable types usually do not.

The __init__ method is the standard way to set attributes when creating objects.

__slots__ can restrict attributes and save memory but requires careful use.

Overriding __getattr__ and __setattr__ gives powerful control over attribute access but can introduce subtle bugs if misused.