Learn What self Is in Python: Absolute Beginners Tutorial

Every Python class tutorial shows self in the first line of every method, and beginners are often told "just include it." This tutorial explains what it actually does, why every method needs it, and how to use it with confidence.

When you write a class in Python, every method that operates on an instance needs a way to refer to that specific instance. That is the entire job of self. It is not magic — it is a parameter like any other, and Python fills it in for you automatically every time you call a method on an object.

If you are still getting comfortable with Python classes in general, the guide to using classes in Python is a good companion read before continuing.

What self Is and Why It Exists

When you call a class in Python — for example buddy = Dog() — Python creates a new object from that class. That object is called an instance. You can create as many instances as you like from the same class: buddy and rex are both Dog instances, but each one is its own independent object with its own separate data.

That separation is exactly where self comes in. When a method runs, it needs to know which instance's data to read or change. self is the parameter that carries that information — it is a reference to the specific object the method was called on.

Consider those two Dog instances. If you call buddy.bark(), Python needs to know that bark() should act on buddy — not on rex or any other dog. It does that by automatically passing buddy as the first argument to bark(). The method's first parameter — called self by convention — receives that argument.

Here is the simplest class possible that shows self in action:

class Dog:
    def bark(self):
        print("Woof!")

buddy = Dog()
buddy.bark()   # Python calls Dog.bark(buddy) internally
# Output: Woof!

When you write buddy.bark(), Python translates that into Dog.bark(buddy). The buddy object is passed as self. You never type it yourself at the call site — Python handles it.

You can verify this by calling the method through the class directly instead of through an instance:

Dog.bark(buddy)   # exactly the same as buddy.bark()
# Output: Woof!

Both calls produce the same result because they are literally the same operation. In both cases, Python passes buddy as the first argument — the dot-notation form on instances is simply a shorter way to write it. Understanding this equivalence is the key to understanding what self actually is: it is the instance Python passes in automatically.

self in __init__: Storing Instance Data

__init__ is the method Python calls automatically the moment a new instance is created. It runs immediately, before any other code in your program touches that object, which makes it the right place to set up the data the instance will carry. You use self inside __init__ to attach that data directly to the object.

class Dog:
    def __init__(self, name, breed):
        self.name = name     # stored on this specific instance
        self.breed = breed   # stored on this specific instance

buddy = Dog("Buddy", "Labrador")
rex   = Dog("Rex",   "German Shepherd")

print(buddy.name)   # Buddy
print(rex.name)     # Rex

self.name = name stores the name argument directly on this instance as an instance attribute. buddy and rex each get their own separate .name and .breed — changing one never touches the other.

What self actually is at runtime

Inside __init__, self is the actual object in memory. You can confirm this with id():

class Dog:
    def __init__(self, name):
        print(id(self))     # memory address of the new object
        self.name = name

buddy = Dog("Buddy")
print(id(buddy))            # same memory address as above

The two id() calls print the same number, confirming that self inside __init__ is the very same object you assigned to buddy once __init__ finished running. Nothing is copied or duplicated — it is one object the whole time.

Instance attribute vs. local variable

One of the most common early mistakes is writing a plain variable assignment instead of a self assignment. There is also a third form worth knowing about: a class-level variable, which is written directly inside the class body but outside any method. Unlike an instance attribute, a class-level variable is shared across all instances of the class — every object reads the same value unless you specifically override it on one. The table below compares all three forms. Click a row to see what differs.

self in Other Methods: Accessing Your Data

Once __init__ has stored data on the instance, every other method in the class can reach that data through self. Any method that takes self as its first parameter can read an attribute with self.attribute, update it with self.attribute = new_value, or call another method on the same object with self.method_name().

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner   = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount           # modifies this instance's balance
        print(f"Deposited {amount}. New balance: {self.balance}")

    def summary(self):
        print(f"{self.owner}: ${self.balance}")

account = BankAccount("Alice", 100)
account.deposit(50)
account.summary()
# Deposited 50. New balance: 150
# Alice: $150

When account.deposit(50) runs, Python passes account as self. That means self.balance inside deposit is the exact same value as account.balance outside the class — they are the same attribute on the same object. When deposit writes self.balance += amount, it is updating the object directly, and that change is visible everywhere that object is used.

Calling one method from another using self

Methods can call other methods on the same instance using self.method_name(). This lets you split logic into focused, reusable pieces rather than writing everything in one long method. Python passes the instance as self in those inner calls too, so the whole chain always operates on the same object:

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner   = owner
        self.balance = balance

    def is_overdrawn(self):
        return self.balance < 0

    def deposit(self, amount):
        self.balance += amount
        if self.is_overdrawn():        # calling another method via self
            print("Warning: account is overdrawn.")

account = BankAccount("Alice", -10)
account.deposit(5)
# Warning: account is overdrawn.

Common self Mistakes

There are three mistakes beginners make with self repeatedly. Each one produces a specific error message, and once you know what to look for the fix is immediate.

Forgetting self in the method signature

If you define a method without self and then call it on an instance, Python raises a TypeError:

class Dog:
    def bark():          # missing self
        print("Woof!")

buddy = Dog()
buddy.bark()
# TypeError: Dog.bark() takes 0 positional arguments but 1 was given

The error message is telling you exactly what happened. Python tried to pass the buddy instance as the first argument — that is the "1" that was given. The method declared zero parameters, so it had nowhere to receive it. The fix is always the same: add self as the first parameter in the method definition.

Using self outside a class method

self is just a name — it has no special meaning outside a class. If you write it in a standalone function or at the module level, Python treats it as an ordinary variable. Outside a class, if you use self without having defined it first, you get a NameError:

def greet():
    print(self.name)   # NameError: name 'self' is not defined

greet()

There is no instance here, so there is no object for self to refer to. Python sees an undefined name and raises NameError. The fix is straightforward: if you need this function to operate on an object, make it a method inside a class and give it self as its first parameter.

Forgetting to use self when accessing an attribute

Inside a method, instance attributes live on self — they are not in scope as bare names. If you write the attribute name without self., Python searches for a local variable with that name, finds nothing, and raises a NameError:

class Counter:
    def __init__(self):
        self.count = 0

    def increment(self):
        count += 1         # NameError: name 'count' is not defined
        # correct: self.count += 1

The commented correct version — self.count += 1 — tells Python exactly where to look: on the instance. That single prefix is the entire difference between an attribute update and a crash.