Skip to main content

How to Check if an Object Has an Attribute in Python

In a dynamically typed language like Python, it's common to work with objects whose attributes may vary. To write robust code that avoids AttributeError exceptions, you often need to check if an object has a specific attribute before attempting to access it. Python provides a simple built-in function, hasattr(), for this exact purpose.

This guide will demonstrate the recommended way to check for an attribute using hasattr() and will also cover two powerful, alternative patterns: using a try...except block and using getattr() with a default value.

Understanding Attributes in Python​

In Python, an attribute is a variable or a method that is associated with an object. For example, if you have a list my_list, its .append is a method attribute, and if you have a custom object my_car, its .brand could be a data attribute. Accessing an attribute that doesn't exist will raise an AttributeError.

The built-in hasattr(object, name) function is the most direct and readable way to check if an object has a given attribute. It takes two arguments: the object to check and the attribute's name as a string. It returns True if the attribute exists and False otherwise.

This approach is known as LBYL ("Look Before You Leap").

Solution:

class Car:
    def __init__(self):
        self.brand = 'Tesla'
        self.year = 2022

my_car = Car()

# Check for an attribute that exists
has_brand = hasattr(my_car, 'brand')
print(f"Does the car have a 'brand' attribute? {has_brand}")

# Check for an attribute that does NOT exist
has_wheels = hasattr(my_car, 'wheels')
print(f"Does the car have a 'wheels' attribute? {has_wheels}")

# Using hasattr() to control program flow
if hasattr(my_car, 'year'):
    print(f"The car's year is: {my_car.year}")
else:
    print("The car's year is unknown.")

Output:

Does the car have a 'brand' attribute? True
Does the car have a 'wheels' attribute? False
The car's year is: 2022

Method 2: Using try...except AttributeError (Pythonic Alternative)​

An alternative and often more Pythonic approach is to simply try to access the attribute and catch the AttributeError if it doesn't exist. This pattern is known as EAFP ("Easier to Ask for Forgiveness than Permission").

This method is particularly useful when you intend to use the attribute immediately after checking for its existence.

Solution:

class Car:
    def __init__(self):
        self.brand = 'Tesla'
        self.year = 2022

my_car = Car()

try:
    # Attempt to access and use the attribute directly
    print(f"Brand found: {my_car.brand}")
except AttributeError:
    print("The 'brand' attribute was not found.")


try:
    print(f"Wheels found: {my_car.wheels}")
except AttributeError:
    print("The 'wheels' attribute was not found.")

Output:

Brand found: Tesla
The 'wheels' attribute was not found.
note

When to choose EAFP vs. LBYL (hasattr):

  • Use hasattr() (LBYL) when it's common for the attribute to be missing and you need to handle that case frequently.
  • Use try/except (EAFP) when you expect the attribute to exist most of the time and its absence is an exceptional case.

Method 3: Using getattr() with a Default Value​

The built-in getattr(object, name, default) function is another powerful tool. It tries to get an attribute from an object. If the attribute doesn't exist, instead of raising an error, it returns the default value you provided.

This is extremely useful for retrieving an attribute and providing a fallback value in a single, concise line of code.

Solution:

class Car:
    def __init__(self):
        self.brand = 'Tesla'
        self.year = 2022

my_car = Car()

# Get the 'brand' attribute (it exists)
brand = getattr(my_car, 'brand', 'Unknown Brand')
print(f"The brand is: {brand}")

# Try to get the 'wheels' attribute (it does not exist)
# The default value '4' will be returned instead.
wheels = getattr(my_car, 'wheels', 4)
print(f"The number of wheels is: {wheels}")

Output:

The brand is: Tesla
The number of wheels is: 4

Conclusion​

Python provides several robust ways to check for the existence of an object's attribute. The best one to use depends on your specific goal:

  1. To simply check if an attribute exists (True/False): Use hasattr(object, 'name'). It is explicit and highly readable.
  2. To access an attribute that you expect to be present: Use a try...except AttributeError block. This is often more efficient if the attribute is usually present.
  3. To get an attribute's value and provide a fallback if it's missing: Use getattr(object, 'name', default_value). This is the most concise way to handle this common pattern.

By choosing the right tool for the job, you can write Python code that is both safe and expressive.

Table of Contents