Python delattr: Removing Object Attributes Cleanly
Python's delattr built-in: Learn how to delete object attributes, handle missing attributes, and avoid common pitfalls.

Python's delattr built-in removes an attribute from an object at runtime. It is useful when the attribute name is dynamic, such as when it comes from a variable or user input. Here is the basic syntax:
delattr(object, name)The object argument is the object whose attribute you want to remove, and name is a string containing the attribute's name. If the attribute does not exist, delattr raises AttributeError. Understanding that behavior matters before you use it in production code.
Basic Syntax and Behavior
delattr is a built-in function, so it is always available without importing anything. It performs the same deletion as the del statement when used on an attribute, but it accepts the attribute name as a string argument. This allows you to delete attributes dynamically when the name is not known at write time.
class Config:
def __init__(self):
self.debug = True
self.log_level = "INFO"
config = Config()
delattr(config, "debug")
print(hasattr(config, "debug")) # FalseAfter the call, the debug attribute is gone. Accessing it later raises an AttributeError. For normal classes, the attribute is removed from the instance's __dict__. If the class uses __slots__, the slot is cleared but the class-level descriptor remains.
Handling Missing Attributes
Calling delattr on an attribute that does not exist raises AttributeError. This is often the first failure developers encounter. The error message is straightforward:
class Example:
pass
example = Example()
# delattr(example, "missing") # AttributeError: missingTo avoid this, check whether the attribute exists first with hasattr or getattr with a sentinel default. A common pattern is:
if hasattr(obj, "temp_value"):
delattr(obj, "temp_value")Alternatively, you can catch the exception when the attribute's absence is acceptable:
try:
delattr(obj, "temp_value")
except AttributeError:
passThe try approach is slightly more robust in concurrent or dynamic contexts where the attribute might be removed by another part of the code between the check and the deletion.
Practical Use Cases for delattr
delattr is useful when you need to clean up temporary state on objects. For example, a caching layer can lazily store a computed value and invalidate it later:
class Report:
def __init__(self, data):
self.data = data
def compute_sum(self):
if not hasattr(self, "_cached_sum"):
self._cached_sum = sum(self.data)
return self._cached_sum
def invalidate_cache(self):
if hasattr(self, "_cached_sum"):
delattr(self, "_cached_sum")Another common scenario is removing attributes from objects that were populated dynamically, such as when parsing configuration files or handling user-supplied fields. delattr gives you a direct way to strip unwanted keys from an object's namespace without rebuilding the object.
delattr vs the del Statement
The del statement is the more familiar way to delete an attribute:
del obj.attributeThis works only when the attribute name is a literal identifier. If the name comes from a variable, you must use delattr:
attr_name = "debug"
delattr(obj, attr_name)For a fixed attribute name, del is usually clearer. Use delattr when the name is dynamic or passed as a parameter.
Runtime and Performance Considerations
Deleting an attribute has a small runtime cost because Python must look up the attribute in the instance's __dict__ or the class's slot descriptor. This cost is negligible in most applications, but it can matter in tight loops that repeatedly create and delete attributes. In such cases, consider whether you can reuse a sentinel value like None instead of deleting the attribute, which avoids the risk of AttributeError and can make the object's state easier to reason about.
After deletion, any code that reads the attribute will raise an exception, which is expensive if not handled properly. If your code frequently checks for the attribute's presence, hasattr is a straightforward way to do so, but repeated deletion and re-creation can cause avoidable churn in the instance dictionary. For long-lived objects, prefer setting the attribute to a neutral value unless you specifically need to remove it for serialization or reflection purposes.
Maintainability and Edge Cases
delattr interacts with class-level features in ways that can surprise developers. If a class uses __slots__, deleting an instance attribute clears the slot, but the class-level descriptor remains. A later read of that attribute raises AttributeError while the slot is empty. This is different from deleting a normal instance dictionary key, so test against the exact class structure.
Properties also complicate deletion. If a class defines a property without a deleter method, delattr raises AttributeError even if the underlying attribute exists. For example:
class Temperature:
@property
def celsius(self):
return self._celsius
@celsius.setter
def celsius(self, value):
self._celsius = value
t = Temperature()
t.celsius = 25
# delattr(t, "celsius") # AttributeError: can't delete attributeTo support deletion, you must add a @celsius.deleter method. This is a common source of bugs when developers assume delattr bypasses property logic.
When Not to Use delattr
delattr is not always the right tool. If you need to keep the attribute name but clear its value, assigning None is usually clearer and avoids the overhead of exception handling. Deleting an attribute can also break code that relies on the attribute's existence through hasattr checks or that uses the attribute as part of a data contract. For example, if an object is passed to a function that expects a certain attribute, deleting it will cause that function to fail.
Another case is when you need to delete an attribute from a class rather than an instance. delattr works on classes too, but deleting a class attribute affects all instances. This is rarely what you want unless you are deliberately modifying the class definition at runtime. In such cases, consider whether a class-level del is more explicit.
Finally, if you are working with objects that implement custom __delattr__ methods, remember that delattr calls that method. This can be used for validation or side effects, but it also means the behavior is not guaranteed to be the simple removal you might expect. Always check whether the object's class overrides __delattr__ before assuming the attribute is silently removed.
In summary, delattr is a precise, dynamic way to remove attributes from objects. Use it when the attribute name is not a literal, when you need to clean up temporary state, or when you are building generic utilities that manipulate object fields. For fixed names, prefer the del statement for readability. And always handle the AttributeError that arises when the attribute is missing or when a property blocks deletion.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.