Instance methods in Python - Step-by-Step Execution

Concept Flow - Instance methods

Create object from class

↓

Call instance method on object

↓

Method receives 'self' (the object)

↓

Method uses object's data

↓

Method returns or changes object state

↓

End

This flow shows how an instance method is called on an object, receives the object itself as 'self', and uses or changes the object's data.

Execution Sample

Python

class Dog:
    def __init__(self, name):
        self.name = name
    def bark(self):
        return f"{self.name} says Woof!"

Defines a Dog class with an instance method bark that uses the object's name.

Execution Table

Step	Action	Evaluation	Result
1	Create Dog object with name 'Buddy'	dog1 = Dog('Buddy')	Object dog1 with dog1.name = 'Buddy'
2	Call dog1.bark()	dog1.bark()	Calls bark method with self = dog1
3	Inside bark: access self.name	self.name	'Buddy'
4	Return formatted string	f"{self.name} says Woof!"	'Buddy says Woof!'
5	Print result	print(dog1.bark())	Buddy says Woof!

💡 Method returns string and execution ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 4
dog1	None	Dog object with name='Buddy'	Same object	Same object
self.name	N/A	N/A	'Buddy'	'Buddy'
Return value	N/A	N/A	N/A	'Buddy says Woof!'

Key Moments - 2 Insights

Why do we use 'self' as the first parameter in instance methods?

Because 'self' represents the object calling the method, allowing access to its data. See execution_table step 3 where self.name accesses the object's name.

Can we call an instance method without creating an object first?

No, instance methods need an object to work on. In step 1, we create dog1 before calling bark in step 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of self.name inside the bark method?

A 'dog1'

B 'Buddy'

C 'Woof!'

D None

💡 Hint

Check step 3 in the execution_table where self.name is evaluated.

At which step does the bark method return the string 'Buddy says Woof!'?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the execution_table row where the formatted string is returned.

If we create another Dog object with name 'Max', what will dog2.bark() return?

A 'dog2 says Woof!'

B 'Buddy says Woof!'

C 'Max says Woof!'

D Error, because dog2 is not defined

💡 Hint

Instance methods use the object's own data, see variable_tracker for dog1 and self.name.

Concept Snapshot

Instance methods are functions inside a class that work with the object itself.
They always take 'self' as the first parameter.
Use 'self' to access or change object data.
Call them on an object: obj.method().
They can return values or change the object.

Full Transcript

Instance methods belong to objects created from classes. When you create an object, you can call its instance methods. These methods receive the object itself as the first parameter, usually named 'self'. This lets the method access or change the object's data. For example, a Dog class can have a bark method that uses the dog's name stored in self.name. When you call dog1.bark(), the method returns a string using dog1's name. You must create an object before calling its instance methods. This way, each object can have its own data and behavior.

Practice

1. What is the purpose of the self parameter in an instance method?

easy

A. It refers to the specific object calling the method.

B. It is used to define a static method.

C. It is a keyword to create a new object.

D. It stores the return value of the method.

Solution

1. Step 1: Understand what self represents

   self is a reference to the current object that calls the method, allowing access to its attributes and other methods.

2. Step 2: Differentiate from other options

   Static methods, object creation, and return values are unrelated concepts, which are not the role of self.

3. Final Answer:

   It refers to the specific object calling the method. -> Option A

4. Quick Check:

   self = current object [OK]

Hint: Remember: self means 'this object' inside methods [OK]

Common Mistakes:

• Thinking self is a keyword, not a parameter
• Confusing self with class or static methods
• Assuming self is optional in instance methods

2. Which of the following is the correct way to define an instance method inside a Python class?

easy

A. def method_name():

B. def method_name(*args):

C. def method_name(cls):

D. def method_name(self):

Solution

1. Step 1: Recall instance method syntax

   Instance methods must have self as the first parameter to access the object's data.

2. Step 2: Check each option

   def method_name(): misses self, def method_name(cls): uses cls which is for class methods, and def method_name(*args): uses a generic parameter which is not standard for instance methods.

3. Final Answer:

   def method_name(self): -> Option D

4. Quick Check:

   Instance method = first param self [OK]

Hint: Instance methods always start with self parameter [OK]

Common Mistakes:

• Omitting self in method definition
• Using cls instead of self for instance methods
• Using no parameters or *args incorrectly

3. What will be the output of this code?

class Dog:
    def __init__(self, name):
        self.name = name
    def bark(self):
        return f"{self.name} says Woof!"

my_dog = Dog('Buddy')
print(my_dog.bark())

medium

A. Woof!

B. Buddy says Woof!

C. my_dog says Woof!

D. Error: missing self parameter

Solution

1. Step 1: Understand object creation and method call

   The object my_dog is created with name 'Buddy'. Calling bark() uses self.name which is 'Buddy'.

2. Step 2: Evaluate the return value

   The method returns the string "Buddy says Woof!" which is printed.

3. Final Answer:

   Buddy says Woof! -> Option B

4. Quick Check:

   Method uses self.name = Buddy [OK]

Hint: Instance methods use self to access object data [OK]

Common Mistakes:

• Ignoring self and expecting just 'Woof!'
• Confusing variable name with object name
• Assuming method returns nothing

4. Find the error in this code:

class Car:
    def __init__(self, model):
        self.model = model
    def show_model():
        print(f"Model: {self.model}")

car = Car('Tesla')
car.show_model()

medium

A. Cannot create object without arguments

B. Wrong attribute name used

C. Missing self parameter in show_model method

D. print statement syntax error

Solution

1. Step 1: Check method definition

   The method show_model is missing the self parameter, so it cannot access instance attributes.

2. Step 2: Understand the error cause

   Calling car.show_model() passes the object automatically, but method lacks self to receive it, causing a TypeError.

3. Final Answer:

   Missing self parameter in show_model method -> Option C

4. Quick Check:

   Instance methods need self parameter [OK]

Hint: Always include self as first parameter in instance methods [OK]

Common Mistakes:

• Forgetting self in method definition
• Trying to access self without parameter
• Confusing class and instance methods

5. You want to create a class Counter that counts how many times its method increment is called on each object separately. Which code correctly implements this behavior?

hard

A. class Counter:
def __init__(self):
self.count = 0
def increment(self):
self.count += 1
def get_count(self):
return self.count

B. class Counter:
count = 0
def increment(self):
Counter.count += 1
def get_count(self):
return Counter.count

C. class Counter:
def __init__(self):
self.count = 0
def increment():
self.count += 1
def get_count(self):
return self.count

D. class Counter:
def __init__(self):
self.count = 0
def increment(self):
count += 1
def get_count(self):
return self.count

Solution

1. Step 1: Understand instance vs class variables

   Instance variables (self.count) ensure each object tracks its own count separately. Methods must accept self and update self.count.

2. Step 2: Eliminate incorrect approaches

   Class variables are shared across all instances. Missing self parameter in methods causes TypeError. Updating a local variable doesn't affect the instance attribute.

3. Final Answer:

   class Counter: def __init__(self): self.count = 0 def increment(self): self.count += 1 def get_count(self): return self.count -> Option A

4. Quick Check:

   Instance variables + self = separate counts [OK]

Hint: Use self.variable for per-object data, not class variables [OK]

Common Mistakes:

• Using class variables for per-object data
• Forgetting self in method parameters
• Incrementing local variables instead of instance attributes