Python getattr() Function

Spread the love

The getattr() function provides a dynamic way to retrieve the value of an attribute from an object. Instead of statically accessing attributes using the dot notation, you can use getattr() to fetch attributes programmatically.


The syntax for getattr() is as follows:

getattr(object, name[, default])


  • object: The object whose attribute value is to be retrieved.
  • name: A string that specifies the attribute’s name.
  • default (optional): If provided, returns this default value if the named attribute is not found. If this is omitted and the attribute is not found, an AttributeError is raised.

Return Value:

getattr() function returns:

  • value of the named attribute of the given object
  • default, if no named attribute is found
  • AttributeError exception, if named attribute is not found and default is not defined.


Basic Usage of getattr( )

At its core, getattr() is designed to retrieve the value of a named attribute from an object, given the attribute’s name in string format. This dynamic approach to attribute access is different from the traditional dot notation we typically use in Python.

Conceptual Overview

Consider the following scenario: you have a variable holding the name of an attribute, and you want to fetch the value of this attribute from a specific object. Instead of using conditional statements or other cumbersome methods, you can use getattr() to achieve this in a concise manner.

Example with a Simple Class

Let’s break down an example using a basic class:

class Sample:
    x = 10
    y = 20

Here, we have a simple class Sample with two class attributes: x and y.

The traditional way to access the attribute x would be:

obj = Sample()
print(obj.x)  # Outputs: 10

However, let’s say the attribute name is stored in a variable, and you want to retrieve the attribute’s value using this variable:

attribute_name = "x"

Using getattr(), you can dynamically access the attribute:

value = getattr(obj, attribute_name)
print(value)  # Outputs: 10

In the above code, getattr(obj, attribute_name) is effectively equivalent to obj.x.

Dynamism in Action

The true power of getattr() becomes evident when dealing with situations where the attribute name is determined at runtime. For instance, consider user input determining which attribute to fetch:

attribute_name = input("Which attribute do you want to fetch (x/y)? ")
value = getattr(obj, attribute_name)

Here, the user can input either “x” or “y”, and the program will print the corresponding value from the Sample object.

Handling Absent Attributes

In the basic usage of getattr(), if you attempt to retrieve an attribute that doesn’t exist, Python raises an AttributeError. For example:

# This will raise an error since 'z' is not an attribute of the Sample class
value = getattr(obj, 'z')

This behavior is crucial to note, especially when using getattr() in scenarios where the attribute name is not known beforehand. In more advanced usages, as we’ll explore later, the getattr() function provides mechanisms to handle such cases gracefully.

The basic usage of getattr() offers a dynamic way to access object attributes in Python. While it might seem redundant given the more familiar dot notation, getattr() shines in scenarios where attribute names are determined programmatically or at runtime.

Using the default Parameter in getattr( )

The getattr() function is primarily designed to fetch an attribute’s value from an object based on the attribute’s name given as a string. But what happens if the specified attribute doesn’t exist on the object? By default, Python will raise an AttributeError. However, getattr() provides a third optional parameter called default to handle such cases gracefully.

Purpose of the default Parameter

The primary purpose of the default parameter is to provide a fallback value that getattr() should return if the specified attribute is not found in the given object. This way, instead of raising an error, the function will return the specified default value, enabling smoother program execution in dynamic scenarios.

Example with a Simple Class

Consider the previously mentioned class Sample:

class Sample:
    x = 10
    y = 20

Let’s try to fetch an attribute that doesn’t exist in this class:

obj = Sample()
# Without using the default parameter
# This will raise an AttributeError since 'z' is not an attribute of the Sample class
value = getattr(obj, 'z')

To handle this gracefully, we can provide a default value:

value = getattr(obj, 'z', 'Attribute not found')
print(value)  # Outputs: Attribute not found

Here, since the attribute z doesn’t exist in the Sample object, getattr() returns the string ‘Attribute not found’ instead of raising an error.

Practical Use Cases of the default Parameter

Dynamic Attribute Fetching: When dealing with user inputs or other unpredictable scenarios, you can’t always guarantee that the requested attribute exists. Using the default parameter allows your code to handle such uncertainties without crashing.

attribute_name = input("Enter the attribute name: ")
value = getattr(obj, attribute_name, None)
if value is not None:
    print("Attribute does not exist.")

Configuration Defaults: If you’re using objects to store configuration settings, you can use getattr() with a default value to fetch configuration values, providing defaults for settings that might not be set.

class Config:
    DATABASE_HOST = 'localhost'

config = Config()
# If DATABASE_PORT isn't set, default to 5432
database_port = getattr(config, 'DATABASE_PORT', 5432)

Adapting to Changing Codebases: If you’re working with libraries or codebases that may evolve over time (e.g., attributes might be renamed or removed), using getattr() with a default can provide backward compatibility or at least prevent sudden crashes.

Advanced Usage:

Combining getattr( ), setattr( ), and hasattr( )

These three built-in functions in Python – getattr(), setattr(), and hasattr() – provide dynamic tools for working with object attributes. While getattr() is designed for fetching attribute values, setattr() is for setting attribute values, and hasattr() is for checking the existence of an attribute. When combined, these functions provide a powerful toolkit for dynamic attribute management in Python.

Let’s use a simple class to illustrate their combined usage:

class Person:
    def __init__(self, name): = name

Imagine you want to dynamically set an attribute if it exists and, if not, retrieve a default value:

p = Person("Alice")

attribute_name = "age"
new_value = 25
default_value = 20

if hasattr(p, attribute_name):
    setattr(p, attribute_name, new_value)
    value = getattr(p, attribute_name, default_value)
    print(value)  # Outputs: 20

In the above example:

  • We first check if the attribute age exists using hasattr().
  • If it exists, we set it to a new value (new_value) using setattr().
  • If it doesn’t exist, we retrieve a default value (default_value) using getattr().

Fetching Deeply Nested Attributes

What are Deeply Nested Attributes?

In Python, objects can contain other objects as attributes, and this can lead to a structure where attributes are nested within attributes. These multi-level, nested structures are common in data models like JSON, XML, and hierarchical databases.

Consider a complex data structure like:

class Address:
    def __init__(self, city, street): = city
        self.street = street

class User:
    def __init__(self, name, address): = name
        self.address = address

address = Address("New York", "Broadway")
user = User("Alice", address)

Here, to get the city of the user, we’d typically use:

Using getattr( ) for Nested Attributes

For direct attributes, getattr(obj, 'attribute') is straightforward. But for nested attributes, naive application of getattr() can be cumbersome:

city = getattr(getattr(user, 'address'), 'city')

This works but isn’t very elegant, and it becomes unwieldy for deeper nestings.

A Recursive Approach to Fetching Nested Attributes

To deal with this in a cleaner fashion, a recursive approach can be employed:

def deep_getattr(obj, attr_path, default=None):
    attrs = attr_path.split('.')
    for attr in attrs:
        if hasattr(obj, attr):
            obj = getattr(obj, attr)
            return default
    return obj

city = deep_getattr(user, '', 'Unknown')

With this function, nested attributes can be fetched using dot-separated strings, which is far more manageable for deep structures.


In Python, the ability to treat everything as an object and manipulate attributes dynamically offers a great deal of flexibility. The getattr() function is an embodiment of this dynamic nature, allowing for attribute access based on runtime determinations. Whether you’re building a simple script or a complex framework, understanding and effectively utilizing getattr() can be a valuable asset in your Python programming toolkit.

Leave a Reply