🔒 classes

[rigid dirge]

Can someone explain Self in Classes in simple terms?

[hollow matrix]

@rigid dirge

Python help channel opened

Remember to:

• Ask your Python question, not if you can ask or if there's an expert who can help.
• Show a code sample as text (rather than a screenshot) and the error message, if you've got one.
• Explain what you expect to happen and what actually happens.

:warning: Do not pip install anything that isn't related to your question, especially if asked to over DMs.

Closes after a period of inactivity, or when you send !close.

[surreal kestrel]

self is the instance of the class

like when you call a class, you are running self

because its the instance of the class being runned

!self

[hollow matrix]

Class instance

When calling a method from a class instance (ie. instance.method()), the instance itself will automatically be passed as the first argument implicitly. By convention, we call this self, but it could technically be called any valid variable name.

class Foo:
    def bar(self):
        print('bar')

    def spam(self, eggs):
        print(eggs)

foo = Foo()

If we call foo.bar(), it is equivalent to doing Foo.bar(foo). Our instance foo is passed for us to the bar function, so while we initially gave zero arguments, it is actually called with one.

Similarly if we call foo.spam('ham'), it is equivalent to
doing Foo.spam(foo, 'ham').

Why is this useful?

Methods do not inherently have access to attributes defined in the class. In order for any one method to be able to access other methods or variables defined in the class, it must have access to the instance.

Consider if outside the class, we tried to do this: spam(foo, 'ham'). This would give an error, because we don't have access to the spam method directly, we have to call it by doing foo.spam('ham'). This is also the case inside of the class. If we wanted to call the bar method inside the spam method, we'd have to do self.bar(), just doing bar() would give an error.

[hushed lotus]

self is the instance being worked on

it's more obvious when you use explicit self passing, rather than the usual implicit self passing (as also shown above):

class MyClass:
    def set_name(self, name):
        self.name = name
    def get_name(self):
        return self.name

# explicit self passing
instance = MyClass()
MyClass.set_name(instance, 'Alfred')
print( MyClass.get_name(instance) )

# implicit self passing
instance = MyClass()
instance.set_name('Alfred')
print( instance.get_name() )```

[hollow matrix]

Python help channel closed

This help channel has been closed and it's no longer possible to send messages here. If your question wasn't answered, feel free to create a new post in #1035199133436354600. To maximize your chances of getting a response, check out this guide on asking good questions.