Accessing Object Attributes and Methods

One Class, Many Objects

A class can serve as a template for creating many distinct objects. The important step beyond creating one object is creating several instances that belong to the same class but hold different data. For example, two PartyAnimal objects can begin with different names. They share the class definition, but each object has its own state.

Following Constructor Data

A constructor receives self and any additional parameters supplied by the caller. The self parameter refers to the object instance being created. An additional parameter carries a value chosen for that particular object. Inside the constructor, an assignment such as self.name = nam copies the parameter value into the name attribute of the object represented by self.

The flow is specific to the object being created: the caller supplies a value, the constructor receives it through its parameter, and self.attribute stores it on that object. The assignment does not describe a single shared name for every instance; it stores the value in the current object's attribute.

Constructing Distinct Instances

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

s = PartyAnimal('Sally')
j = PartyAnimal('Jim')

The first construction passes 'Sally' to the constructor. During that construction, self refers to the new object assigned to s, so that object's x becomes 0 and its name becomes 'Sally'. The second construction creates a completely new object assigned to j. Its x also begins at 0, but its name becomes 'Jim'.

Reading and Changing One Object

An expression such as s.name accesses the name attribute belonging to the object referenced by s. Likewise, j.name accesses the name attribute belonging to the object referenced by j. Because each object maintains independent copies of its attributes, accessing or changing one object's data does not change the other object's corresponding data.

class PartyAnimal: def __init__(self, nam): self.x = 0 self.name = nam def party(self): self.x = self.x + 1 s = PartyAnimal('Sally') j = PartyAnimal('Jim') s.party()

Tracing the Complete Setup

Mistakes with Instance Data

• Treating a constructor parameter as if it automatically became an attribute.

  A parameter is used inside the constructor, while self.name is the attribute that stores the value on the object.

  Fix: Copy the parameter into an instance attribute with an assignment such as self.name = nam.

• Assuming that objects made from the same class share the same attribute values.

  Each object maintains its own independent copies of attributes.

  Fix: Track the object named before the dot. s.x and j.x belong to different instances.

• Thinking that a method call operates on every instance of the class.

  The call is made through s, so the method uses self for the object represented by s.

  Fix: Identify the instance used for the call and follow that instance's attributes.

Practice the Data Flow

Key Takeaways

1. A class can be used as a template for creating multiple distinct objects.
2. Constructor parameters beyond self let each object receive unique initial values.
3. An assignment such as self.name = nam stores a constructor parameter in the current object's attribute.
4. Each object maintains independent copies of its attributes.
5. A method call made through one object reads or changes that object's attributes rather than the attributes of every instance.