How to Check if an Object Has an Attribute in Python

By the end of this page, you will understand how Python looks up attributes on objects, how to check for an attribute with hasattr(), how to safely read attributes with getattr(), and when checking first is useful versus when handling AttributeError directly is the better pattern.

In Python, an attribute is a value attached to an object, such as a variable or method.

Examples:

name = "Ada"
print(name.upper)   # method attribute

class User:
    def __init__(self):
        self.email = "user@example.com"

u = User()
print(u.email)      # data attribute

When you access an attribute like a.property, Python searches for it on the object and, if needed, on its class and parent classes. If Python cannot find that attribute, it raises an AttributeError.

The most direct built-in way to check whether an object has an attribute is:

hasattr(a, "property")

This returns True if the attribute exists and False otherwise.

Another useful built-in is:

getattr(a, , default_value)

Think of an object like a backpack with labeled pockets.

• An attribute is a pocket label like email, name, or save.
• Accessing obj.email means: “Open the pocket labeled email.”
• If that pocket does not exist, Python says: AttributeError.

You have three common ways to deal with this:

1. Check first with hasattr()
   • “Does this backpack have a pocket named email?”
2. Ask for it with a fallback using getattr()
   • “Give me the email pocket, or this default value if it is missing.”
3. Try and handle failure with try/except
   • “Open the pocket. If it is missing, I know what to do.”

The best choice depends on whether missing attributes are expected and how you want your code to behave.

Core syntax

hasattr(object, "attribute_name")

Returns True or False.

getattr(object, "attribute_name", default_value)

Returns the attribute value if it exists, otherwise returns default_value.

Example: checking before access

class SomeClass:
    pass

a = SomeClass()

if hasattr(a, "property"):
    print(a.property)
else:
    print("property does not exist")

This prevents AttributeError by checking first.

Example: using getattr() with a default

class :
    

a = SomeClass()
value = (a, , )
(value)

Consider this example:

class User:
    def __init__(self, name=None):
        if name is not None:
            self.name = name

user = User()

if hasattr(user, "name"):
    print(user.name)
else:
    print("No name found")

Step by step:

1. Python defines the User class.
2. user = User() creates a new User object.
3. Inside __init__, the argument name is None.
4. The condition if name is not None: is false.
5. So self.name = name is not executed.
6. The object user is created without a name attribute.

Optional configuration values

timeout = getattr(config, "timeout", 30)

If a config object does not define timeout, the program uses 30.

Framework or library objects

Different objects from a library may expose different attributes:

if hasattr(response, "json"):
    data = response.json()

Data processing

When processing objects from multiple sources, some fields may exist only sometimes:

if hasattr(record, "email"):
    send_email(record.email)

Plugins and extensibility

A plugin system may support optional hooks:

if hasattr(plugin, "before_save"):
    plugin.before_save(item)

Backward compatibility

Older and newer versions of a class may not have the same attributes:

In real Python codebases, developers use attribute checks in a few common ways.

1. Default values with getattr()

This is very common when an attribute is optional.

log_level = getattr(settings, "log_level", "INFO")

2. Guard clauses

A guard clause exits early if a required attribute is missing.

def print_email(user):
    if not hasattr(user, "email"):
        return
    print(user.email)

3. Optional hooks or methods

Large projects often support optional behavior.

def run_plugin(plugin):
    if hasattr(plugin, "setup"):
        plugin.setup()

4. Error handling with EAFP

Instead of checking first, many developers just try the access:

def ():
    :
         user.username
     AttributeError:
         

Mistake 1: Accessing the attribute right after checking, but on a changing object

Usually this is fine, but in more complex code the object may change between the check and the access.

if hasattr(obj, "value"):
    print(obj.value)

A safer pattern when you need a fallback is often:

value = getattr(obj, "value", None)
print(value)

Mistake 2: Confusing "attribute exists" with "attribute has a useful value"

An attribute can exist and still be None, False, or an empty string.

class User:
    email = None

u = User()
print(hasattr(u, "email"))  # True
print(u.email)               # None

If you care about content, check the value too.

email = getattr(u, "email", None)
 email:
    (email)

hasattr() vs getattr()

• Use when your logic depends on whether the attribute exists.

# Check if attribute exists
hasattr(obj, "name")

# Get attribute or default value
getattr(obj, "name", default_value)

# Handle missing attribute directly
try:
    value = obj.name
except AttributeError:
    value = default_value

Quick rules

• Attribute names passed to hasattr() and getattr() must be strings.
• hasattr() returns True or False.
• getattr() returns the actual value if found.
• If no default is given to getattr() and the attribute is missing, it raises AttributeError.
• Methods are also attributes.
• An attribute can exist even if its value is None.

Common patterns

if hasattr(user, "email"):
    send_email(user.email)

How do I check if an object has an attribute in Python?

Use:

hasattr(obj, "attribute_name")

It returns True if the attribute exists, otherwise False.

What is the difference between hasattr() and getattr()?

• hasattr() checks existence.
• getattr() retrieves the value and can return a default if missing.

Is hasattr() safe to use in Python?

Yes, for normal attribute checks. But if you actually need the value, getattr() or try/except AttributeError is often cleaner.

Can hasattr() check for methods too?

Yes. Methods are attributes in Python.

hasattr(str, "upper")

What happens if the attribute exists but is None?

• AttributeError — The exception Python raises when an attribute does not exist.
• getattr — Lets you read an attribute dynamically and provide a default value.
• setattr — Lets you create or update an attribute by name.
• delattr — Removes an attribute by name.
• Exceptions and try/except — Important for the EAFP style of handling missing attributes.
• Classes and objects — Attributes belong to objects and classes, so this is the foundation.
• Instance attributes vs class attributes — Helps explain where Python finds attributes.
• Dictionaries — Useful to compare object attributes with key-based data access.