Initializing Objects with __init__

From Blueprint to Object

Imagine tracking several bank accounts. Each account needs data such as an account number, an owner's name, and a balance. It also needs actions such as depositing, withdrawing, and checking the balance. A class groups this related data and behavior into one organized structure. The class is the blueprint; each bank account created from it is an object, or instance. The important question for this article is how each new object receives its starting data.

The Creation Sequence

Object creation can be understood as a sequence. First, the class provides the blueprint. Next, a program creates an instance from that class. During that creation, __init__ runs automatically. Its purpose is to initialize the object's attributes with starting values. After this step, the instance has the data it needs for its initial state and can use the behavior defined by the class.

Writing Initial State

An attribute is data that belongs to an object. For a Student object, attributes might include name, student_id, and gpa. A method is a function that belongs to the object's behavior. For example, a method might calculate a letter grade or update the gpa. The class keyword places these related attributes and methods inside one cohesive blueprint. The __init__ method is the part that gives each newly created object its initial attribute values.

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

    def update_gpa(self, new_gpa):
        self.gpa = new_gpa

student = Student("Mina", "S104", 3.7)

In this example, Student is the class and student is one instance. When the instance is created, __init__ runs and assigns three attributes. The assignments use self to attach each value to the particular object being created. The update_gpa method later operates on that object's gpa attribute. A second Student object could be created with different values and would receive its own separate attributes.

Following self

Data and Behavior Together

An object bundles data and behavior into one organized unit. Attributes store information about the object's state or characteristics. Methods perform actions and typically work with those attributes. This relationship keeps an action close to the data it uses. In a bank account, for example, the balance is data, while depositing, withdrawing, and checking the balance are behaviors associated with that account.

class BankAccount:
    def __init__(self, account_number, owner, balance):
        self.account_number = account_number
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance = self.balance + amount

account = BankAccount("A17", "Ravi", 500)
account.deposit(200)

The BankAccount class organizes the account data and actions together. When the account is created, __init__ establishes the initial account number, owner, and balance. When deposit is called, self identifies which account's balance should be changed. A different BankAccount object could use the same method while keeping its own independent balance.

Mistakes with Initialization

• Treating the class and the object as the same thing

  The class defines the structure and behavior, while each object is an instance created from that blueprint.

  Fix: Ask whether you are describing the plan or one individual instance.

• Forgetting that attributes belong to a particular instance

  Each instance has its own separate set of attributes and can have different values.

  Fix: Trace self in each call to __init__; it refers to the specific object being initialized.

• Using __init__ without initializing the object's expected attributes

  The object may not begin in a valid, predictable state.

  Fix: Initialize every attribute that the object will use in __init__.

• Confusing attributes with methods

  Attributes store information, while methods perform actions, usually using the object's attributes.

  Fix: Classify each class member by asking whether it stores state or performs behavior.

Practice the Trace

1. Identify the class as the blueprint and the two Book values as separate instances.
2. List the attributes that every Book object should have.
3. Explain that __init__ runs automatically for each new instance.
4. Explain how self makes each assignment belong to the particular Book being created.
5. Check that the describe method uses the attributes of the object that calls it.

Key Takeaways

1. A class is a blueprint, while an object is an instance created from that blueprint.
2. Attributes store an object's information, and methods perform actions involving that information.
3. The class keyword groups related data and behavior into a cohesive structure.
4. __init__ runs automatically when an object is instantiated and establishes its initial state.
5. self refers to the particular object being initialized, so each instance receives its own independent attributes.