Python Tutorials

Python Methods : Instance, Class, and Static

8 min read

When you first learn Object-Oriented Programming (OOP) in Python, you learn that functions placed inside a class are called “methods.” However, not all methods operate the same way.

Imagine a bustling restaurant. The waiters take specific orders for individual tables—they interact with the “instances” of customers. The restaurant manager, however, looks at the big picture, setting the overall menu prices for the entire establishment—they interact with the “class” as a whole. Finally, the health inspector checks the kitchen—they don’t care about specific customers or the menu prices; they just perform an independent, isolated task.

In Python, we have exact equivalents for these three roles: Instance Methods, Class Methods, and Static Methods. Knowing when and how to use each of these is the hallmark of a senior-level Python developer.

Instance Methods vs. Class Methods vs. Static Methods

In Python, methods inside a class are categorized by how they access and modify data:

  • Instance Methods: The most common type. They operate on specific object instances and must take self as their first parameter. They can modify both object state and class state.
  • Class Methods: They operate on the class itself, not individual objects. They must take cls as their first parameter and are marked with the @classmethod decorator.
  • Static Methods: They do not operate on the object or the class. They take neither self nor cls as parameters. They are marked with the @staticmethod decorator and behave exactly like regular functions, but are placed inside a class for logical organization.

Syntax & Basic Usage

Let’s look at a minimal, beginner-friendly example of all three methods living side-by-side inside a single class.

class Bakery:
    # A class attribute shared by the whole bakery
    bakery_name = "Python Pastries"

    def __init__(self, cake_flavor):
        # An instance attribute unique to one specific cake
        self.flavor = cake_flavor

    # 1. INSTANCE METHOD (Requires 'self')
    def slice_cake(self):
        print(f"Slicing the {self.flavor} cake.")

    # 2. CLASS METHOD (Requires 'cls' and decorator)
    @classmethod
    def change_bakery_name(cls, new_name):
        cls.bakery_name = new_name
        print(f"The bakery is now called {cls.bakery_name}.")

    # 3. STATIC METHOD (No 'self' or 'cls' required)
    @staticmethod
    def calculate_tax(price, tax_rate):
        total = price + (price * tax_rate)
        print(f"Total price with tax: ${total:.2f}")

# Using the Instance Method
my_cake = Bakery("Chocolate")
my_cake.slice_cake()

# Using the Class Method
Bakery.change_bakery_name("Advanced Python Pastries")

# Using the Static Method
Bakery.calculate_tax(10.00, 0.05)

# Expected Output:
# Slicing the Chocolate cake.
# The bakery is now called Advanced Python Pastries.
# Total price with tax: $10.50

Python OOP Methods and Function Arguments

To truly master OOP, we must explore the specific use cases, rules, and arguments associated with each method type.

1. Instance Methods (The Default)

If you do not add a decorator to a function inside a class, it is automatically an Instance Method. It can read and modify the specific attributes of the object it belongs to using self.

class BankAccount:
    def __init__(self, account_holder, starting_balance):
        self.holder = account_holder
        self.balance = starting_balance

    # Instance method accessing 'self'
    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            print(f"Deposited ${amount}. New balance: ${self.balance}")
        else:
            print("Deposit amount must be positive.")

    # Instance method accessing another instance method!
    def apply_monthly_interest(self):
        interest_amount = self.balance * 0.02
        # We use 'self' to call the deposit method from inside the class
        self.deposit(interest_amount)

user_account = BankAccount("Alice", 1000)
user_account.apply_monthly_interest()

# Expected Output:
# Deposited $20.0. New balance: $1020.0

2. Class Methods (@classmethod)

A Class Method cannot modify the state of a specific object because it does not have access to self. Instead, it uses cls to modify attributes that affect the entire class blueprint.

The most powerful, real-world use case for a Class Method is acting as an “Alternative Constructor” (often called a Factory Method). It allows you to create new objects from different types of input data.

class EmployeeProfile:
    company = "TechNova"

    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    # Normal instance method
    def display_badge(self):
        print(f"Badge: {self.first_name} {self.last_name} | {self.company}")

    # CLASS METHOD acting as a factory/alternative constructor
    @classmethod
    def create_from_string(cls, data_string):
        # We split the string "John-Doe" by the hyphen
        first, last = data_string.split("-")
        # We use 'cls' exactly like calling 'EmployeeProfile(first, last)'
        return cls(first, last)

# Standard creation using __init__
dev_one = EmployeeProfile("Sarah", "Connor")

# Alternative creation using our Class Method
dev_two = EmployeeProfile.create_from_string("John-Doe")

dev_one.display_badge()
dev_two.display_badge()

# Expected Output:
# Badge: Sarah Connor | TechNova
# Badge: John Doe | TechNova

3. Static Methods (@staticmethod)

A Static Method knows nothing about the class (cls) and nothing about the object (self). It is literally just a normal Python function that you have decided to tuck inside a class because it logically belongs there.

Static methods are almost exclusively used for Utility or Helper functions.

class PasswordValidator:
    
    # We use a static method because this logic relies ONLY on the input (password_string)
    # It doesn't need to know anything about the class or any instances.
    @staticmethod
    def is_valid_length(password_string):
        if len(password_string) >= 8:
            return True
        return False

    @staticmethod
    def contains_number(password_string):
        # any() checks if at least one character is a digit
        return any(char.isdigit() for char in password_string)

# We can call static methods directly on the class without creating an object
user_password = "SecurePassword123"

length_check = PasswordValidator.is_valid_length(user_password)
number_check = PasswordValidator.contains_number(user_password)

print(f"Is length valid? {length_check}")
print(f"Contains number? {number_check}")

# Expected Output:
# Is length valid? True
# Contains number? True

Real-World Practical Examples

Scenario 1: A Complete User Registration System

In a robust application, you will frequently use all three methods in the same class to handle different aspects of user management.

import datetime

class UserRegistration:
    # Class attribute
    total_registered_users = 0

    def __init__(self, username, birth_year):
        self.username = username
        self.birth_year = birth_year
        # Automatically increment the class attribute when a new user is made
        UserRegistration.total_registered_users += 1

    # 1. INSTANCE METHOD: Modifies this specific user's state
    def display_profile(self):
        age = self.calculate_age(self.birth_year)
        print(f"Profile: {self.username} is {age} years old.")

    # 2. CLASS METHOD: Alternative constructor parsing CSV data
    @classmethod
    def from_csv_string(cls, csv_string):
        username, birth_year = csv_string.split(",")
        # Convert the string year to an integer before creating the object
        return cls(username, int(birth_year))

    # 3. STATIC METHOD: A utility function that just does independent math
    @staticmethod
    def calculate_age(birth_year):
        current_year = datetime.datetime.now().year
        return current_year - birth_year

# Creating users through different methods
user_a = UserRegistration("Alice", 1995)
user_b = UserRegistration.from_csv_string("Bob,1990")

user_a.display_profile()
user_b.display_profile()

print(f"Total Users Registered: {UserRegistration.total_registered_users}")

# Expected Output (Age will vary based on current year):
# Profile: Alice is 31 years old.
# Profile: Bob is 36 years old.
# Total Users Registered: 2

Scenario 2: Data Conversion Utilities

Sometimes, you create a class solely to hold a collection of related static methods, acting like a namespace or toolkit.

class TemperatureConverter:
    # No __init__ needed! This class is just a container for static methods.

    @staticmethod
    def celsius_to_fahrenheit(celsius):
        return (celsius * 9/5) + 32

    @staticmethod
    def fahrenheit_to_celsius(fahrenheit):
        return (fahrenheit - 32) * 5/9

# Calling the utility functions directly
boiling_point_f = TemperatureConverter.celsius_to_fahrenheit(100)
freezing_point_c = TemperatureConverter.fahrenheit_to_celsius(32)

print(f"100°C is {boiling_point_f}°F")
print(f"32°F is {freezing_point_c}°C")

# Expected Output:
# 100°C is 212.0°F
# 32°F is 0.0°C

Code language: CSS (css)

Best Practices & Common Pitfalls

  • The Decorator Pitfall: Forgetting to add the @classmethod or @staticmethod decorators above your functions will cause Python to assume they are standard instance methods. When you try to run them, Python will crash with a TypeError complaining about missing positional arguments.
  • Choosing the Right Method (The Decision Tree):
    • Does the method need to modify or read self (the object’s unique data)? Use an Instance Method.
    • Does the method need to modify cls (the global class blueprint) or create a new object from scratch? Use a Class Method.
    • Does the method rely only on the arguments you pass into it, completely ignoring the object and the class? Use a Static Method.
  • Don’t Overuse Static Methods: If you have a class that contains only static methods (like the TemperatureConverter example above), ask yourself if it really needs to be a class. In Python, it is often more “Pythonic” to just put those functions directly into a standalone module file (e.g., temperature.py) rather than wrapping them in an artificial class.

Summary

  • Instance Methods take self as their first parameter. They are the default method type and are used to manipulate the state of a specific, individual object.
  • Class Methods take cls as their first parameter and require the @classmethod decorator. They alter the class blueprint itself and are heavily used as alternative constructors (factory methods) to build objects in non-standard ways.
  • Static Methods take neither self nor cls and require the @staticmethod decorator. They are entirely independent utility functions that are placed inside a class solely for organizational purposes.

Leave a Comment