Check Whether an Object Has an Attribute in Python

Quick answer: Use hasattr for a simple optional-capability check or getattr with a unique sentinel when None is a valid attribute value. For required fields, direct access is often clearer. Be careful with properties because attribute access can execute code and may raise an AttributeError for reasons other than absence.

To check whether a Python object has an attribute, use hasattr(object, "name"). It returns True when the attribute can be read and False when it is missing.

For many real programs, getattr() with a default value is even more useful because it checks and reads the attribute in one step. The official hasattr documentation and getattr documentation define the built-ins, and the attribute access data model explains custom lookup behavior.

Use hasattr For A Boolean Check

hasattr() is the simplest way to ask whether an attribute exists.

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

user = User("Ada")

print(hasattr(user, "name"))
print(hasattr(user, "email"))

The first check returns True, and the second returns False. This is useful when optional object data may or may not be present.

Use hasattr() when you only need a yes-or-no answer.

Use getattr With A Default

If you need the attribute value, use getattr() with a default. This avoids a separate check followed by another lookup.

class User:
    name = "Grace"

user = User()

email = getattr(user, "email", "[email protected]")
name = getattr(user, "name", "unknown")

print(name)
print(email)

The default is returned only when the attribute is missing. Existing attributes keep their real value.

This pattern is clean for optional settings, plugin objects, configuration objects, and API response wrappers.

Use A Sentinel For Missing Values

Sometimes None is a valid attribute value. In that case, use a unique sentinel object as the default.

missing = object()

class Item:
    price = None

item = Item()
price = getattr(item, "price", missing)

if price is missing:
    print("price attribute is missing")
else:
    print("price exists:", price)

This distinguishes a missing attribute from an attribute that exists and is set to None.

Sentinels are useful in validation code where missing and empty values mean different things.

Catch AttributeError When Access Has Side Effects

Some objects compute attributes dynamically. A property can raise AttributeError while being read.

class Report:
    @property
    def title(self):
        raise AttributeError("title is not ready")

report = Report()

try:
    print(report.title)
except AttributeError:
    print("title unavailable")

Use a try block when reading the attribute is the operation you care about. This is clearer than checking first and reading later.

For simple data objects, getattr() with a default is usually enough.

Inspect Instance Attributes With vars

vars() returns the instance attribute dictionary for many normal Python objects.

class Settings:
    def __init__(self):
        self.theme = "dark"
        self.debug = False

settings = Settings()

print("theme" in vars(settings))
print(vars(settings))

This checks attributes stored directly on the instance. It does not include every property, method, or descriptor available through normal attribute lookup.

Use vars() when you specifically need stored instance data, not inherited or dynamic attributes.

Check Before Calling Optional Methods

For optional methods, check that the attribute exists and is callable before calling it.

class Plugin:
    def run(self):
        return "done"

plugin = Plugin()
method = getattr(plugin, "run", None)

if callable(method):
    print(method())

This avoids calling a missing attribute or a non-callable attribute by mistake.

It is useful for plugin hooks, optional callbacks, and objects from third-party libraries.

hasattr Versus getattr

Use hasattr() when the answer itself is all you need. Use getattr() when you need the value. Use a sentinel when the default value could be confused with a real value.

Be aware that hasattr() works by attempting to read the attribute and catching AttributeError. If attribute access performs work, a direct try block may be easier to reason about.

Dynamic Attributes And Descriptors

Normal instance attributes are not the only attributes Python can expose. Classes can define properties, descriptors, __getattr__(), or __getattribute__(). These hooks can calculate a value only when it is requested.

That means an attribute check is not always a cheap dictionary lookup. In most application classes this does not matter, but for objects from ORMs, network clients, plugin frameworks, or lazy loaders, reading an attribute can trigger extra work.

If a property may raise an error for reasons other than absence, handle that error close to the read. A broad hasattr() check can hide the detail that the object exists but could not produce a usable value.

Design Clear Attribute Checks

Prefer checking for behavior over checking for one specific class when you support flexible objects. For example, checking whether an object has a callable run method can be more flexible than requiring every plugin to inherit from the same base class.

Use clear attribute names. Dynamic access through strings is powerful, but it is also easier to mistype than direct attribute access. If many parts of the code use the same attribute name, keep that name in one well-tested helper.

Do not use attribute checks as a substitute for validation. After confirming that an attribute exists, still confirm that its value has the shape your code expects.

The practical default is to use getattr(obj, name, default) for optional values and hasattr() for quick capability checks. After checking whether an attribute exists, Python getattr Function Examples retrieves it with defaults and explains dynamic access without masking real errors.

Use hasattr For Optional Features

hasattr is convenient when code supports several object types and only needs to know whether a capability is present. Check the returned attribute before assuming it has the expected type.

class Report:
    export = True

report = Report()
if hasattr(report, "export"):
    print(getattr(report, "export"))

Distinguish Missing From None

getattr with a sentinel distinguishes an absent attribute from an existing attribute whose value is None. Compare the sentinel with is.

missing = object()

class Config:
    value = None

config = Config()
value = getattr(config, "value", missing)
print(value is missing, value is None)

Check Callability

An attribute can exist but not be callable. Read it, validate the callable contract, and call only after that boundary check.

class Plugin:
    def run(self):
        return "done"

operation = getattr(Plugin(), "run", None)
if not callable(operation):
    raise TypeError("run is not callable")
print(operation())

Prefer Explicit Contracts

hasattr should not replace a documented interface. For required attributes, direct access provides a useful failure and lets type checkers understand the code.

class User:
    name = "Ada"

user = User()
print(user.name)

Python’s hasattr() and getattr() references define dynamic lookup. Related references include getattr patterns, sentinels, and contract tests.

For related object contracts, compare getattr, sentinel values, and contract tests when checking optional attributes.

Frequently Asked Questions

How do I check if an object has an attribute?

Use hasattr for a simple presence check or getattr with a sentinel when the value itself may be None.

What is the problem with hasattr?

It can return False when attribute access raises AttributeError, including from a property, so it should not replace understanding the object contract.

How do I check whether an attribute is callable?

Read it with getattr and use callable on the returned value before invoking it.

Should I use hasattr for required attributes?

Direct access is often clearer for required fields because a missing attribute raises an actionable AttributeError.