Learn What Instances Are in Python: Absolute Beginners Tutorial

Every object you work with in Python — a string, a list, a custom dog or bank account — is an instance. Understanding what that means is the key to understanding how Python thinks about data and behavior.

Python is an object-oriented language, which means it organizes data and logic into objects. An instance is simply one of those objects — a single, concrete thing that was created from a class. When you write my_list = [], Python creates an instance of the built-in list class and assigns it to my_list. When you define your own class and call it, you get back an instance of that class. This tutorial explains what instances are, how they are created, how they store data, and how to interact with them.

What Is an Instance?

A class is a blueprint. An instance is the actual object built from that blueprint. Think of a class as a cookie cutter and each instance as one of the cookies it stamps out. Every cookie has the same shape — defined by the cutter — but each one is a separate, physical object you can decorate differently.

In Python, when you call a class, you are telling Python to build a new object that follows that class's blueprint. The object that comes back is an instance. Here is the simplest possible example:

class Dog:
    pass

rex = Dog()   # rex is now an instance of Dog
luna = Dog()  # luna is a separate instance of Dog

print(rex)    # <__main__.Dog object at 0x...>
print(luna)   # <__main__.Dog object at 0x...> — different address

rex and luna are two distinct objects. Even though both came from the same Dog class, they live at different memory addresses and are completely independent of each other. Changing one does not affect the other.

You can verify that an object is an instance of a particular class using isinstance():

print(isinstance(rex, Dog))   # True
print(isinstance(luna, Dog))  # True
print(isinstance(rex, list))  # False

Everything in Python — integers, strings, lists, functions — is an instance of some class. When you type "hello", Python creates an instance of the built-in str class. When you type [1, 2, 3], Python creates an instance of list. Custom classes work exactly the same way.

Classes and Instances Working Together

A class with pass is not very useful. In practice, classes define an __init__ method that runs automatically every time a new instance is created. Inside __init__, you attach data to the instance using self.

self is simply a reference to the instance that is being created right now. When Python calls __init__, it automatically passes the new instance as the first argument. By convention, everyone names that parameter self, though Python itself does not care what you call it.

class Dog:
    def __init__(self, name, age):
        self.name = name   # attach name to this instance
        self.age = age     # attach age to this instance

rex = Dog("Rex", 4)
luna = Dog("Luna", 2)

print(rex.name)   # Rex
print(luna.name)  # Luna
print(rex.age)    # 4

When you call Dog("Rex", 4), Python creates a blank instance, then calls __init__ with that instance as self, "Rex" as name, and 4 as age. The two lines self.name = name and self.age = age attach those values to the instance. The finished instance is then returned and stored in rex.

Here is a comparison of how three different instances from the same class each hold their own, independent data:

Instance Attributes and Instance Methods

Data stored on an instance using self is called an instance attribute. A function defined inside a class that takes self as its first parameter is called an instance method. Together, instance attributes and instance methods make up the core of how objects work in Python.

Instance attributes hold an object's state — its current data. Instance methods define what an object can do — its behavior. Here is a more complete example showing both:

class Dog:
    def __init__(self, name, age):
        self.name = name          # instance attribute
        self.age = age            # instance attribute
        self.tricks = []          # instance attribute — starts empty

    def learn_trick(self, trick): # instance method
        self.tricks.append(trick)

    def describe(self):           # instance method
        return f"{self.name} is {self.age} years old."

rex = Dog("Rex", 4)
rex.learn_trick("sit")
rex.learn_trick("shake")

print(rex.describe())   # Rex is 4 years old.
print(rex.tricks)       # ['sit', 'shake']

luna = Dog("Luna", 2)
print(luna.tricks)      # [] — Luna's tricks list is separate from Rex's

Notice that rex.tricks and luna.tricks are separate lists, even though they were both created by the same line self.tricks = [] in __init__. That is because each time you create an instance, a brand-new list is created for that specific object. The two instances share the same blueprint but own their own copies of the data.

You can also modify instance attributes directly from outside the class using dot notation:

rex.age = 5           # update the age attribute directly
print(rex.age)        # 5
print(luna.age)       # 2 — luna is unaffected

"Objects are Python's main abstraction for data." — Python Data Model, Python Software Foundation Documentation

Python Learning Summary Points

1. A class is a blueprint. An instance is a concrete object built from that blueprint. You can create as many instances from a class as you need, and each one is independent.
2. __init__ runs automatically when a new instance is created. Use it to set instance attributes with self.attribute_name = value. Every instance gets its own copy of those attributes.
3. Instance methods take self as their first parameter and use dot notation to access and modify the instance's attributes. When you call a method, you never pass self — Python passes it for you.
4. Everything in Python is an instance of some class. Strings, lists, integers, and your own custom objects all follow the same instance model.
5. Use isinstance(obj, ClassName) to check whether an object is an instance of a particular class. This is safer than comparing types directly with type().

Instances are the building blocks of object-oriented Python. Once you understand that every object is an instance of a class — with its own attributes and access to the class's methods — you have the foundation needed to work with dataclasses, inheritance, Python's standard library, and third-party frameworks like Django or SQLAlchemy.