How to Use ‘Self ‘in Python Class?

Introduction

If you’ve been learning Python, I’m sure you have come across the term ‘self.’ This small word plays a big role in how Python classes work. Whenever you create a method inside a class, you use ‘self’ to refer to the instance that calls the method. This helps you access and modify the instance variables and methods within the class. In this article, we’ll dive deep into what self means, why it’s important, and explore how it’s used in Python programming.

Overview

• Understand the meaning and importance of ‘self’ in Python class.
• Learn how to use ‘self’ in Python.
• Find out what happens when you don’t use ‘self’ in Python.

What Does `Self` Mean in Python?

In Python, ‘self` is a reference to the instance of the class. Python uses the term `’self’` to refer to the instance that is calling the class. In a class, it is used to call up the instance variables and methods. The following is an explanation of the term ‘self’`:

• Instance Reference: `self` is a conventional name for the first parameter of methods in a class. This term also stands for the class object that calls that method.
• Instance Variables: It is used to access instance variables and methods from within class methods.
• Method Definition: `self` is the first parameter of an instance method in Python. Thus any new user-defined method in a class will have `self` argument to signify the instance it refers to.

Why is `Self` Important?

Let’s now try to understand the importance of ‘self’ in Python.

1. Access to Instance Variables

`Self` allows you to access and modify instance variables within class methods.

Example :

 class Person:
        def __init__(self, name, age):
            self.name = name  # self.name is an instance variable
            self.age = age    # self.age is an instance variable

        def greet(self):
            print(f"Hello, my name is {self.name} and I am {self.age} years old.")
   

2. Access to Other Methods

`Self` allows methods within the same class to call other methods.

Example :

class Circle:
        def __init__(self, radius):
            self.radius = radius

        def area(self):
            return 3.14 * self.radius * self.radius

        def perimeter(self):
            return 2 * 3.14 * self.radius

        def describe(self):
            print(f"Circle with radius {self.radius}, area: {self.area()}, perimeter: {self.perimeter()}")
   

3. Distinguishing Between Class and Instance Variables

Using `self` helps distinguish between instance variables and local variables within methods.

class Example:
        def __init__(self, value):
            self.value = value  # instance variable

        def set_value(self, value):
            self.value = value  # here self.value is the instance variable, and value is the local variable

Can Another Word Be Used Instead of `Self`?

Indeed, `self` can be replaced with any valid variable name. However, this is risky since `self` is a widely recognized convention. It is highly discouraged when individuals come across a new name, they might become puzzled and disoriented, causing a potential problem. Also, using a different name might confuse other programmers who read your code.

class Person:
    def __init__(myself, name, age):
        myself.name = name
        myself.age = age

    def greet(myself):
        print(f"Hello, my name is {myself.name} and I am {myself.age} years old.")

In this example, `myself` is used instead of `self`, and it works perfectly fine, but it is not recommended.

What Happens If ‘Self` is Not Used?

If you do not include `self` (or an equivalent first parameter) in your method definitions, you will encounter errors when you try to call those methods. This is because Python automatically passes the instance as the first argument to instance methods, and if your method signature does not expect it, it will result in a `TypeError`.

class Person:
    def __init__(name, age):  # Incorrect: missing 'self'
        name = name
        age = age

    def greet():  # Incorrect: missing 'self'
        print(f"Hello, my name is {name} and I am {age} years old.")

# This will raise an error when you try to create an instance
p = Person("Alice", 30)

Error:

TypeError: __init__() takes 2 positional arguments but 3 were given.

Conclusion

`Self` is essential for accessing instance variables and methods within a class. It allows for object-oriented programming practices and ensures that methods operate on the correct instances. This gives you the power to build complex, reusable, and modular code. While you can technically use another name instead of `self`, it is not recommended due to conventions and readability. Also remember that not using `self` where required will result in errors, disrupting the smooth operation of your code. Embrace ‘self’, and you’ll find your Python programming becomes more intuitive and effective.

Frequently Asked Questions

Sahitya Arya

I'm Sahitya Arya, a seasoned Deep Learning Engineer with one year of hands-on experience in both Deep Learning and Machine Learning. Throughout my career, I've authored more than three research papers and have gained a profound understanding of Deep Learning techniques. Additionally, I possess expertise in Large Language Models (LLMs), contributing to my comprehensive skill set in cutting-edge technologies for artificial intelligence.