Services
Technology Web App Development Mobile App Development Windows App Development Database Development UI/UX Development Cloud Development SEO Digital Marketing Guest Posting Content Writing Artificial Intelligence Data Science ERP Development CRM Development CMS Development LMS Development Business Listing Blockchain Technology Startup Promotion AI Tools Integration
Products
Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller
Developer
Article Blog Forum Interview Beginner News Startup Quiz
Users
Career
Apply Job Internship
Pricing
Login Sign Up Get a Quote

forum

Home Forums What’s the difference between @staticmethod, @classmethod, and instance methods? – MindStick
Ask Question

1 Answers

Anubhav Sharma
Anubhav Sharma 28 Aug 2025
Report Abuse

1. Instance Method (default)

  • Defined with self as the first parameter.
  • Operates on an instance of the class.
  • Can access instance attributes (self.attr) and class attributes.
  • Called on an object.
class Example:
    def instance_method(self):
        return f"Called instance_method from {self}"

e = Example()
print(e.instance_method())   #works
# Output: Called instance_method from <__main__.Example object at 0x...>

Use when you need to work with data tied to a specific object.

2. Class Method

  • Defined with @classmethod decorator.
  • Takes cls (class itself) as the first parameter.
  • Cannot access instance-specific data (self), but can modify class-level data.
  • Can be called on both the class and an instance.
class Example:
    count = 0
    
    @classmethod
    def increment_count(cls):
        cls.count += 1
        return cls.count

print(Example.increment_count())  # 1
print(Example.increment_count())  # 2

Use when you need methods that work with class-level state (shared across all instances), or when you want alternate constructors.

3. Static Method

  • Defined with @staticmethod.
  • Doesn’t take self or cls.
  • Behaves like a regular function inside a class’s namespace.
  • Cannot access instance attributes or class attributes directly.
class Example:
    @staticmethod
    def add(a, b):
        return a + b

print(Example.add(5, 3))   # 8

Use when the method doesn’t need instance (self) or class (cls) data, but logically belongs to the class.

Quick Comparison

Type First Arg Can Access Instance (self) Can Access Class (cls) Typical Use
Instance Method self Yes Yes Work with object state
Class Method cls No Yes Work with class state, alternative constructors
Static Method None No No Utility functions that logically belong to the class

Real-world Analogy

Think of a Bank Account class:

class BankAccount:
    interest_rate = 0.05  # class attribute

    def __init__(self, owner, balance=0):
        self.owner = owner      # instance attribute
        self.balance = balance

    def deposit(self, amount):       # Instance method
        self.balance += amount
        return self.balance

    @classmethod
    def set_interest_rate(cls, rate): # Class method
        cls.interest_rate = rate

    @staticmethod
    def validate_amount(amount):      # Static method
        return amount > 0
        
acc1 = BankAccount("Alice", 1000)
print(acc1.owner, acc1.balance)
# Instance method
acc1.deposit(500)
print(acc1.owner, acc1.balance)

# Class method
BankAccount.set_interest_rate(0.07)
print(BankAccount.interest_rate)

# Static method
print(BankAccount.validate_amount(200))
  • deposit → Needs to update that account’s balance → instance method.
  • set_interest_rate → Affects all accounts (class-level) → class method.
  • validate_amount → Just a check, doesn’t depend on account or bank → static method.

Output - 

Alice 1000
Alice 1500
0.07
True
advertising
Markdown for AI

A clean, structured version of this page for AI assistants and LLMs.

Open .md