Skip to main content

How to Dynamically Access Object Attributes in Python

How to Dynamically Access Object Attributes in Python | Rustcode

How to Dynamically Access Object Attributes in Python

Sometimes you need to access object attributes in Python without knowing their names ahead of time—especially when building flexible tools or working with user input. Python delivers powerful built-in tools for this: getattr(), hasattr(), and more. This guide explains dynamic attribute access, presents practical examples, highlights best practices, and covers common pitfalls.

Table of Content

Why Dynamic Attribute Access?

  • Flexible code: Access attributes by name stored in variables, config files, or user input.
  • Metaprogramming: Write generic functions/classes that adapt based on object structure.
  • Introspection: Explore objects programmatically (e.g., for serialization or debugging).

The Main Method: getattr()

getattr(object, name[, default]) is the built-in, Pythonic way to access an attribute when its name is a string (not a fixed identifier). 

class Car:
    color = 'red'
    year = 2021

car = Car()

attr_name = 'color'
print(getattr(car, attr_name))       # Output: red

print(getattr(car, 'year'))          # Output: 2021

print(getattr(car, 'brand', 'N/A'))  # Output: N/A (uses default since 'brand' not present)
  • getattr(car, 'color') fetches the attribute color from car.
  • If the attribute doesn't exist and you provide a default, that value is returned instead of raising an error.
Note: getattr() is not limited to attributes—it can retrieve methods as well, letting you call them dynamically.

Code Examples

Example 01: Accessing a dynamic attribute


# 1. Accessing a dynamic attribute
class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade

stu = Student('Ali', 95)
attr = 'grade'
print(getattr(stu, attr))      # Output: 95

Output:

95

Example 02: Calling a method dynamically


# 2. Calling a method dynamically
class Calculator:
    def add(self, a, b): return a + b
    def mul(self, a, b): return a * b

calc = Calculator()
operation = getattr(calc, 'mul')
result = operation(3, 7)
print(result)                  # Output: 21

Output:

21

Example 03: Dynamic attribute with default


# 3. Dynamic attribute with default
print(getattr(stu, 'age', 'Unknown'))  # Output: Unknown

Output:

Unknown

Other Dynamic Attribute Functions

  • hasattr(object, name): Checks if object has an attribute called name (string).
    hasattr(car, 'color') # True
  • setattr(object, name, value): Dynamically sets (creates or updates) an attribute.
    setattr(stu, 'age', 20)
  • delattr(object, name): Deletes an attribute by name (raises an error if missing).
    delattr(stu, 'grade')
Explanation:
  • getattr, hasattr, setattr, and delattr together provide a complete toolbox for runtime introspection and manipulation of Python objects.
  • Attributes added with setattr() are immediately available to the object and can also be accessed via dot notation (stu.age) or getattr() later.

Method Comparison Table

Function Purpose Return Value Raises Error? Code Example
getattr() Access attribute by name Attribute value / default Yes (if not found and no default) getattr(obj, name, default)
hasattr() Check if attribute exists True / False No hasattr(obj, name)
setattr() Set (add/update) attribute None Yes (invalid name) setattr(obj, name, value)
delattr() Delete attribute None Yes (if not present) delattr(obj, name)

Useful Tips

  • Always pass the attribute name as a string (getattr(obj, 'attr')), not as an identifier.
  • If using setattr() or delattr(), be careful of overwriting or deleting important attributes.
  • Use hasattr() before getattr() if you’re unsure whether the attribute exists and want to avoid errors.
  • For objects that override __getattr__ or __getattribute__, these functions may follow custom rules.
  • Dynamic access works with instance and class attributes, and can also retrieve methods for immediate calling.

Conclusion

Dynamically accessing object attributes in Python is straightforward and robust with getattr(), hasattr(), setattr(), and delattr(). These functions are cornerstones for metaprogramming, flexible APIs, plugins, and configuration-driven frameworks. Lean on them when attribute names aren’t known until runtime—and write cleaner, safer, and more reusable code.

Comments

Post a Comment