Understanding self and Instance Attributes

A New Category of Object

Python's class keyword does more than organize related code. It creates a new type. Python already provides built-in types such as int and str, but a class lets you introduce another category of object that Python recognizes as its own type.

Following self to an Instance

An instance attribute is data associated with one particular object. In the PartyAnimal example described in the source, each instance has an x attribute, and the party method increments that instance's x value. The name self identifies the particular instance involved when the method works with that attribute. Therefore, a method call on an points to an's x, while a method call on a second instance points to that second instance's x.

class PartyAnimal: def __init__(self): self.x = 0 def party(self): self.x = self.x + 1 print("party", self.x) an = PartyAnimal() an2 = PartyAnimal() an.party() an2.party()

Reading an Object's Type

The type() function reports the class of an object. For a built-in value such as 5, type() identifies int. For a string such as 'Alice', it identifies str. For the instance an created from PartyAnimal, it identifies PartyAnimal. This confirms that the class is a real type recognized by Python.

class PartyAnimal:
    def __init__(self):
        self.x = 0

an = PartyAnimal()

print(type(5))
print(type("Alice"))
print(type(an))
print(type(an.x))

<class 'int'>
<class 'str'>
<class '__main__.PartyAnimal'>
<class 'int'>

Inspecting Attributes with dir

The dir() function lists the attributes and methods available on an object. For a PartyAnimal instance, the listing includes the user-defined x attribute and party method. It also includes special methods that Python automatically provides to every class. The complete listing can be long, so the important skill is to use dir() as an inspection tool: look for the names your class defines, while remembering that the object also has Python-provided members.

class PartyAnimal:
    def __init__(self):
        self.x = 0

    def party(self):
        self.x = self.x + 1

an = PartyAnimal()
print("x" in dir(an))
print("party" in dir(an))

True
True

Mistakes Beginners Make

• Treating a class as only a container for code

  The class keyword creates a new type, and instances created from it are objects of that type.

  Fix: Use type(an) to confirm that the instance has type PartyAnimal.

• Assuming an instance has the type of one of its attributes

  The instance and its attribute are different objects and can have different types.

  Fix: Check them separately with type(an) and type(an.x).

• Assuming two instances share the same instance data

  Separate instances have separate data. The source describes each PartyAnimal instance as having its own x attribute.

  Fix: Track the selected instance through self when a method reads or changes x.

• Expecting dir() to show only names written by the programmer

  dir() lists user-defined attributes and methods as well as special methods Python automatically provides.

  Fix: Use dir() as a complete inventory of available names, not as a copy of only your class body.

Practice the Inspection Tools

The Working Mental Model

1. The class keyword creates a new custom type, not merely a container for code.
2. An instance created from a class is an object of that class's type, just as 5 is an object of type int.
3. self identifies the particular instance whose attributes a method reads or changes.
4. type(object) reports the object's class, while type(object.attribute) reports the attribute's class.
5. dir(object) lists available attributes and methods, including user-defined names and Python-provided special methods.