What do __init__ and self do in Python?

Common Misconceptions

1. self is Optional:

   • Misconception: Some beginners think self is optional.
   • Reality: In instance methods, self must be explicitly defined as the first parameter to access instance attributes and methods.

2. __init__ is the Same as a Constructor:

   • Misconception: __init__ is often confused with the actual constructor.
   • Reality: The actual constructor is __new__, which creates a new instance. __init__ initializes the instance after it's been created.

3. self is a Keyword:

   • Misconception: self is a reserved keyword in Python.
   • Reality: self is just a naming convention. You can name it differently, but it's highly discouraged for the sake of readability and consistency.

Best Practices

1. Always Use self as the First Parameter:

   • Stick to the convention of naming the first parameter self to make your code more understandable to others.

2. Initialize All Necessary Attributes in __init__:

   • Ensure that all essential attributes are initialized within the __init__ method to prevent unexpected behaviors.

3. Keep __init__ Focused:

   • Avoid putting complex logic in __init__. Instead, delegate complex operations to other methods to keep initialization straightforward.

4. Use self to Access Attributes and Methods:

   • Always use self when referring to instance attributes and methods within class methods.

Advanced Example

class BankAccount:
    def __init__(self, account_holder, balance=0):
        self.account_holder = account_holder  # Instance attribute
        self.balance = balance                # Instance attribute

    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            print(f"Deposited ${amount}. New balance: ${self.balance}")
        else:
            print("Deposit amount must be positive.")

    def withdraw(self, amount):
        if 0 < amount <= self.balance:
            self.balance -= amount
            print(f"Withdrew ${amount}. New balance: ${self.balance}")
        else:
            print("Insufficient funds or invalid amount.")

    def display_balance(self):
        print(f"{self.account_holder}'s balance: ${self.balance}")

# Creating instances
account1 = BankAccount("Alice", 100)
account2 = BankAccount("Bob")

# Using methods
account1.deposit(50)        # Output: Deposited $50. New balance: $150
account1.withdraw(30)       # Output: Withdrew $30. New balance: $120
account1.display_balance()  # Output: Alice's balance: $120

account2.deposit(200)       # Output: Deposited $200. New balance: $200
account2.withdraw(250)      # Output: Insufficient funds or invalid amount.
account2.display_balance()  # Output: Bob's balance: $200

Explanation:

1. Initialization:

   • account1 is initialized with a balance of $100.
   • account2 is initialized with the default balance of $0.

2. Method Usage:

   • deposit and withdraw methods modify the balance attribute using self.balance.
   • display_balance accesses the account_holder and balance attributes using self.

3. Instance Independence:

   • account1 and account2 maintain separate states. Operations on one do not affect the other.

Summary

• __init__:

  • A special method called automatically when a new object is created.
  • Initializes the object's attributes.
  • Acts as the initializer, setting up the object's initial state.

• self:

  • A reference to the instance of the class.
  • Used to access and modify the object's attributes and methods.
  • Must be the first parameter in instance methods to maintain clarity and consistency.

Understanding __init__ and self is crucial for effective object-oriented programming in Python. They work together to create well-structured, maintainable, and efficient classes by ensuring that each object manages its own state and behavior properly.

Happy Coding!