Learn What Attributes Are in Python: Absolute Beginners Tutorial

Every object in Python carries data around with it. Attributes are how that data gets stored and named — and once you understand them, the way Python classes and objects work starts to make a lot more sense.

When Python creates an object, it needs somewhere to store that object's data. A Dog object needs to remember its name and breed. A BankAccount object needs to track its balance. That stored data lives in attributes. This tutorial walks through what attributes are, how Python looks them up, and what tools are available for working with them directly.

What Is an Attribute?

An attribute is a named value that belongs to an object. You access it using a dot between the object and the attribute name. If dog is an object and it has a name attribute, you write dog.name to read it.

That dot is doing real work. Python looks up the name on the right side of the dot by searching the object's internal data store. For most objects, that store is a dictionary called __dict__, which holds every attribute as a key-value pair.

class Dog:
    def __init__(self, name, breed):
        self.name = name    # instance attribute
        self.breed = breed  # instance attribute

rex = Dog("Rex", "German Shepherd")

print(rex.name)    # Rex
print(rex.breed)   # German Shepherd
print(rex.__dict__) # {'name': 'Rex', 'breed': 'German Shepherd'}

The two assignments inside __init__ — self.name = name and self.breed = breed — are what create the attributes. The keyword self refers to the object being created, so you are saying "store this value on this particular object."

Instance Attributes vs. Class Attributes

Not all attributes belong to individual objects. Some attributes are defined at the class level and shared across every instance. This distinction matters because it changes where the value lives and how Python finds it.

An instance attribute is defined inside a method — usually __init__ — using self. It is stored in the object's own __dict__. Each object gets its own copy, so changing one object's attribute does not affect any other object.

A class attribute is defined directly in the class body, outside any method. It is stored on the class itself, not on individual instances. Every instance can read it, but there is only one copy of the value unless an instance overrides it.

class Dog:
    species = "Canis lupus familiaris"  # class attribute

    def __init__(self, name):
        self.name = name  # instance attribute

rex = Dog("Rex")
fido = Dog("Fido")

print(rex.species)   # Canis lupus familiaris
print(fido.species)  # Canis lupus familiaris  (same value, shared)
print(rex.name)      # Rex
print(fido.name)     # Fido  (each instance has its own)

When Python evaluates rex.species, it first checks rex.__dict__. The attribute is not there, so Python moves up to the class and finds it there. This lookup chain — instance first, then class, then parent classes — is how attribute resolution works in Python.

The Built-In Attribute Functions

Python provides four built-in functions for working with attributes by name as a string. These become useful when the attribute name is not known until the program is running — for example, when reading configuration files or processing data dynamically.

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

rex = Dog("Rex", "German Shepherd")

# hasattr — check if an attribute exists
print(hasattr(rex, "name"))   # True
print(hasattr(rex, "color"))  # False

# getattr — read an attribute by name string
print(getattr(rex, "name"))              # Rex
print(getattr(rex, "color", "unknown"))  # unknown (default returned)

# setattr — assign an attribute by name string
setattr(rex, "color", "black")
print(rex.color)  # black

# delattr — remove an attribute
delattr(rex, "color")
print(hasattr(rex, "color"))  # False

"Objects are Python's abstraction for data." — Python Language Reference

The optional third argument to getattr is especially practical. Without it, reading a missing attribute raises an AttributeError. Providing a default means your code can continue gracefully when an attribute may or may not be present, without needing a separate hasattr check first.

Python Learning Summary Points

1. An attribute is a named value stored on an object, accessed using dot notation. Python stores most instance attributes in a dictionary called __dict__ that you can inspect at any time.
2. Instance attributes are defined inside methods with self and belong to individual objects. Class attributes are defined in the class body and are shared by all instances, though any instance can shadow them with its own value of the same name.
3. The four built-in attribute functions — hasattr, getattr, setattr, and delattr — let you work with attributes using string names, which is essential for dynamic or configurable code.

Attributes are central to how Python's object model works. Everything you do with classes — storing state, building methods, inheriting behavior — depends on this foundation. Spend time reading __dict__ output while experimenting; seeing the data directly reinforces the concepts faster than diagrams alone.