After this lesson, you will be able to:

• Define __init__ and initialize instance attributes as an object is created.
• Distinguish the constructor parameters from attributes stored on self.
• Create separate instances from different constructor arguments.
• Use an optional constructor argument and preserve the initial state when a method updates it.

In the previous lesson, you created a class and attached attributes after constructing each object. That works, but it is easy to forget an attribute. Python's __init__ initializes an instance automatically when you call its class:

class Task:
    def __init__(self, name, owner):
        self.name = name
        self.owner = owner

Task("build", "Maya") constructs an object and calls __init__ with the supplied arguments. Python supplies self automatically; you do not pass it yourself. Unlike a Java/C# constructor, __init__ is an initialization method, and it normally does not return a value.

Constructor parameters are temporary inputs. self.name and self.owner are instance attributes that remain available through the object. Every call constructs a separate instance with its own stored state.

Defaults from Unit 1 work in __init__ as well: def __init__(self, name, retries=0): lets callers omit a retry count. Put required parameters before optional ones.

1. Initialize attributes when an object is created

class Endpoint:
    def __init__(self, name, region):
        self.name = name
        self.region = region

endpoint = Endpoint("billing", "eu")
print(f"{endpoint.name}@{endpoint.region}")

Output:

billing@eu

The constructor inputs become persistent instance attributes.

2. Create independent objects

class Deployment:
    def __init__(self, tag, ready):
        self.tag = tag
        self.ready = ready

first = Deployment("v1.4", True)
second = Deployment("v1.5", False)
print(first.ready)
print(second.ready)

Output:

True
False

The second object does not overwrite the first object's state.

3. Provide a sensible optional starting value

class Queue:
    def __init__(self, name, pending=0):
        self.name = name
        self.pending = pending

normal = Queue("email")
busy = Queue("reports", 4)
print(f"{normal.name}: {normal.pending}")
print(f"{busy.name}: {busy.pending}")

Output:

email: 0
reports: 4

The default applies only when the caller omits the argument.

4. Update initialized state inside a method

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

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

wallet = Wallet("Ari", 20)
wallet.deposit(7)
print(f"Balance: {wallet.balance}")

Output:

Balance: 27

Methods change the initialized state using self, not a temporary local variable.

• Writing name = name instead of self.name = name does not save an attribute on the instance.
• Accessing an attribute never initialized on self raises AttributeError.
• Ignoring a caller-supplied starting value and always setting a hardcoded default changes the intended object state.
• Returning an ordinary value from __init__ raises a TypeError; use other methods to return results.