Static methods behavior in Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of calling static method from instance

What is the output of this code when calling obj.greet()?

Python

class MyClass:
    @staticmethod
    def greet():
        return "Hello from static method"

obj = MyClass()
print(obj.greet())

A AttributeError: 'MyClass' object has no attribute 'greet'

B TypeError: greet() takes 0 positional arguments but 1 was given

C Hello from static method

D None

💡 Hint

Static methods do not receive the instance automatically.

Static methods can be called on instances without passing the instance as an argument. They behave like regular functions inside the class namespace.

❓ Predict Output

intermediate

Static method accessing class variable

What will be printed when this code runs?

Python

class Counter:
    count = 0

    @staticmethod
    def increment():
        Counter.count += 1

Counter.increment()
Counter.increment()
print(Counter.count)

A NameError

B 0

C TypeError

D 2

💡 Hint

Static methods can access class variables by using the class name.

The static method increments the class variable 'count' twice, so the final value is 2.

❓ Predict Output

advanced

Static method vs class method behavior

What is the output of this code?

Python

class Example:
    value = 5

    @staticmethod
    def static_method():
        return Example.value

    @classmethod
    def class_method(cls):
        return cls.value

print(Example.static_method())
print(Example.class_method())

A 5\n5

B 5\nTypeError

C TypeError\n5

D AttributeError\nAttributeError

💡 Hint

Static methods use the class name explicitly; class methods receive the class as first argument.

Both methods return the class variable 'value' correctly, so both print 5.

❓ Predict Output

advanced

Static method called with instance and class

What will be the output of this code?

Python

class Demo:
    @staticmethod
    def info():
        return "Static method called"

obj = Demo()
print(Demo.info())
print(obj.info())

A Static method called\nStatic method called

B AttributeError\nAttributeError

C TypeError\nStatic method called

D Static method called\nTypeError

💡 Hint

Static methods can be called both on the class and on instances without error.

Static methods do not depend on instance or class arguments, so both calls succeed and print the same string.

❓ Predict Output

expert

Static method with parameters and no self or cls

What is the output of this code?

Python

class Calculator:
    @staticmethod
    def multiply(a, b):
        return a * b

print(Calculator.multiply(3, 4))
calc = Calculator()
print(calc.multiply(5, 6))

A TypeError\n30

B 12\n30

C 12\nTypeError

D AttributeError\nAttributeError

💡 Hint

Static methods behave like normal functions inside the class and do not receive instance or class automatically.

Both calls pass two arguments explicitly, so both calls return the product correctly.

Practice

1. What is a key characteristic of a staticmethod in Python?

easy

A. It does not receive the instance or class as the first argument.

B. It automatically receives the instance as the first argument.

C. It can only be called on an instance, not on the class.

D. It modifies the class state directly.

Solution

1. Step 1: Understand the role of static methods

   Static methods do not take the instance (self) or class (cls) as their first argument.

2. Step 2: Compare options with static method behavior

   It does not receive the instance or class as the first argument. correctly states this key feature, while others describe instance or class methods.

3. Final Answer:

   It does not receive the instance or class as the first argument. -> Option A

4. Quick Check:

   Static method = no self or cls [OK]

Hint: Static methods don't get self or cls automatically [OK]

Common Mistakes:

• Thinking static methods receive 'self' or 'cls'
• Confusing static methods with instance methods
• Believing static methods modify class state

2. Which of the following is the correct way to define a static method in a Python class?

easy

A. def method(self): pass

B. @classmethod\ndef method(cls): pass

C. @staticmethod\ndef method(): pass

D. def method(cls): pass

Solution

1. Step 1: Identify the decorator for static methods

   The @staticmethod decorator is used to define static methods.

2. Step 2: Check method signature

   Static methods do not take self or cls as parameters, so the method should have no parameters.

3. Final Answer:

   @staticmethod\ndef method(): pass -> Option C

4. Quick Check:

   @staticmethod + no self/cls = correct static method [OK]

Hint: Use @staticmethod decorator and no parameters [OK]

Common Mistakes:

• Forgetting @staticmethod decorator
• Including self or cls as parameters
• Confusing with @classmethod

3. What will be the output of the following code?

class MyClass:
    @staticmethod
    def greet():
        return "Hello!"

print(MyClass.greet())

medium

A. TypeError: greet() missing 1 required positional argument

B. None

C. AttributeError: 'MyClass' object has no attribute 'greet'

D. "Hello!"

Solution

1. Step 1: Understand static method call

   Static methods can be called directly on the class without creating an instance.

2. Step 2: Check method return value

   The greet method returns the string "Hello!", so printing it outputs "Hello!".

3. Final Answer:

   "Hello!" -> Option D

4. Quick Check:

   Static method call returns "Hello!" [OK]

Hint: Call static methods on class directly to get return value [OK]

Common Mistakes:

• Expecting an instance to call static method
• Confusing static method with instance method needing self
• Misreading the output as an error

4. Identify the error in this code snippet:

class Example:
    @staticmethod
    def show(self):
        print("Static method")

Example.show()

medium

A. TypeError because static method has 'self' parameter

B. No error, prints "Static method"

C. SyntaxError due to decorator misuse

D. AttributeError: 'Example' has no attribute 'show'

Solution

1. Step 1: Check static method parameters

   Static methods should not have 'self' or 'cls' parameters because they are not passed automatically.

2. Step 2: Understand the call behavior

   Calling Example.show() passes no arguments, but method expects one ('self'), causing TypeError.

3. Final Answer:

   TypeError because static method has 'self' parameter -> Option A

4. Quick Check:

   Static method with 'self' causes TypeError [OK]

Hint: Static methods must not have self or cls parameters [OK]

Common Mistakes:

• Adding self parameter to static methods
• Assuming static methods get instance automatically
• Confusing static and instance methods

5. Given this class:

class Calculator:
    @staticmethod
    def add(a, b):
        return a + b

    @staticmethod
    def multiply(a, b):
        return a * b

# Which call is correct to get the product of 3 and 4?

hard

A. Calculator.multiply(self, 3, 4)

B. Calculator.multiply(3, 4)

C. Calculator.multiply()

D. Calculator.multiply(3)

Solution

1. Step 1: Understand static method parameters

   Static methods require all parameters to be passed explicitly since no self or cls is passed.

2. Step 2: Check each call for correctness

   Calculator.multiply(3, 4) correctly passes two arguments (3 and 4). Options B, C, and D have wrong or missing arguments.

3. Final Answer:

   Calculator.multiply(3, 4) -> Option B

4. Quick Check:

   Static method call with correct arguments works [OK]

Hint: Pass all arguments explicitly to static methods [OK]

Common Mistakes:

• Passing self to static methods
• Calling without required arguments
• Confusing static with instance method calls