The Constructor and the self Parameter

One Class, Many Objects

A class becomes especially useful when it creates more than one object. The class provides the shared structure, while each object receives its own data. For example, one PartyAnimal object can begin with the name Sally and another can begin with the name Jim. Both objects come from the same class, but they do not have to contain the same attribute values.

What the Constructor Receives

The constructor is the __init__ method. It has two kinds of parameters. The self parameter refers to the particular object being created. Additional parameters receive values supplied by the caller. Those additional parameters allow each new object to start with customized data.

class PartyAnimal:
    def __init__(self, nam):
        self.x = 0
        self.name = nam

In this constructor, self identifies the object that is currently being initialized. The parameter nam holds the value passed by the caller. The assignment self.name = nam stores that passed-in value in the name attribute of the particular object identified by self. The assignment self.x = 0 gives that same object its starting x value.

Tracing Two Constructor Calls

s = PartyAnimal('Sally')
j = PartyAnimal('Jim')

The separate data is the important point. If Sally's party() method increments her x to 1, Jim's x remains 0. The objects were created from the same class, but each object maintains its own independent copies of its attributes.

The Role of self

self connects the constructor's assignments to one specific object. During the creation of s, self refers to the object referenced by s, so self.name receives Sally and self.x receives 0. During the creation of j, self refers to the new object referenced by j, so that object's name receives Jim and its x receives 0. The same constructor instructions can therefore initialize different objects with different values.

Mistakes with Initialization

• Treating the constructor parameter as the object's attribute

  The parameter is the incoming value. The assignment self.name = nam stores that value in the particular object's name attribute.

  Fix: Trace both names separately: nam is the parameter, while self.name is the object's attribute.

• Forgetting that self identifies the current object

  The constructor runs for each object being created, and self refers to the object being initialized during that call.

  Fix: For each constructor call, ask which object self refers to before tracing the assignment.

• Assuming objects created from one class share the same attribute values

  Each object maintains its own independent copies of x and name.

  Fix: Track each instance separately. Sally's x can become 1 while Jim's x remains 0.

Practice the Trace

Key Takeaways

1. The constructor __init__ initializes an object when it is created.
2. Parameters beyond self let each constructor call supply unique initial values.
3. self identifies the particular object whose attributes are being initialized.
4. self.attribute = parameter stores an incoming value in that object's attribute.
5. Objects from the same class maintain independent attribute data, so changing one does not affect another.