The self Parameter Explained

From Class Call to Initialized Object

When you write MyClass(some_value), Python does more than simply produce an object. Python creates a new object and automatically calls the special method named __init__ on that object. The initialization method runs before the object is returned to your code, so the object can emerge with its initial state already set up.

The Initializer Method

__init__ is a special method used to initialize an object's state immediately. Its name has two underscores at the beginning and two underscores at the end. This distinctive naming convention signals that Python should recognize the method and call it automatically at the appropriate point in an object's lifecycle.

class Person:
    def __init__(self, name):
        self.name = name

The first parameter is self. After self, the method declares the parameters needed for initialization. In this example, name is the initialization parameter. When an instance is created with a name argument, Python supplies the object as self and supplies the creation argument as name. The caller passes the initialization argument, but does not pass self; Python handles self automatically.

Following Alex into Object State

The two uses of name in self.name = name have different roles. The name on the right is the parameter receiving the value from instantiation. The name after self. identifies the instance attribute that stores that value. self connects the assignment to the particular object currently being initialized.

class Person:
    def __init__(self, name):
        self.name = name

p = Person('Alex')

Before and After Initialization

At the instant Python creates a Person object, the source describes it as existing without attributes. The __init__ method then assigns the name attribute. After initialization completes, the same object has name set to 'Alex'. This state change happens automatically as part of instantiation.

Multiple Values in One Setup

__init__ can receive several initialization parameters. For example, when Student('Jordan', 12345, 10) is used, Python runs __init__ with those three arguments. The object can then emerge with all corresponding attributes populated, rather than requiring separate assignments after creation.

class Student:
    def __init__(self, name, student_id, grade):
        self.name = name
        self.student_id = student_id
        self.grade = grade

student = Student('Jordan', 12345, 10)

Here, self still represents the particular Student object. name, student_id, and grade receive the values supplied during instantiation. Each assignment beginning with self. places one of those values into the object's state.

Mistakes with self and __init__

• Leaving out self as the first parameter

  The source specifies that __init__ must include self as its first parameter. self represents the object being initialized.

  Fix: Use def __init__(self, name): and pass only the initialization value when creating the object.

• Using the wrong method name

  Python recognizes the initializer through the distinctive name with double underscores on both sides.

  Fix: Write the method name exactly as __init__.

• Assuming the caller passes self

  Python handles self automatically when it invokes __init__.

  Fix: Create the object with the initialization value, such as Person('Alex').

• Forgetting to bind a parameter to an instance attribute

  The source identifies self.name = name as the assignment that stores the value as part of the object's state.

  Fix: Use self.name = name when the value should become an attribute of that object.

Practice the Data Trace

Key Takeaways

1. __init__ runs automatically during object creation, before the initialized object is returned to your code.
2. The method name has double underscores on both sides: __init__.
3. self is the first parameter and represents the particular object being initialized; Python supplies it automatically.
4. Arguments passed during instantiation become __init__ parameter values, and assignments such as self.name = name store them as instance attributes.
5. Defining __init__ makes initialization consistent and documents the data an object needs.