Accessing and modifying attributes in Python - Deep Dive

Overview - Accessing And Modifying Attributes

What is it?

Accessing and modifying attributes means reading or changing the values stored inside an object in Python. Attributes are like properties or characteristics that belong to an object. You can get the current value of an attribute or update it to a new value using simple syntax. This lets you control and customize how objects behave and store information.

Why it matters

Without the ability to access and modify attributes, objects would be fixed and unchangeable, making programs rigid and less useful. This concept allows programs to store data inside objects and update it as needed, which is essential for modeling real-world things that change over time. It makes code flexible, reusable, and easier to understand by organizing data logically.

Where it fits

Before learning this, you should understand what objects and classes are in Python. After mastering attribute access and modification, you can learn about special methods like property decorators and how to control attribute access with getters and setters. This topic is a foundation for object-oriented programming and working with more advanced Python features.

Mental Model

Core Idea

Attributes are named pieces of data inside an object that you can read or change to control the object's state.

Think of it like...

Think of an object as a car, and attributes as parts like color, speed, or fuel level. You can look at the speedometer to see the current speed (access attribute) or press the gas pedal to change the speed (modify attribute).

Object
┌───────────────┐
│   Attributes  │
│ ┌───────────┐ │
│ │ color = 'red' │
│ │ speed = 50   │
│ │ fuel = 10    │
│ └───────────┘ │
└───────────────┘

Access: obj.color → 'red'
Modify: obj.speed = 60

Build-Up - 7 Steps

1

Foundation

What Are Object Attributes

Concept: Attributes are variables that belong to an object and hold its data.

In Python, when you create an object from a class, it can have attributes that store information. For example, a Dog object might have a name and age. These attributes are like labels attached to the object that hold values. Example: class Dog: def __init__(self, name, age): self.name = name # attribute self.age = age # attribute my_dog = Dog('Buddy', 5) print(my_dog.name) # Access attribute print(my_dog.age)

Result

Buddy 5

Understanding that attributes are just variables tied to an object helps you see how objects store their own data separately.

2

Foundation

Accessing Attributes Using Dot Notation

Concept: You use the dot (.) to get the value of an attribute from an object.

To read an attribute's value, write the object name, then a dot, then the attribute name. Example: print(my_dog.name) # Outputs the dog's name You can also use the built-in function getattr(object, 'attribute_name') to access attributes dynamically.

Result

Buddy

Knowing dot notation is the standard way to reach inside an object to get its data is key to working with objects in Python.

3

Intermediate

Modifying Attributes Directly

Concept: You can change an attribute's value by assigning a new value using dot notation.

To update an attribute, write the object name, dot, attribute name, then equals and the new value. Example: my_dog.age = 6 print(my_dog.age) # Now the age is updated This changes the object's internal state.

Result

6

Directly changing attributes lets you update an object's data anytime, reflecting changes in the real world or program state.

4

Intermediate

Using setattr and getattr Functions

🤔Before reading on: do you think setattr can create new attributes on the fly or only modify existing ones? Commit to your answer.

Concept: Python provides functions to get and set attributes dynamically by name as strings.

getattr(obj, 'attr') returns the value of 'attr' from obj. setattr(obj, 'attr', value) sets 'attr' to value on obj. Example: setattr(my_dog, 'color', 'brown') # Adds a new attribute print(getattr(my_dog, 'color')) # Outputs 'brown'

Result

brown

Using getattr and setattr allows flexible code that can work with attribute names stored in variables or user input.

5

Intermediate

Deleting Attributes with delattr

🤔Before reading on: do you think deleting an attribute removes it permanently or just hides it temporarily? Commit to your answer.

Concept: You can remove an attribute from an object using delattr or the del keyword.

delattr(obj, 'attr') deletes the attribute named 'attr' from obj. Example: delattr(my_dog, 'color') # Now my_dog.color no longer exists and will raise an error if accessed.

Result

AttributeError if accessed after deletion

Knowing how to remove attributes helps manage object state and avoid stale or unwanted data.

6

Advanced

Controlling Attribute Access with Properties

🤔Before reading on: do you think properties store data themselves or just control access to other data? Commit to your answer.

Concept: Properties let you define methods that act like attributes, controlling how values are read or changed.

Using @property decorator, you can create a method that looks like an attribute but runs code when accessed. Example: class Person: def __init__(self, name): self._name = name @property def name(self): return self._name.upper() # Return name in uppercase p = Person('alice') print(p.name) # Outputs 'ALICE' You can also define a setter with @name.setter to control modifications.

Result

ALICE

Properties provide a safe way to customize attribute behavior without changing how code accesses them.

7

Expert

Attribute Access Internals and __getattr__ Magic

🤔Before reading on: do you think __getattr__ is called for all attribute accesses or only missing ones? Commit to your answer.

Concept: __getattr__ and __setattr__ are special methods that let you customize what happens when attributes are accessed or set.

If an attribute is not found normally, Python calls __getattr__(self, name) to try to return a value. __setattr__(self, name, value) is called every time an attribute is set. Example: class MyClass: def __getattr__(self, name): return f"No attribute named {name}!" def __setattr__(self, name, value): print(f"Setting {name} to {value}") super().__setattr__(name, value) obj = MyClass() print(obj.foo) # Calls __getattr__ obj.bar = 10 # Calls __setattr__

Result

No attribute named foo! Setting bar to 10

Understanding these hooks reveals how Python handles attribute access behind the scenes and enables powerful dynamic behaviors.

Under the Hood

When you access obj.attr, Python first looks in the object's __dict__ for 'attr'. If found, it returns the value. If not, it checks the class and its parents for descriptors or __getattr__ methods. When setting obj.attr = value, Python calls __setattr__ if defined; otherwise, it stores the value in __dict__. Properties use descriptors to run code on access or assignment.

Why designed this way?

This design balances simplicity and flexibility. Direct dictionary lookup is fast for normal attributes. Special methods like __getattr__ allow dynamic behavior without slowing down common cases. Properties provide controlled access without changing syntax, keeping code clean and readable.

Attribute Access Flow

obj.attr
  │
  ▼
Check obj.__dict__ for 'attr'
  │
  ├─ Found? → Return value
  │
  └─ Not found → Check class for descriptor or __getattr__
        │
        ├─ Descriptor? → Call descriptor method
        │
        └─ __getattr__? → Call __getattr__(name)
        │
        └─ Else → AttributeError

Attribute Setting Flow

obj.attr = value
  │
  ▼
Call obj.__setattr__('attr', value) if defined
  │
  └─ Else → Store in obj.__dict__['attr'] = value

Myth Busters - 4 Common Misconceptions

Quick: Does modifying an attribute on one object change it on all objects of the same class? Commit to yes or no.

Common Belief: Changing an attribute on one object changes it for all objects of that class.

Reality: Instance attributes belong to each object separately; changing one object's attribute does not affect others. Class attributes are shared, but instance attributes override them.

Why it matters: Confusing instance and class attributes leads to bugs where changes unexpectedly affect multiple objects or don't apply as intended.

Quick: Is it safe to access any attribute directly without checking if it exists? Commit to yes or no.

Common Belief: You can always access any attribute directly without errors.

Reality: Accessing a missing attribute raises AttributeError unless handled by __getattr__ or hasattr checks.

Why it matters: Assuming attributes always exist causes runtime crashes and unstable programs.

Quick: Does using properties always store data inside the property method? Commit to yes or no.

Common Belief: Properties store their own data inside the property method itself.

Reality: Properties usually control access to separate private attributes; they don't store data themselves.

Why it matters: Misunderstanding this leads to infinite recursion bugs when property methods try to access themselves.

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

Common Belief: __getattr__ is called every time an attribute is accessed.

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

Why it matters: Expecting __getattr__ to run always can cause confusion and incorrect assumptions about attribute behavior.

Expert Zone

1

Setting attributes via __setattr__ must call super().__setattr__ to avoid infinite recursion, a subtle trap for many.

2

Properties can be combined with descriptors to create reusable attribute management patterns beyond simple getters and setters.

3

Dynamic attribute access via __getattr__ and __setattr__ can impact performance and debugging, so use them judiciously.

When NOT to use

Avoid modifying attributes directly when you need validation or side effects; use properties or methods instead. For immutable objects, prefer using methods that return new objects rather than changing attributes. When working with many attributes, consider using __slots__ to save memory instead of dynamic attributes.

Production Patterns

In real systems, attributes are often accessed via properties to enforce validation and logging. Dynamic attribute access supports frameworks like ORMs that map database fields to object attributes. Custom __getattr__ implementations enable proxy objects and lazy loading patterns.

Connections

Encapsulation in Object-Oriented Programming

Accessing and modifying attributes is a core part of encapsulation, controlling how object data is exposed and changed.

Understanding attribute access helps grasp how encapsulation protects object state and enforces rules.

Reflection and Introspection

Using getattr, setattr, and __getattr__ relates to reflection, where programs examine and modify their own structure at runtime.

Knowing attribute access methods deepens understanding of how Python supports dynamic and flexible code.

Human Memory and Object Properties

Just like humans remember facts about objects (like a car's color), objects store attributes to remember their state.

This connection shows how programming models real-world knowledge storage, making code intuitive.

Common Pitfalls

#1 Trying to access an attribute that does not exist without checking.

Wrong approach:

print(my_dog.owner) # AttributeError if 'owner' not set

Correct approach:

print(getattr(my_dog, 'owner', 'No owner')) # Safely returns default

Root cause:

Assuming all attributes exist leads to runtime errors; getattr with default avoids this.

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

Wrong approach:

def __setattr__(self, name, value):
self.__dict__[name] = value # Wrong, can cause issues

# Or

def __setattr__(self, name, value):
self.name = value # Calls __setattr__ again, infinite loop

Correct approach:

def __setattr__(self, name, value):
super().__setattr__(name, value) # Correct way

Root cause:

Not delegating to the parent method traps the call in a loop.

#3 Using property methods that access the same property inside themselves causing recursion.

Wrong approach:

@property
def name(self):
return self.name # Calls itself endlessly

Correct approach:

@property
def name(self):
return self._name # Accesses private attribute

Root cause:

Confusing the property method with the underlying data causes infinite calls.

Key Takeaways

Attributes are the named data stored inside objects that define their state and behavior.

You access and modify attributes using dot notation or built-in functions like getattr and setattr for dynamic control.

Properties and special methods like __getattr__ and __setattr__ let you customize how attributes behave and are accessed.

Understanding the difference between instance and class attributes prevents common bugs in object state management.

Careful use of attribute access controls enables flexible, safe, and maintainable object-oriented code.