Defining Your Own Classes

From Creation to Cleanup

An object-oriented program becomes easier to understand when you follow an object's lifecycle. The central pattern has three phases: construction, operation, and destruction. During construction, __init__ sets up the object's internal data attributes. During operation, methods are called with dot notation and may change the object's internal state. During destruction, Python calls __del__ to clean up the object.

Construction with __init__

The constructor is named __init__. Python calls it automatically when you create an object. Its role is to set up the object's internal data attributes, giving the object the initial structure it needs before methods operate on it.

class Counter: def __init__(self): self.value = 0 counter = Counter()

Methods and State Changes

Methods are functions that belong to objects. They are called with dot notation, such as object.method(). A method can modify the object's internal state, so the same object can contain different values after successive operations.

class Counter:
    def __init__(self):
        self.value = 0

    def increment(self):
        self.value = self.value + 1

counter = Counter()
counter.increment()
counter.increment()

The important point is that counter.increment() is not just a label for an action. Python looks up the increment method on counter, calls it, and allows that method to modify the object's internal state.

Bracket Access and __getitem__

Square bracket access is another form of method invocation. For an object named stuff, the expression stuff[0] is shorthand for stuff.__getitem__(0). The source also identifies list.__getitem__(stuff, 0) as an equivalent form. In each form, the object is accessed with the key or index 0.

stuff = ['first', 'second']

item_a = stuff[0]
item_b = stuff.__getitem__(0)
item_c = list.__getitem__(stuff, 0)

In the example, item_a, item_b, and item_c each refer to the item selected with index 0.

Reading Each Line Mechanically

When reading object-oriented code, replace surface syntax with the mechanism it represents. Creating list() invokes construction and automatic initialization. Calling stuff.append('item') looks up the append method on stuff and calls it with the supplied parameter; the method changes the list's internal state. Reading stuff[0] means recognizing the shorthand call to __getitem__(0). When the object is no longer needed at program end, Python calls __del__ for cleanup.

Mistakes in Lifecycle Tracing

• Treating __init__ as an ordinary method that must be called manually after every object is created

  The constructor is called automatically when the object is created.

  Fix: Read the creation expression as the event that invokes __init__.

• Assuming a method call only produces an action and does not change the object

  Methods can modify the object's internal state.

  Fix: Record the object's state before and after each method call.

• Thinking stuff[0] is unrelated to __getitem__

  Square bracket syntax is a shorthand for stuff.__getitem__(0).

  Fix: Translate bracket access into the corresponding __getitem__ call while tracing.

• Stopping the lifecycle trace after the final visible operation

  The lifecycle also includes destruction, during which Python calls __del__ when the object is no longer needed.

  Fix: Include cleanup as the final phase of the lifecycle.

Lifecycle Checklist

1. Object construction automatically invokes __init__, which sets up internal data attributes.
2. Methods belong to objects, are called with dot notation, and can modify internal state.
3. Square bracket syntax such as stuff[0] is shorthand for stuff.__getitem__(0).
4. A complete trace includes construction, operation, and destruction.
5. When an object is no longer needed at program completion, Python calls __del__ for cleanup.