Of course! The term you're looking for in Python is setattr().

It's a built-in function that allows you to set an attribute on an object dynamically, using a string for the attribute's name.

What is setattr()?

In Python, almost everything is an object, and objects can have attributes. Attributes are variables associated with an object. You can normally access and set them using dot notation (e.g., my_object.my_attribute = 10).

The setattr() function provides a dynamic alternative to this. It's extremely useful when you don't know the attribute name at the time you're writing your code.

The Syntax

setattr(object, name, value)

• object: The object on which you want to set the attribute.
• name: A string representing the name of the attribute.
• value: The value you want to assign to the attribute.

The function returns None, but it modifies the object in place.

Examples

Let's see how it works in different scenarios.

Example 1: Basic Usage on a Custom Class

This is the most common use case. Imagine you have a class and you want to set an attribute based on user input or configuration.

class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model
        print(f"Car created: {self.make} {self.model}")
# Create an instance of the Car class
my_car = Car("Toyota", "Corolla")
# --- Using dot notation (the standard way) ---
my_car.year = 2025
my_car.color = "blue"
print(f"Standard attribute setting: {my_car.color}")
# --- Using setattr() ---
# Let's say we get the attribute name and value from somewhere else
attribute_name = "mileage"
attribute_value = 15000
setattr(my_car, attribute_name, attribute_value)
# Now, the 'mileage' attribute exists on my_car
print(f"Dynamic attribute setting: {my_car.mileage}")
# You can even use it to overwrite existing attributes
setattr(my_car, "year", 2025)
print(f"Overwritten year: {my_car.year}")

Output:

Car created: Toyota Corolla
Standard attribute setting: blue
Dynamic attribute setting: 15000
Overwritten year: 2025

Example 2: Setting Attributes on Built-in Objects

You can also use setattr() on built-in types like lists or dictionaries, although it's less common.

my_list = [1, 2, 3]
# Let's add a custom attribute to our list object
setattr(my_list, "description", "This is my list of numbers")
print(my_list.description)
# Output: This is my list of numbers
# You can also set attributes on dictionaries
my_dict = {"name": "Alice"}
setattr(my_dict, "status", "active")
print(my_dict.status)
# Output: active

Example 3: Practical Use Case - Configuration Files

Imagine you have a configuration file or a dictionary with settings, and you want to apply them to an object.

class ServerConfig:
    def __init__(self):
        self.host = "localhost"
        self.port = 8080
        self.debug = False
    def __str__(self):
        return f"Config(host='{self.host}', port={self.port}, debug={self.debug})"
# Our configuration is stored in a dictionary (e.g., from a JSON file)
config_from_file = {
    "host": "api.production.com",
    "port": 443,
    "debug": True
}
# Create a default config object
server_config = ServerConfig()
print(f"Before applying config: {server_config}")
# Dynamically apply all settings from the dictionary
for key, value in config_from_file.items():
    setattr(server_config, key, value)
print(f"After applying config:  {server_config}")

Output:

Before applying config: Config(host='localhost', port=8080, debug=False)
After applying config:  Config(host='api.production.com', port=443, debug=True)

The Opposite: getattr()

setattr() has a counterpart called getattr(), which retrieves an attribute dynamically using its name as a string.

class User:
    def __init__(self, username):
        self.username = username
user = User("john_doe")
# Get the 'username' attribute using dot notation
print(user.username)
# Output: john_doe
# Get the 'username' attribute using getattr()
print(getattr(user, "username"))
# Output: john_doe
# --- A key feature of getattr() ---
# If the attribute doesn't exist, you can provide a default value
# This prevents an AttributeError from being raised.
# This will cause an error:
# print(user.email)
# This will not cause an error:
print(getattr(user, "email", "Not provided"))
# Output: Not provided

Comparison: setattr() vs. Dot Notation

Summary

Use setattr() when:

• The attribute name is stored in a variable.
• You are working with dynamic data, like configurations from files or user input.
• You are writing code that needs to be generic and work with different attributes (e.g., in a plugin or framework).

For all other cases, standard dot notation (my_object.my_attribute = value) is preferred for its clarity and simplicity.