Python Classes: Object-Oriented Programming (OOP) in Python

You have already used objects whenever you have worked with a number, string, list, or dictionary. An object has a type, a value or state, and operations it supports. Even functions and None are objects. Writing your own class extends this familiar system.

Find an object's type and methods

type("hello") returns <class 'str'>; type([1, 2]) returns <class 'list'>. The words type and class describe the same role here. isinstance(3.5, float) is True, while isinstance("3.5", float) is False: the second value is text, even though it looks numeric.

A method is a function provided by a type. In "ada lovelace".title(), the string before the dot is the object, title is the method, and the parentheses call it. The result is "Ada Lovelace". dir(value) lists names offered by an object; names such as __len__ are special methods that connect objects to Python operations such as len(value).

Track the result and the original

A method call can return a result, change an object, or do both. Check the method's behavior before deciding what to assign.

word = "level"
print(word.count("l"))  # 2
print(word.upper())     # LEVEL
print(word)             # level

nums = [3, 1, 2]
result = nums.sort()
print(nums)             # [1, 2, 3]
print(result)           # None

Strings are immutable: their contents cannot change. upper() returns another string, so word keeps its original value. To keep the uppercase result under that name, write word = word.upper().

Lists are mutable. sort() changes the list in place and returns None. Writing nums = nums.sort() loses the list reference held by nums and assigns None. Use nums.sort() on its own line, or nums = sorted(nums) to get a new sorted list. For a dictionary, {"a": 1}.get("b", 0) returns 0 because the requested key is missing.

Parentheses matter too. word.upper is a method object; word.upper() runs it. The same behavior can be offered by many objects: "cat".upper() and "dog".upper() use one kind of method with different string data.

Separate equality from identity

Equality asks whether values match. Identity asks whether two names refer to one object.

a = [1, 2]
b = [1, 2]
c = a
print(a == b)  # True
print(a is b)  # False
print(c is a)  # True
c.append(3)
print(a)       # [1, 2, 3]
print(b)       # [1, 2]

a and b start with equal contents but are separate lists. c = a creates an alias, another name for the same list. Appending through c changes the object that a also refers to. It does not change the separate list held by b. When tracing a program, draw one box per object and an arrow from each name to its box.

A class defines a type you can use in your own program. Each object made from it is an instance. One class describes the kind of thing; instances hold the data for particular things. A blank form and its filled-in copies make a useful comparison.

Write a class and call it

A class statement has the keyword class, a name, a colon, and an indented body. pass supplies an empty body while you try out the structure.

class Book:
    pass

b1 = Book()
b2 = Book()
print(b1 is b2)           # False
print(isinstance(b1, Book))  # True

Each Book() call makes a separate instance. In a script, type(b1) shows <class '__main__.Book'>. The class statement must run before code tries to use Book. You can also define a class in a module and import it with from library import Book, then create instances in the calling program.

Follow Python's naming conventions: Book, BankAccount, and ShoppingCart use CapWords, with each word capitalized. Variables and methods use lowercase words separated by underscores, such as book_count and add_item. Use four spaces for each level of indentation.

Store data on each instance

An attribute is a named value reached with a dot. Assigning an attribute stores it; reading the same name retrieves it.

b1.title = "Dune"
b2.title = "Emma"
b1.pages = 412
print(b1.title)  # Dune
print(b2.title)  # Emma
print(b1.pages)  # 412

The data belongs to the selected instance. Giving b1 a pages attribute does not give one to b2. Reading b2.pages now raises AttributeError, because that object has no attribute named pages.

Assignments can create new names without checking what you meant. After b1.titel = "X", the original b1.title still holds "Dune"; the object has gained a second attribute with a misspelled name. If a value seems not to change, compare the spelling where it was assigned and where it was read.

Keep the class and its instances distinct

b = Book gives the class another name. It does not create a book. If titles were set only on instances, asking for Book.title raises AttributeError; there is no single title shared by the type.

Give every object a dependable start

Setting attributes from outside is possible, but it leaves setup scattered across the program. One book might receive a title and page count while another receives only a title. Later code cannot safely assume that both have pages.

A setup method called __init__ places the starting assignments inside the class. Each creation call then follows the same setup process. The class can require a title and create other attributes with sensible initial values, so calling code does not have to remember a separate sequence of assignments.

Every newly created account needs an owner and a starting balance. Putting that setup in __init__ gives each object the attributes that later methods expect. Python creates the instance first, then calls __init__ to initialize it.

Connect arguments to attributes

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
        self.transactions = []

acct = BankAccount("Maya", 50)
other = BankAccount("Leo")

For the first call, Python passes the new account as self, "Maya" as owner, and 50 as balance. The assignments make acct.owner equal "Maya" and acct.balance equal 50. The second call uses the default balance, so other.balance is 0.

self is the parameter that receives the current object. It is a convention, not a Python keyword. Use this name so readers can recognize the object immediately. Callers leave it out: BankAccount("Maya", 50) supplies two arguments, not three.

Keep local names and stored data separate

In self.owner = owner, the name on the right is a local parameter. The name on the left is an attribute stored on the object. When initialization ends, other methods can still use self.owner.

Writing balance = balance only reassigns the local name. It creates no attribute, so reading acct.balance later fails. Put self. before each attribute that should remain part of the object.

Plan initialization by listing what each instance needs. Required values become parameters after self; optional values can have defaults. Values that always start the same way can be assigned in the body, such as self.visits = 0. A list created by self.transactions = [] is made anew on every call.

Avoid a shared default list

A default argument is evaluated when Python defines the method. With def __init__(self, items=[]), calls that omit items receive the same list. If the initializer stores that list directly, changing one object's items changes the items seen by another.

Use None as the default and create a fresh list during each call:

class Cart:
    def __init__(self, items=None):
        self.items = [] if items is None else list(items)

a = Cart()
b = Cart()
a.items.append("pen")
print(b.items)  # []

list(items) also makes a new outer list when a caller supplies one. The objects inside that list are still shared references; creating the list does not recreate every item.

Read setup errors

BankAccount() is missing the required owner argument and raises TypeError. Check the call against the parameters after self.

The spelling __init__ has two underscores on each side. _init_ is an ordinary method name and will not perform this setup automatically. __init__ must return None, so normally leave out a return statement. Returning a balance raises TypeError; the class call itself supplies the new instance to the caller.

Some values describe one object; others describe the type as a whole. A pizza's size belongs to that pizza. A topping limit or a count of pizzas created can belong to the class. Where an assignment occurs determines which kind of attribute it creates.

Put the value in the right place

class Pizza:
    MAX_TOPPINGS = 5
    count = 0

    def __init__(self, size):
        self.size = size
        self.toppings = []
        Pizza.count += 1

p1 = Pizza("large")
p2 = Pizza("small")

size and toppings are instance attributes, set on self. Each pizza has its own values. MAX_TOPPINGS and count are class attributes, assigned in the class body outside a method. Capital letters mark a value intended as a constant; they do not prevent reassignment.

After these calls, Pizza.count is 2. Every initializer updates the same class attribute. p1.size is "large", while p2.size is "small".

Trace lookup and shadowing

For ordinary data attributes such as these, reading p1.MAX_TOPPINGS first checks the instance and then the class. Since no value is stored on p1, Python finds Pizza.MAX_TOPPINGS, which is 5.

Assignment through an instance has a different effect:

p1.MAX_TOPPINGS = 8
Pizza.MAX_TOPPINGS = 6
print(p1.MAX_TOPPINGS)     # 8
print(p2.MAX_TOPPINGS)     # 6
print(Pizza.MAX_TOPPINGS)  # 6

The first line creates an instance attribute on p1. It shadows the class value for that object. Changing the class value later reaches p2, which still reads from the class, but does not replace p1's own value.

Watch two forms of accidental sharing

If the initializer used self.count += 1, Python would read the class's 0, add one, and store an instance attribute. Each new pizza would receive its own count of 1, while Pizza.count stayed 0. Name the class when updating a class-wide counter.

A list in the class body causes a different problem. With toppings = [], instances that have no separate toppings attribute all find the same list. p1.toppings.append("olives") mutates that shared list; it does not assign a new instance attribute. Put self.toppings = [] in __init__ when each pizza needs its own toppings.

Inspect an object's own data

For the original p2, vars(p2) gives {'size': 'small', 'toppings': []}. The class values are absent because they live on Pizza. This is useful when debugging a surprising lookup: check whether the instance has its own value, then inspect the class value. A shared setting belongs on the class; a name, size, balance, or personal collection belongs on the instance.

An object should start in a state its methods can use. A rectangle with a negative width cannot represent the intended shape. A rule that must remain true for every object of a class is an invariant. Validation checks those rules before accepting data.

Check before storing

class Rectangle:
    def __init__(self, width, height):
        if width <= 0:
            raise ValueError("width must be positive")
        if height <= 0:
            raise ValueError("height must be positive")
        self.width = width
        self.height = height

Rectangle(3, 4) passes both checks and returns an initialized object. Rectangle(-2, 4) raises ValueError at the first check. The later assignments never run. If the program does not catch that exception, execution stops there.

Suppose r already refers to a valid rectangle. In r = Rectangle(-2, 4), the right-hand call fails before assignment. r keeps its previous value. If r had no value before the failed call, the assignment does not create one.

Choose a useful exception

A negative numeric width is a value error. Text supplied where a number is required is a type error. The comparison with 0 in this example already raises TypeError for text. A class can also check a type explicitly with isinstance when it needs a clearer message.

Write messages that name the rule, such as "width must be positive". A message saying only "bad input" leaves the caller guessing which value needs repair.

Let calling code handle recovery

while True:
    try:
        width = float(input("Width: "))
        room = Rectangle(width, 3)
        break
    except ValueError as error:
        print("Try again:", error)

Entering abc fails during float; entering -2 passes conversion but fails in Rectangle. Both raise ValueError, so this loop handles both. The class states its data rule, while the calling code decides to ask again.

Printing a warning inside __init__ does not reject the call. If execution continues, the program can receive an invalid object and fail later when using it. Raising an exception stops the unsuccessful setup where the problem occurs.

Clean data deliberately and maintain the rule

A documented cleanup can be useful. self.name = name.strip() removes surrounding spaces; validate the cleaned name if blank names are forbidden. self.items = list(items) makes a separate outer list, so appending to the caller's list does not append to this one. Changing an invalid width to its absolute value would change the caller's meaning, so it needs an explicit design rule.

Initialization checks run at creation time. Plain assignment such as r.width = -5 still bypasses them later. Methods that change a width must check it again. A property can place a check on attribute assignment itself, allowing the same rule to run during setup and later updates.

An instance method is a function defined inside a class that works with the object passed as self. The object supplies its stored data; extra parameters supply any additional information needed for the action.

Read attributes through self

Add these methods inside the validated Rectangle class, at the same indentation level as __init__:

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

    def is_square(self):
        return self.width == self.height

With r = Rectangle(3, 4), r.area() returns 12, r.perimeter() returns 14, and r.is_square() returns False. Each method reads the same object's attributes. A second rectangle uses the same method definitions with its own width and height.

Inside a method, self.width names an attribute. A bare width names a local or other accessible variable; Python does not automatically search the current object for it. If no such variable exists, return width * height raises NameError. Writing self. makes the intended data owner explicit.

Follow the call

For this class, r.area() works like Rectangle.area(r). Python finds the function on the class and supplies r as its first argument. A method reference such as r.area is a bound method: it remembers the function and this rectangle. Adding () performs the call.

If a method is defined as def resize(self, factor), call it as r.resize(2). r fills self, and 2 fills factor. You do not pass r again. If an instance method is accidentally written as def area():, a call on r raises TypeError because Python still supplies the object to a function that accepts no arguments.

One method can use another through self:

    def double_area(self):
        return self.area() * 2

Here self.area() calculates using the same rectangle. Leaving out self. would ask for a separate function called area, not the object's method.

Return results for the caller

A calculation method should normally return its result. Returning gives calling code a value to store, combine, test, or display:

r1 = Rectangle(3, 4)
r2 = Rectangle(2, 5)
total = r1.area() + r2.area()
print(total)  # 22

If area only printed its answer, each call would return None. The addition would then fail with TypeError, even though two numbers had appeared on the screen. Printing is an action; returning supplies a value to the expression containing the call.

Use method names that show the task. deposit and resize name actions; is_square and has_room suggest Boolean checks. A method does not need parameters for data already stored on its object. It needs parameters for new inputs, such as a resize factor or a deposit amount.

An object's state is the current set of values in its attributes. An accessor reports on that state. A mutator changes it. A useful mutator checks its inputs and maintains every related attribute, so calling code does not have to coordinate several updates.

Validate the whole change first

Add these methods inside the BankAccount class with its owner, balance, and transaction list:

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("deposit must be positive")
        self.balance += amount
        self.transactions.append(("deposit", amount))

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("withdrawal must be positive")
        if amount > self.balance:
            raise ValueError("insufficient funds")
        self.balance -= amount
        self.transactions.append(("withdraw", amount))

A deposit changes the balance and records the event. A withdrawal checks both the amount's sign and the available balance before subtracting. These checks prevent a rejected withdrawal from changing either the balance or its history.

Starting with BankAccount("Maya", 50), depositing 25 gives 75, and withdrawing 30 gives 45. A later attempt to withdraw 100 raises ValueError; it leaves the balance at 45 and adds no transaction. Putting the subtraction before the funds check would change state even on failure.

Distinguish a change from a returned value

These mutators have no return statement, so they return None. After new_balance = acct.deposit(25), the deposit has happened, but new_balance is None. Read acct.balance afterwards to obtain the updated number.

A class can offer a different style of method that returns a new object. resize suggests changing a rectangle; resized can be chosen for a method that returns a new rectangle and leaves the original alone. Read the method's contract: the name is helpful, but its definition determines the behavior.

Trace shared references

a = BankAccount("Maya", 50)
b = a
b.deposit(10)
print(a.balance)  # 60
print(a is b)     # True

Assignment binds a name to an object; it does not copy that object. Both names reach the account whose balance changed. Passing a to a function also passes access to that object. A function calling account.withdraw(5) can therefore change the account seen by its caller.

For an independent account with the same owner and balance, create BankAccount(a.owner, a.balance). That constructor also supplies a fresh, empty history. It is a new account, not a complete historical copy.

copy.copy(a) creates a new outer object but keeps references to the same inner objects, including the transaction list. copy.deepcopy(a) copies nested objects too. When independence matters, check the objects inside the attributes as well as the outer instance.

Directly assigning acct.balance = -500 skips the checks in the two methods. Internal attribute conventions and properties help make the intended update path clear and keep validation close to state changes.

Calling code needs a clear way to read and change an object. Encapsulation keeps its data rules with the methods that manage them. Python uses conventions and properties to express that interface.

Mark internal storage

A leading underscore in _balance signals an internal attribute. Callers should use the account's methods, but Python still permits direct access. There is no private keyword that locks the value away.

A name such as __balance, with two leading underscores and no double trailing underscores, triggers name mangling. Inside class Acc, self.__balance is stored under _Acc__balance. Outside, obj.__balance fails, but obj._Acc__balance can still work. Mangling prevents name clashes; it does not secure sensitive data.

Run a method through attribute syntax

A property makes a method run when an attribute is read. The @property line is a decorator: it changes how Python exposes the method. A property without a setter permits reading but rejects assignment.

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance

    @property
    def balance(self):
        return self._balance

After acct = Account("Maya", 50), read acct.balance with no parentheses. Assigning acct.balance = 10 raises AttributeError because this property has no setter. A deposit method inside the class could update _balance after its checks.

Check assignment with a setter

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

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not 0 <= value <= 100:
            raise ValueError("score must be between 0 and 100")
        self._score = value

The getter and setter share the name score; the stored value uses _score. On creation, self.score = score runs the setter.

For s = Student("Ana", 88), assigning s.score = 92 stores 92. Assigning s.score = -1 raises ValueError before storage, so the score stays 92. Student("Ana", 105) fails during initialization.

Inside the setter, self.score = value would call the setter again, repeating until RecursionError. The getter has the same risk if it returns self.score. Use the separate storage name _score in both bodies.

Compute values when they are read

A property can calculate a value from other attributes:

    @property
    def area(self):
        return self.width * self.height

Placed inside a rectangle class, this permits r.area. For width 3 and height 4, the value is 12. Changing the width to 5 makes the next read return 20. Storing an area once during initialization would leave an old value behind after a width change.

Start with a plain attribute when simple storage meets the need.

An object is easier to inspect when it can describe its own data. Special methods let Python request that description through familiar actions such as print, str, and repr. Their names start and end with two underscores, often called dunder names.

Choose text for two audiences

__str__ supplies readable text for a program's users. __repr__ supplies a precise description for programmers. Both return strings; neither should print its result as a substitute for returning it.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(p)        # (3, 4)
print(repr(p))  # Point(3, 4)

str(p) returns the string "(3, 4)". repr(p) returns "Point(3, 4)". When possible, a representation resembles a class call that would recreate the value. It still is text: calling repr does not itself create another point.

Without a custom representation, a plain instance typically displays a class name and an address-like identifier. That helps distinguish objects but does not show their useful data. You rarely call these special methods directly; define them once and use Python's ordinary display operations.

Predict what a container displays

With the class above, print([Point(3, 4), Point(0, 0)]) shows [Point(3, 4), Point(0, 0)]. The list uses the representations of its elements, even though each element also has __str__.

If you define __repr__ alone, the default __str__ uses it too. Defining __str__ alone does not change repr or container displays. When adding just one display method, __repr__ therefore serves more inspection contexts.

Make string fields unambiguous

For a book that already stores title, author, and year, these methods give different useful views:

    def __str__(self):
        return f"{self.title} by {self.author} ({self.year})"

    def __repr__(self):
        return f"Book({self.title!r}, {self.author!r}, {self.year})"

For the book with title "Dune", author "Frank Herbert", and year 1965, the first method gives "Dune by Frank Herbert (1965)". The second gives "Book('Dune', 'Frank Herbert', 1965)". !r asks for the string fields' representations, including quotes.

A body containing only print(self.x) returns None, so str(p) fails with TypeError. Returning an integer fails too. Build the required text, then return that string.

Special methods connect a class to operators and built-in functions. Define only operations with a clear meaning for that type: adding vectors is understandable; adding a player to a team is clearer as team.add_player(player).

Compare values and keep hashes safe

Two separate plain instances compare unequal by default. Add value equality to a point class with:

    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented
        return self.x == other.x and self.y == other.y

Now two points at (3, 4) compare equal even though their identities differ. in, count, index, and remove on lists can find such equal values. The usual != result follows from __eq__.

NotImplemented is a return value that lets Python try the other operand or a fallback. It is not an exception to raise. When neither operand supports value equality, == falls back to identity; a point and the string "3,4" compare unequal.

Defining __eq__ without __hash__ makes instances unhashable. They cannot then be set members or dictionary keys. Equal objects must have equal hashes, and a key's hash must stay stable. If the compared attributes never change, a matching hash can return hash((self.x, self.y)). Keep mutable value objects unhashable when their equality fields can change.

Define an ordering

__lt__ supplies <. A student class can compare scores with return self.score < other.score. Scores 88, 72, and 95 then sort into 72, 88, 95. min chooses the lowest; max chooses the highest by using > and its reflected < comparison.

With only __lt__, a > b can use b < a. Python does not infer <= or >= from that definition; those need their own methods. If an order is useful only for one task, pass a key function instead:

def by_score(student):
    return student.score

ordered = sorted(students, key=by_score)

Return new results from arithmetic

Inside a vector class with x and y attributes:

    def __add__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(self.x + other.x, self.y + other.y)

    def __mul__(self, factor):
        if not isinstance(factor, (int, float)):
            return NotImplemented
        return Vector(self.x * factor, self.y * factor)

    def __rmul__(self, factor):
        return self * factor

Vector(1, 2) + Vector(3, 4) produces a new vector (4, 6). Multiplying the first vector by 3 produces (3, 6), leaving it unchanged. __mul__ handles the vector on the left; __rmul__ supports a number on the left. Python does not assume the two orders mean the same thing.

Supply a meaningful length

For a playlist storing self.songs, define __len__ to return len(self.songs). The result must be a nonnegative integer. len(playlist) then counts songs. In this class, length zero also makes if playlist: false; a custom __bool__ would take priority over length when testing truth.

An object's attributes can refer to other objects. A cart holds items, a library holds books, and a course holds students. Composition builds a larger object from smaller ones through this has-a relationship.

Give each object its own responsibility

class Item:
    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price
        self.quantity = quantity

    def subtotal(self):
        return self.price * self.quantity

class ShoppingCart:
    def __init__(self):
        self.items = []

    def add(self, item):
        if not isinstance(item, Item):
            raise TypeError("a cart holds Item objects")
        self.items.append(item)

    def total(self):
        total = 0
        for item in self.items:
            total += item.subtotal()
        return total

The cart owns a separate list created during initialization. Its add method checks the incoming object before appending it. cart.add("pen") raises TypeError instead of storing text that will fail when a subtotal is requested.

Create the items before or during the calls:

cart = ShoppingCart()
cart.add(Item("notebook", 2.50, 4))
cart.add(Item("pen", 1.25, 3))
print(cart.total())         # 13.75
print(cart.items[0].name)   # notebook

The subtotals are 10.0 and 3.75; the cart adds them to get 13.75. The chain cart.items[0].name first reaches the cart's list, then its first object, then that object's name.

Delegate work to the object that knows it

The cart asks each item for subtotal(). This is delegation: one object calls another object's method for part of a task. If a bulk discount changes how a subtotal is calculated, that rule belongs in Item.subtotal. The cart can keep adding the returned subtotals without duplicating price rules.

Passing Item instead of Item(...) passes the class, not a purchased item. The type check rejects that class object. Keep all additions on the checked path; direct access to cart.items.append(...) would bypass add.

Search for an object

Add this method inside ShoppingCart:

    def find(self, name):
        for item in self.items:
            if item.name == name:
                return item
        return None

The first match returns the existing item. No match returns None. Check found is None before using found.name; None has no such attribute. A __len__ method returning len(self.items) could also make len(cart) count stored item objects, while __str__ could join item lines into a receipt.

Track references inside collections

A list stores references, so placing the same item in two carts does not copy it. Updating that item's price affects the next total calculated by both carts. Separate cart lists prevent accidental list sharing, but they do not make the objects inside independent. Create separate items when the carts must hold independent data.

Objects can be method arguments and return values just like numbers or strings. Track the receiver, arguments, and result separately: a method may change an existing object, return a new object, or simply report a value.

Use another object as input

Inside a point class with x and y, a method can read both points:

    def midpoint(self, other):
        return Point((self.x + other.x) / 2,
                     (self.y + other.y) / 2)

For p = Point(3, 4) and q = Point(1, 0), middle = p.midpoint(q) creates a third point at (2.0, 2.0). During the call, self refers to p and other refers to q. The method calculates coordinates and constructs a new point; it assigns nothing to either original.

With import math, a distance method can return math.hypot(self.x - other.x, self.y - other.y). Point(0, 0).distance_to(Point(3, 4)) then gives 5.0. This call returns a number, while midpoint returns an object.

Let each receiver manage its changes

Inside an account class with checked withdraw and deposit methods:

    def transfer_to(self, other, amount):
        self.withdraw(amount)
        other.deposit(amount)

If Maya has 100 and Leo has 20, maya.transfer_to(leo, 30) first withdraws from Maya, leaving 70, then deposits into Leo, giving 50. In the first call, self is Maya's account. In the deposit call, its own self is Leo's account.

A later transfer of 500 fails in withdraw because Maya has only 70. Execution stops before deposit, so both balances keep their previous values. The order of the calls matters. Python does not undo an earlier state change if a later call raises; this short method depends on the receiver's deposit being able to accept the amount.

Calling other.deposit(amount) runs the receiving account's rules in one place. Directly changing other.balance would skip them.

Trace the objects, not just the variable names

Draw each instance as a box containing its attributes. Draw an arrow from each variable to its box. At a call, identify which box receives self and which boxes are passed as arguments. Update the affected box after each successful state-changing line. Two arrows to one box mean a change through either name reaches the same object.

A plain function can also work across objects. total_balance(accounts) can loop over accounts and add their balances. That whole-list calculation need not belong to a single account.

Represent an absent relationship

A book can start with self.borrower = None, then later store a member object. Before reading a member attribute, check the relationship:

if book.borrower is not None:
    print(book.borrower.name)

Otherwise book.borrower.name fails when the book has no borrower. Classes can be defined above a main() function that creates and connects the objects. Calling main() under if __name__ == "__main__": keeps those actions from running when the classes are imported.

A class earns its place when related data and repeated operations become easier to understand together. You do not need to turn every function or record into a class. Choose the structure that makes the program's responsibilities clear.

Look for data and behavior that travel together

Classes help when several functions keep accepting the same group of values, many records share a layout, and state changes must follow common rules. Several accounts that all support deposits and withdrawals are a good fit. A single calculation can stay a function. A fixed, read-only record can stay a tuple or dictionary.

A class with only setup and a one-time operation often adds more ceremony than useful structure. Ask what one instance represents and which repeated actions belong to it. If you cannot answer those questions simply, reconsider the design.

Move an operation next to its data

A dictionary-based account might begin as:

account = {"owner": "Maya", "balance": 50}

def deposit(account, amount):
    account["balance"] += amount

The class version can place the same operation beside its state and its rules:

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

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("deposit must be positive")
        self.balance += amount

    def __repr__(self):
        return f"BankAccount({self.owner!r}, {self.balance})"

After acct = BankAccount("Maya", 50) and acct.deposit(25), its representation is BankAccount('Maya', 75). The positive-deposit rule now runs whenever callers use that method. Reading account["balence"] would raise KeyError; reading acct.balence raises AttributeError. A class does not eliminate spelling mistakes, but it gives the data and its operations a named home.

Plan from a short description

For “A library lends books to members. A member can borrow at most 3 books,” nouns suggest Book, Member, and Library. Verbs suggest checkout and return methods.

1. List what each instance knows: a book's title, author, and borrower; a member's name and borrowed books; a library's books and members.
2. Identify rules: a book cannot already be on loan, and a member cannot exceed MAX_LOANS = 3.
3. Put each rule in the operation that changes the relationship, such as Library.check_out(book, member).
4. Write initialization and a useful representation, then add and test one action at a time.

Different titles need different instances of Book, not separate classes named after each title. Use singular nouns for individual objects, such as Book; name a collection for the collection, such as Library. Keep each class's job clear enough to describe in one sentence.

Test observable behavior

acct = BankAccount("Maya", 50)
acct.deposit(25)
assert acct.balance == 75

assert raises AssertionError if its condition is false. Test rejected actions too: catch the expected exception and verify that the state did not change. Use explicit validation with raise for caller input; assertions are checks during development and can be disabled when Python runs with optimization.