Difference between method types in Python - Visual Side-by-Side Comparison

Concept Flow - Difference between method types

Call instance.method(obj)

↓

Uses self, accesses instance data

↓

Call class.method(cls)

↓

Uses cls, accesses class data

↓

Call static.method()

↓

No self or cls, independent function

Shows how instance, class, and static methods are called and what data they access.

Execution Sample

Python

class Example:
    def instance_method(self):
        return f"Instance method called, self={self}"

    @classmethod
    def class_method(cls):
        return f"Class method called, cls={cls}"

    @staticmethod
    def static_method():
        return "Static method called"

Defines a class with three method types to show their differences.

Execution Table

Step	Call	Method Type	Parameter Passed	Output
1	obj.instance_method()	Instance method	self = obj	Instance method called, self=<Example object>
2	Example.class_method()	Class method	cls = Example	Class method called, cls=<class 'Example'>
3	Example.static_method()	Static method	No parameters	Static method called
4	obj.class_method()	Class method	cls = Example	Class method called, cls=<class 'Example'>
5	obj.static_method()	Static method	No parameters	Static method called
6	Example.instance_method()	Error	Missing self	TypeError: missing 1 required positional argument: 'self'

💡 Step 6 raises error because instance_method requires an instance (self) but called on class.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6
self	N/A	<Example object>	<Example object>	<Example object>	<Example object>	<Example object>	Error
cls	N/A	N/A	<class 'Example'>	<class 'Example'>	<class 'Example'>	<class 'Example'>	N/A

Key Moments - 3 Insights

Why does calling instance_method on the class (Example.instance_method()) cause an error?

Because instance_method expects an instance as the first argument (self), but calling it on the class does not provide one. See execution_table step 6.

How can class_method be called from an instance?

Class methods receive the class as the first argument (cls), so calling obj.class_method() works and passes the class automatically. See execution_table step 4.

Do static methods receive any automatic arguments?

No, static methods do not receive self or cls automatically. They behave like regular functions inside the class namespace. See execution_table steps 3 and 5.

Visual Quiz - 3 Questions

Look at the execution_table, what parameter is passed to class_method when called as obj.class_method() at step 4?

A cls (the class)

B self (the instance)

C No parameters

D Both self and cls

💡 Hint

Check the 'Parameter Passed' column in execution_table row for step 4.

At which step does calling a method cause an error due to missing parameters?

A Step 2

B Step 4

C Step 6

D Step 3

💡 Hint

Look for 'Error' in the 'Method Type' column in execution_table.

If static_method needed to access instance data, what would happen?

A It would work normally

B It would raise an error because no self is passed

C It would receive cls automatically

D It would convert to a class method

💡 Hint

Static methods do not get self or cls automatically, see key_moments about static methods.

Concept Snapshot

Instance method: first parameter is self (instance), accesses instance data.
Class method: decorated with @classmethod, first parameter is cls (class), accesses class data.
Static method: decorated with @staticmethod, no automatic parameters, behaves like a normal function.
Instance methods require an instance to be called.
Class and static methods can be called on class or instance.
Calling instance method on class without instance causes error.

Full Transcript

This lesson shows the difference between instance, class, and static methods in Python. Instance methods receive the instance as the first parameter called self and can access instance data. Class methods are decorated with @classmethod and receive the class as the first parameter called cls, allowing access to class data. Static methods are decorated with @staticmethod and do not receive any automatic parameters; they behave like regular functions inside the class. The execution table shows calls to each method type and what parameters are passed. Calling an instance method on the class without an instance causes an error because self is missing. Class methods can be called from both the class and instances, receiving the class automatically. Static methods can also be called from both but do not receive self or cls. The variable tracker shows how self and cls change during calls. Key moments clarify common confusions about method calls and parameters. The visual quiz tests understanding of parameters passed and errors raised during calls.

Practice

1. Which method type in Python automatically receives the instance as the first argument named self?

easy

A. Instance method

B. Class method

C. Static method

D. Global function

Solution

1. Step 1: Understand method types

   Instance methods receive the instance as the first argument, usually named self.

2. Step 2: Identify method with self

   Class methods receive the class as cls, static methods receive no automatic first argument.

3. Final Answer:

   Instance method -> Option A

4. Quick Check:

   Method with self = Instance method [OK]

Hint: Look for self as first parameter for instance methods [OK]

Common Mistakes:

• Confusing cls with self
• Thinking static methods have self
• Mixing global functions with methods

2. Which decorator is used to define a class method in Python?

easy

A. @classmethod

B. @staticmethod

C. @instance

D. @class

Solution

1. Step 1: Recall Python decorators for methods

   Class methods use the @classmethod decorator to receive the class as the first argument.

2. Step 2: Identify correct decorator

   @staticmethod is for static methods, @instance and @class are invalid decorators.

3. Final Answer:

   @classmethod -> Option A

4. Quick Check:

   Class method decorator = @classmethod [OK]

Hint: Class methods always use @classmethod decorator [OK]

Common Mistakes:

• Using @staticmethod for class methods
• Assuming @instance is a valid decorator
• Confusing decorator names

3. What is the output of this code?

class MyClass:
    @staticmethod
    def greet():
        return 'Hello'

print(MyClass.greet())

medium

A. AttributeError

B. TypeError

C. None

D. 'Hello'

Solution

1. Step 1: Understand static method behavior

   Static methods do not require an instance or class argument and can be called directly on the class.

2. Step 2: Analyze the code output

   The static method greet returns the string 'Hello', so print(MyClass.greet()) outputs 'Hello'.

3. Final Answer:

   'Hello' -> Option D

4. Quick Check:

   Static method call returns 'Hello' [OK]

Hint: Static methods can be called on class without arguments [OK]

Common Mistakes:

• Expecting a TypeError for missing self
• Confusing static with instance method call
• Thinking static methods return None by default

4. Identify the error in this code:

class Example:
    @classmethod
    def show(cls):
        print(cls.value)

Example.show()

medium

A. Missing @staticmethod decorator

B. Method should use 'self' instead of 'cls'

C. Missing class attribute 'value'

D. Syntax error in method definition

Solution

1. Step 1: Check class method usage

   The method show is a class method and tries to print cls.value.

2. Step 2: Verify class attribute existence

   The class Example does not define value, so accessing cls.value causes an AttributeError at runtime.

3. Final Answer:

   Missing class attribute 'value' -> Option C

4. Quick Check:

   Class attribute missing causes error [OK]

Hint: Class methods need class attributes to access via cls [OK]

Common Mistakes:

• Confusing instance and class attributes
• Thinking @staticmethod fixes attribute errors
• Using 'self' in class methods incorrectly

5. You want a method that can be called on the class or instance but does NOT access instance or class data. Which method type should you use?

hard

A. Class method

B. Static method

C. Instance method

D. Property method

Solution

1. Step 1: Understand method access types

   Instance methods access instance data via self, class methods access class data via cls.

2. Step 2: Identify method without data access

   Static methods do not access instance or class data and can be called on both class and instance.

3. Final Answer:

   Static method -> Option B

4. Quick Check:

   No data access = Static method [OK]

Hint: No data access means use static method [OK]

Common Mistakes:

• Choosing instance or class method incorrectly
• Confusing property methods with static methods
• Assuming static methods access class data