Checking Object Attributes in Python: Safe Reflection with hasattr()

1. Syntax & Formal Parameter Specifications 🔝

The hasattr() function takes two arguments and evaluates to a boolean value:

has_attr = hasattr(object, name)

2. Basic Usage: Checking Instance & Class Attributes 🔝

You can check for instance attributes, class variables, and methods on any object:

class Animal:
    species = "carnivores"  # Class attribute

    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

tiger = Animal("Ronald", 5)

# Existing instance attribute
print("Has age:", hasattr(tiger, "age"))

# Existing class attribute
print("Has species:", hasattr(tiger, "species"))

# Missing attribute returns False cleanly
print("Has height:", hasattr(tiger, "height"))

Output:

Has age: True
Has species: True
Has height: False

3. Internal Mechanics: How hasattr() Works 🔝

Under the hood, CPython implements hasattr(obj, name) by calling getattr(obj, name) and checking for an exception:

# Conceptual implementation of hasattr() in Python
def custom_hasattr(obj, name: str) -> bool:
    try:
        getattr(obj, name)
        return True
    except AttributeError:
        return False

Because it internally invokes getattr(), any custom __getattr__ or __getattribute__ methods defined on the target class will execute normally during the check.

4. hasattr() vs. getattr(): EAFP vs. LBYL 🔝

In Python, choosing between hasattr() and getattr() with a default depends on whether you only need to verify existence or immediately consume the value:

class Config:
    timeout = 30

cfg = Config()

# Pattern 1: hasattr() check before branch
if hasattr(cfg, "timeout"):
    print("Timeout configured (hasattr):", cfg.timeout)

# Pattern 2: Single-step getattr() with default (more Pythonic)
timeout = getattr(cfg, "timeout", 60)
print("Effective timeout (getattr):", timeout)

Output:

Timeout configured (hasattr): 30
Effective timeout (getattr): 30

5. Inheritance, Bound Methods & Dunder Protocols 🔝

hasattr() inspects the object's entire inheritance hierarchy, including inherited methods, properties, and special dunder protocols:

class BaseDevice:
    def connect(self):
        return True

class SmartLight(BaseDevice):
    def turn_on(self):
        pass

light = SmartLight()

# Inherited method from BaseDevice
print("Has connect:", hasattr(light, "connect"))

# Checking callable method vs attribute
print("Is connect callable:", callable(getattr(light, "connect")))

# Checking built-in dunder protocols
print("Has __iter__ on list:", hasattr([1, 2], "__iter__"))
print("Has __iter__ on int:", hasattr(42, "__iter__"))

Output:

Has connect: True
Is connect callable: True
Has __iter__ on list: True
Has __iter__ on int: False

6. The @property Side-Effect & Masking Gotcha 🔝

Because hasattr() calls getattr(), inspecting a decorated @property actually executes the property getter code. If the getter throws an AttributeError internally, hasattr() will unexpectedly return False:

class Account:
    @property
    def balance(self):
        print(">>> Property getter executed!")
        return 1000

acc = Account()

# Checking hasattr triggers the getter!
print("Checking hasattr(acc, 'balance'):")
exists = hasattr(acc, "balance")
print("Result:", exists)

Output:

Checking hasattr(acc, 'balance'):
>>> Property getter executed!
Result: True

7. Production Recipes & Real-World Use Cases 🔝

Recipe A: Duck Typing & Protocol Verification

Check whether an arbitrary object conforms to a file-like stream protocol before reading or writing:

def safe_stream_reader(source) -> str:
    if hasattr(source, "read") and callable(source.read):
        return source.read()
    elif isinstance(source, str):
        return source
    else:
        raise TypeError("Object does not support stream reading")

import io
stream = io.StringIO("Sample stream buffer data")
print("Stream result:", safe_stream_reader(stream))
print("String result:", safe_stream_reader("Raw string text"))

Output:

Stream result: Sample stream buffer data
String result: Raw string text

Recipe B: Graceful Resource Cleanup

Safely close active connection handles without assuming a specific connection library:

def close_resource(resource):
    if hasattr(resource, "close") and callable(resource.close):
        resource.close()
        return "Resource closed cleanly"
    return "No close method available"

class SocketMock:
    def close(self):
        pass

print(close_resource(SocketMock()))
print(close_resource(123))

Output:

Resource closed cleanly
No close method available

8. Common Pitfalls & Developer Traps 🔝

tiger = Animal("Ronald", 5)

# Correct: pass string literal
print("Valid check:", hasattr(tiger, "age"))

# Wrong: passing non-string argument raises TypeError
try:
    hasattr(tiger, 123)
except TypeError as err:
    print("TypeError caught:", err)

Output:

Valid check: True
TypeError caught: hasattr(): attribute name must be string

9. Interactive Notebook & Practice Exercises 🔝

Practice dynamic attribute checks, duck typing protocols, and property inspection in our companion Jupyter Notebook:

Self-Verifying Assertion Suite

Run these unit checks directly in Python or your local environment to verify hasattr() mechanics:

def test_hasattr_mechanics():
    class Device:
        brand = "Acme"
        def __init__(self, sn: str):
            self.sn = sn
            
    dev = Device("SN-001")
    assert hasattr(dev, "sn") is True
    assert hasattr(dev, "brand") is True
    assert hasattr(dev, "firmware") is False
    
    # Dynamic addition reflection
    setattr(dev, "firmware", "v1.0")
    assert hasattr(dev, "firmware") is True
    
    print("All hasattr() unit assertions passed! 100% verified.")

test_hasattr_mechanics()

Output:

All hasattr() unit assertions passed! 100% verified.

10. Related Built-in Functions 🔝

Subhendu Mohapatra

Author & Instructor at plus2net

I write and maintain practical tutorials on Python, PHP, SQL, JavaScript, HTML, jQuery, and web development at plus2net. The tutorials focus on clear explanations, working examples, and code that readers can test and adapt while learning.

About the author   Watch on YouTube

Connect: