Questions: Introduction to Classes

Question 1

A programmer defines a class Dog with an attribute `name`. She then creates two instances: dog1 = Dog('Rex') and dog2 = Dog('Luna'). She later runs dog1.name = 'Max'. What happens to dog2.name?

• A. dog2.name also changes to 'Max' because both objects share the same class
• B. dog2.name remains 'Luna' because each instance has its own independent state
• C. dog2.name becomes None because the class definition was modified
• D. An error is raised because you cannot modify one instance without modifying all

Answer: (B)

Each instance created from a class has its own independent copy of its attributes. The class is a blueprint — when you instantiate it twice, you get two separate objects with separate memory for their attributes. Modifying dog1.name changes only dog1's copy; dog2 is completely unaffected. This independence is a fundamental property of object-oriented design and is why creating 1,000 Dog objects from the same class results in 1,000 independent objects, not 1,000 references to the same data.

Question 2

What does `self` refer to inside a class method, and why is it necessary?

• A. It refers to the class itself, allowing methods to access the class definition
• B. It is a keyword that marks the method as belonging to the class rather than being a standalone function
• C. It refers to the specific instance the method was called on, connecting the method to that object's data
• D. It refers to the parent class, enabling inheritance from built-in types

Answer: (C)

When you call my_account.deposit(50), Python automatically passes my_account as the first argument to the method — this is what `self` receives. Without `self`, a method would have no way to know *which* object it should act on. Writing `self.balance += amount` means 'modify this particular object's balance attribute,' not some global variable. Every instance method needs `self` as its first parameter for this reason. The class definition is shared, but `self` gives each method call access to the specific instance's unique data.

Question 3

Defining a class in Python immediately creates an object in memory that you can use.

• T. True
• F. False

Answer: False

Defining a class only creates the blueprint — it does not create any objects. No memory is allocated for instance attributes, and no code inside __init__ is executed. An object is only created when you instantiate the class by calling it like a function (e.g., my_dog = Dog('Rex')). This distinction matters: you can define class BankAccount without any accounts existing yet. Only the act of calling BankAccount() — instantiation — produces an actual object with its own memory and state.

Question 4

Two different instances created from the same class can have different values for their attributes.

• T. True
• F. False

Answer: True

This is precisely the point of classes: one blueprint, many independent objects. The class defines which attributes will exist, but each instance gets its own copy of those attributes with its own values. dog1.name = 'Rex' and dog2.name = 'Luna' are two separate attribute slots in two separate objects in memory. The class is like the cookie cutter (always the same shape), while instances are like individual cookies (each can have different frosting).

Question 5

Why does every instance method in Python require `self` as its first parameter? What would break if `self` were omitted?

Model answer: Without `self`, a method has no reference to the specific instance it is operating on. It cannot access or modify that instance's attributes. If you wrote `def deposit(amount): balance += amount`, it would fail because `balance` is not defined as a local variable — it lives on the instance. `self.balance` is the correct reference, and `self` is how the method receives that instance. Without it, Python would treat the method like a plain function with no connection to any object's data.

The need for explicit `self` is a design choice Python made (many other OOP languages implicitly pass `this`). It makes the connection between method and instance visible and explicit. When Python calls my_account.deposit(50), it translates this internally to BankAccount.deposit(my_account, 50) — the instance is always the first argument, and `self` is the parameter that receives it. Omitting `self` would cause the method to receive its first real argument (like `amount`) as `self`, producing confusing errors, and the method would have no way to access the instance's attributes.