Classes and Objects

A class defines a kind of object

Python programs work with objects: values that have an identity, a type, and a value. A class statement is one way to define a new user-facing type. Its indented suite runs when Python executes the class statement, producing a class object. In beginner code, the useful mental model is that the class provides a shared definition, while each call to the class creates a separate instance.

Here is a minimal class:

class Badge:
    pass

first = Badge()
second = Badge()

Badge names the class. first and second are two different instances made by calling it. The empty pass is only a placeholder; practical classes usually define initialization and methods. A class is not a single record of data. It describes operations and attributes that instances can use. This is narrower than a full object-oriented-design discussion: the immediate question is simply which object owns a particular value or action.

Instance attributes and initialization

An attribute is a value reached with dotted notation, such as book.title. Classes often create instance attributes in a method named __init__. Python calls that method as part of constructing an instance. By convention, its first parameter is named self. In a call such as Book("The Left Hand of Darkness"), Python supplies the new instance as self; the programmer supplies the title argument.

class Book:
    def __init__(self, title):
        self.title = title

first = Book("The Left Hand of Darkness")
second = Book("Kindred")
print(first.title)
print(second.title)

This prints the two different titles. The assignment self.title = title stores an attribute on the particular object received as self. It does not create one universal title for every Book. Later, first.title = "A Wizard of Earthsea" changes only first's attribute. That per-instance separation is why objects are useful for representing several similar things with different state.

Methods, self, and attribute lookup

A method is a function defined in a class body. Accessing it through an instance creates the normal method-call connection: first.describe() uses first as the first argument. self is not a special keyword; it is the conventional parameter name that makes this relationship readable. Inside a method, self.title means “the title on the instance that received this call.”

class Book:
    def __init__(self, title):
        self.title = title

    def describe(self):
        return f"Reading: {self.title}"

first = Book("Kindred")
print(first.describe())

The result is Reading: Kindred. Defining describe in the class gives each Book instance the same behavior, but the behavior reads each instance's own data. Do not write Book.describe() as a substitute for first.describe() here: the method needs an instance for its self parameter. This lesson's nearby functions and return-values topics own general function syntax and return mechanics; here they are used only to show a method attached to a class.

Class attributes are shared defaults

A name assigned directly in the class suite is a class attribute. Instances can read it when they do not have an instance attribute with the same name. That makes class attributes suitable for a shared constant or default. An instance assignment with the same name creates an instance attribute that shadows the class attribute for that one object.

class Meter:
    unit = "km"
    def __init__(self, value):
        self.value = value
    def label(self):
        return f"{self.value} {self.unit}"

a = Meter(3)
b = Meter(7)
Meter.unit = "mi"
a.unit = "m"
print(a.label())
print(b.label())

The output is 3 m and 7 mi. Changing Meter.unit changes the class value that b finds. Assigning a.unit gives a its own value, so it no longer uses the class value. A critical caution follows: do not use a mutable object such as [] as a class attribute when each instance needs a separate collection. Put self.items = [] in __init__ instead; otherwise instances can observe and modify the same list.