Python Static Methods Tutorial – Complete Guide

Welcome to a journey into the world of Python static methods. This tutorial will guide you into understanding how they work, why they are useful, and how you can effectively use them in your coding routine. As an essential part of Object-Oriented Programming (OOP), static methods can significantly improve your code structure and efficiency.

What are Python Static Methods?

In Python, methods like instance and class methods require a special first parameter that ties it to either an instance of the class (self) or the class itself (cls). A static method, however, has no such requirement. It is a method that belongs to a class rather than an instance of the class.

Python static methods offer an effective way of writing code that does not depend on the state of the object and can be grouped into the class for better code organization. They can perform utility tasks, which do not alter the state of an object but are logically bound to the class.

Understanding Python static methods can enhance your skill set as a Python developer. They offer a powerful tool in your arsenal for structuring your code, improving readability, maintainability, and code reuse. Whether you’re just starting your coding journey or already an experienced coder, mastering static methods will propel you to a higher level of Python coding proficiency.

CTA Small Image

How to Define a Static Method

Let’s go through the basic steps of defining a static method in Python. The key to this is using the @staticmethod decorator before defining your method.

class MyClass:
    def static_method():
        print("This is a static method")

Here we have a static method named static_method in the class MyClass. Even though it’s located within the class, it can’t access or modify the class state because it doesn’t take a self or a cls parameter.

How to Call a Static Method

Static methods can be called either on an instance or on the class itself. Let’s see two examples.

# Calling static method on class
MyClass.static_method() # Outputs: This is a static method

# Calling static method on instance
instance = MyClass()
instance.static_method() # Outputs: This is a static method

When to Use a Static Method

Let’s consider an example where a static method can come in handy. Suppose we have a class that processes user data. One of the tasks is to validate a user’s email address. This function does not deal with class or instance parameters, so a static method is ideal.

import re

class User:
    def validate_email(email):
        if re.match(r"[^@]+@[^@]+\.[^@]+", email):
            return True
            return False

# use the static method
print(User.validate_email("[email protected]")) # Outputs: True
print(User.validate_email("wrong-email")) # Outputs: False

A Warning About Static Methods

Just because you can use static methods does not mean you should always use them. Remember that they can’t access or modify the class or instance state. If you find yourself needing to use the class or instance data, consider using class methods or instance methods instead.

class MyClass:
    my_attribute = 10

    # This static method can't access my_attribute directly
    def static_method():
        return MyClass.my_attribute # need to reference class explicitly

    # class method can access class state directly
    def class_method(cls):
        return cls.my_attribute

There you have it! Understanding how and when to use static methods can be hugely beneficial and can improve the readability and maintainability of your Python code.

Using Static Methods for Math Operations

Static methods can be deployed for routine utility tasks like mathematical operations. Let’s illustrate this with a MathFunctions class.

class MathFunctions:
    def add_numbers(x, y):
        return x + y

    def subtract_numbers(x, y):
        return x - y

# Using the class for mathematical operations
print(MathFunctions.add_numbers(10, 5)) # Outputs: 15
print(MathFunctions.subtract_numbers(10, 5)) # Outputs: 5

Defining these static math functions within a class helps to organize your code and provides logical grouping of related functions.

Static Methods and Inheritance

Static methods can also be inherited in Python, similar to instance and class methods. They can be overridden by subclasses for different functionality.

class Parent:
    def greet():
        print("Hello from Parent class!")

class Child(Parent):
    def greet():
        print("Hello from Child class!")
Parent.greet() # Outputs: Hello from Parent class!
Child.greet() # Outputs: Hello from Child class!

Even though static methods behave somewhat differently than regular class or instance methods, they still follow the rules of inheritance and polymorphism.

Combining Instance, Class, and Static Methods

In a real-world codebase, you’ll frequently find all three types of methods being used within a single class. Each type has its advantages and specific use cases.

class MyCafe:
    sales = 0  # a class attribute

    def __init__(self, name, price): = name
        self.price = price
    def update_sales(cls, amount):
        cls.sales += amount

    def sell_item(self, quantity):
        total = self.price * quantity
        return total

    def calculate_discount(price, discount_percentage):
        return price - (price * discount_percentage/100)

# Creating instances
coffee = MyCafe("Coffee", 5)
tea = MyCafe("Tea", 3)

# Selling items
print(coffee.sell_item(4)) # Outputs: 20
print(tea.sell_item(2)) # Outputs: 6
print(MyCafe.sales) # Outputs: 26

# Applying discount using static method
print(MyCafe.calculate_discount(coffee.price, 20)) # Outputs: 4.0

Here, the sell_item method is instance specific, hence an instance method. The update_sales is a class method which updates sales, a class attribute. And the calculate_discount is a static method as it just does a utility task of calculating discount, and does not depend on either an instance or the class.

With that, you’re equipped to use static methods in Python confidently, understanding where, when, and how to use them in your code to write cleaner and more readable code.

Where to Go Next

You’ve made it this far and discovered the power of Python static methods, but don’t stop here. There’s still so much more to learn and master to become a proficient Python programmer, and we can help you on your journey.

Ready to take your Python programming skills to the next level? We invite you to check out our Python Mini-Degree, a comprehensive collection of courses that delve into the world of Python programming. Within this mini-degree, you will learn a variety of topics, from coding basics and algorithms to object-oriented programming and app development.

You won’t just be learning – you’ll be doing. Our philosophy emphasizes creating projects, so by the time you’re done, you’ll have a portfolio showcasing your skills. It’s not just about reading and watching, but doing.

Our courses cater to your skill level – whether you’re just starting with Python or you’re seeking a deeper challenge, our Mini-Degree provides learners with a flexible and comprehensive learning path. The Zenva journey doesn’t stop at the basics, we take you all the way to becoming a professional.

Looking for more? We have a wide collection of Python courses that cover an array of topics. Find the course that suits your goals and delve deeper into the fascinating world of Python programming. Check out our Python courses and continue your educational journey with us.


We hope this tutorial led you to a deeper understanding of Python’s static methods and just how powerful and versatile they can be in your coding toolkit. As a Python programmer, extending your knowledge base is crucial to becoming more efficient and producing higher quality code.

Ready to dive deeper into Python and other exciting aspects of programming? Embark on your learning journey with Zenva’s Python Mini-Degree. Discover the wealth of knowledge we have to offer, expand your skills, and excel in your coding journey. Here’s to advancing your abilities and achieving your programming goals!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.