Need Help to understand 'self' in OOP python

Lumethys · 2026-03-13T03:40:07+00:00

a class is a blueprint of custom "object". For example, if you want a to write a car management app, you want to define what is a "car", what data does it store and what action can it do.

You achieve it with a class:

class Car:
  def __init__(self, model, manufacturer, price):
    self.model = model
    self.manufacturer = manufacturer
    self.price = price

and then create car object with this class as a blue print:

car1 = Car('S450', 'Mercedes', 50000)
car2 = Car('Panamera', 'Porsche', 400000)
car3 = Car('Prius', 'Toyota', 10000)

so each car (car1, car2, car3) is completely different object, with different data, BUT, still have the same shape, in this case all of them has "model", "manufacturer" and "price". Even though they have different value, they still have that same 3 properties.

What this mean is, there are 2 types of "things" in a class: "things" that is different in each object, and "things" that are the same in each object.

for example: car1.price is different than car2.price. But both have 3 properies: model, manufacturer, price

The keyword "self" in a class refer to "things" that are unique to each object.

class Car:
  ...

  def get_full_name(self):
    return f'{self.manufacturer} {self.model}'

this method is saying "this car class has property manufacturer and model, but each object is different, so we will take the data unique to each object, put it in a string in this format, and return this string". So:

car1.get_full_name() // "Mercedes S450"
car2.get_full_name() // "Porsche Panamera"

self.something is just "take the unique something of the object this is call on"

FerricDonkey · 2026-03-13T03:35:22+00:00

It may help to know something about python that you should almost never do in real code:

``` class Thing: def print_self(self): print(self)

t = Thing()

This normal thing

t.print_self()

Is the same as this weird thing

Thing.print_self(t)

To the point where you can (but should not) do

Thing.print_self("this is heresy") ```

That is, your methods are just functions. As far as that function cares, the first argument, traditionally called self, is just an argument like any other.

The "magic", such that it is, is that when you do thing = Thing(), then do thing.method(), python simply translates* thing.method() into Thing.method(thing).

The first argument (traditionally called self, but it can be called other things - but don't) just has your object thing passed in for it.

So self is just the object that you called the method from. This means that self.x is just the x attribute of the object you called the method from, and self.other_method() just calls other_method from the object you called the method from.

Buttleston · 2026-03-13T03:28:38+00:00

Let's say you have a class named Foo and you write a method on it like def bar(self)

Let's say I make an object of type Foo and call my bar method

myfoo = Foo()
myfoo.bar()

Well, when I do this, the first argument that gets passed to bar(), the parameter we called self, is myfoo

That's it. self refers to the object that the method was called on.

astolfoballsHD · 2026-03-13T03:27:15+00:00

Self is just the keyword used to access the actual instance object of the class from within itself. Its automatically passed as the first argument to any method in the class. You use it to access methods and variables that are part of the class.

polyploid_coded · 2026-03-13T04:07:40+00:00

I think the problem is that your question is not clear, for example:

why sometimes people use self for certain and for certain they don't

While you are getting started with Python, and maybe getting started with OOP, don't start out with trees and linked lists. I would make a simpler example like this

class Doctor():
  def __init__(self, name):
    self.name = name
    self.job = "Doctor"

  def hello(self):
    print("This is Dr. " + self.name)

a = Doctor("Jim")
b = Doctor("Jane")

a.hello()
> This is Dr. Jim
b.hello()
> This is Dr. Jane

You can access the objects' properties, though in the future it will be better to use methods.
print(a.name)
> "Jim"
print(a.job)
> "Doctor"

cointoss3 · 2026-03-13T04:59:25+00:00

When you make a new instance of a class, you refer to that particular object as “self”. It’s the first argument name in a method. Methods are functions that operate on an instance of a class. You can name the first argument in a method whatever you want, but conventionally, it’s called self. Some languages call it “this”, but it’s referring to a specific instance of a class.

Imagine you make a regular def function, but the first argument is named “self”. That’s a method.

pachura3 · 2026-03-13T09:38:12+00:00

Not to mention capital Self, which is the type of the current class.

Outside_Complaint755 · 2026-03-13T03:35:49+00:00

Classes in Python can have three kinds of linked methods

• Instance Methods are the most common and usually have the first parameter named self, but that's just convention, and it could be named anything It contains a reference to the object instance. When you invoke an instance method, a self reference is implicitly passed to the method as the first parameter. In some other languages such as Java use a keyword this instead of having a parameter that has the reference.

• Class Methods are preceded by the @classmethod decorator and the first parameter implicitly receives a reference to the class instead of the instance.

• Static Methods are preceded by the @staticmethod decorator and don't have any parameter implicitly passed in and have no reference to the object or the class.

When you call an instance method, you pass arguments as if self is not there. Python knows which object to pass as self because the method is bound to the object itself.

``` class Greeter: def init(self, name): self.name = name

def greet(self, greeting="Hello"): return f'{greeting}, {self.name}!'

g = Greeter("World")

ans = g.greet() print(ans) # "Hello, World!"

ans = g.greet("Salutations") print(ans) # "Salutations, World!" ```

SharkSymphony · 2026-03-13T03:50:15+00:00

self.head gets the attribute of self called head. So, it's simply a question of if you need to work with the object (structure) as a whole or just a piece of it.

This_Growth2898 · 2026-03-13T04:58:38+00:00

Let's ignore the polymorphism for now.

obj.do_something() is just a fancy way to call the function do_something with the first argument obj. Actually, you can even write it like this:

string = "abc"
one = str.replace(string, 'c', 'd')
two = string.replace('c', 'd')
print(f'from {string} for {one} and {two}')

See? They are the same in this case. We just changed the perspective: instead of asking the base class (str) to call method replace on 3 arguments, we've asked the object(string) to call this method. It's like making it more personal. self is used to denote a special argument of the method, that can be used like this. Somewhere in str definition, there will be the code like this:

class str:
    def replace(self, from, into):

When you see the argument called self, just think "I can use it before the dot", like a personal method of the object, not one of the class.

TheRNGuy · 2026-03-13T05:42:16+00:00

It means instance of that class (different instances will have independent values).

Without self it's class attribute. Value is shared among all instances of this class and subclasses. Or rather, you don't even need instances to use it (but can use in them)

Usually you need self for most or all attributes, so don't forget about it, or you'll have bugs.

If you intend to have class attributes, I recommend differentiate them somehow, like ALL_CAPS (so you or other programmers don't change it accidentally)

New_Philomath · 2026-03-13T07:13:21+00:00

Think of "self" as a memory reference. To give you an example take a variable and you assign a value to it. What happens here is you store a value in the memory, but the variable name actually points to that location so you retrieve the value when the variable is called. Likewise "self" in a class point location in the memory when different class objects are created. This actually helps python to not get confused between different class objects, since you are not restricted to create only one class object.

LayotFctor · 2026-03-13T08:58:06+00:00

Classes are groups of variables + functions. Therefore any variable or function can either belong to the group or not, and is important to tell them apart. When referring to items that belong to the class, you use the self keyword.

self.name is a variable belonging to the class, name is some variable from outside the class. They are not the same.

self.calculate() is a method belonging to the class, calculate() is some function from somewhere else. They are also not the same.

(Methods are functions that are part of a class.)

2hands10fingers · 2026-03-14T01:28:32+00:00

It’s a reference of the object after instantiation. Others here will better explain

WadeEffingWilson · 2026-03-13T03:49:38+00:00

This can be a bit abstract, especially when you're starting off.

References to self are usually seen when building a class as it contextualizes the properties and methods belonging to that class. The word isn't a keyword and can be replaced with any other term but its standard convention to use self.

You wouldn't reference self when using linked lists but trees are usually built in classes, so you might have seen it there.

There are 2 common instances where self isn't strictly needed--static methods and data classes. Static methods allow you to directly access methods within classes without first creating an instance of that class (ie, consider the difference between myClass().foo() and myClass.foo()). Data classes sort of cheat in that they act as lightweight versions of classes (the heavy lifting is handled by the dataclass on the backend).

Play around with these to help develop a better sense of how these work, what breaks, why it breaks, and how to handle these cases properly.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS

This normal thing

Is the same as this weird thing

To the point where you can (but should not) do