Use cases for each method type in Python - Mini Project: Build & Apply

Use Cases for Each Method Type

📖 Scenario: Imagine you are creating a simple program to manage a library's book collection. You want to organize your code using different types of methods to see when each type is useful.

🎯 Goal: Build a Python class Book that uses instance methods, class methods, and static methods to handle book details, count books, and check if a book title is valid.

📋 What You'll Learn

Create a class called Book

Use an instance method to display book details

Use a class method to count how many books have been created

Use a static method to check if a book title is valid (non-empty string)

Create at least two Book objects

💡 Why This Matters

🌍 Real World

Using different method types helps organize code clearly in real applications like managing libraries, users, or products.

💼 Career

Understanding method types is essential for writing clean, maintainable object-oriented code in software development jobs.

1

Create the Book class with instance variables

Create a class called Book with an __init__ method that takes title and author as parameters and stores them as instance variables.

Python

class Book:
    def __init__(self, title, author):
        # Your code here

Hint

Use self.title = title and self.author = author inside the __init__ method.

2

Add a class variable and class method to count books

Add a class variable called count initialized to 0. Increase count by 1 inside the __init__ method. Then add a class method called get_count that returns the current value of count. Use the @classmethod decorator and cls parameter.

Python

class Book:
    count = 0
    def __init__(self, title, author):
        self.title = title
        self.author = author
        # Your code here
    @classmethod
    def get_count(cls):
        # Your code here

Hint

Remember to increase Book.count inside __init__ and use @classmethod for get_count.

3

Add a static method to validate book titles

Add a static method called is_valid_title that takes a title parameter and returns True if the title is a non-empty string, otherwise False. Use the @staticmethod decorator.

Python

class Book:
    count = 0
    def __init__(self, title, author):
        self.title = title
        self.author = author
        Book.count += 1
    @classmethod
    def get_count(cls):
        return cls.count
    @staticmethod
    def is_valid_title(title):
        # Your code here

Hint

Use isinstance(title, str) and check if length is greater than zero.

4

Create Book objects, use methods, and print results

Create two Book objects called book1 and book2 with titles and authors. Print the number of books using Book.get_count(). Then print whether the title "Python 101" is valid using Book.is_valid_title("Python 101").

Python

class Book:
    count = 0
    def __init__(self, title, author):
        self.title = title
        self.author = author
        Book.count += 1
    @classmethod
    def get_count(cls):
        return cls.count
    @staticmethod
    def is_valid_title(title):
        return isinstance(title, str) and len(title) > 0

# Your code here

Hint

Create two books, then print the count and check if "Python 101" is a valid title.

Practice

1. Which method type in Python is used to access or modify data unique to each object instance?

easy

A. Global function

B. Instance method

C. Static method

D. Class method

Solution

1. Step 1: Understand instance methods

   Instance methods receive the object itself as the first argument and can access or modify instance-specific data.

2. Step 2: Compare with other methods

   Class methods work with class-level data, static methods don't access instance or class data, and global functions are outside the class.

3. Final Answer:

   Instance method -> Option B

4. Quick Check:

   Instance method = unique object data [OK]

Hint: Instance methods use 'self' to access object data [OK]

Common Mistakes:

• Confusing class methods with instance methods
• Thinking static methods access instance data
• Assuming global functions are methods

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

easy

A. def method():

B. def method(self):

C. @staticmethod\ndef method():

D. @classmethod\ndef method(cls):

Solution

1. Step 1: Recall class method syntax

   Class methods use the @classmethod decorator and receive the class as the first argument, usually named 'cls'.

2. Step 2: Check options

   @classmethod\ndef method(cls): matches this syntax exactly; others define instance or static methods or lack decorators.

3. Final Answer:

   @classmethod\ndef method(cls): -> Option D

4. Quick Check:

   Class method = @classmethod + cls parameter [OK]

Hint: Class methods use @classmethod and 'cls' parameter [OK]

Common Mistakes:

• Using 'self' instead of 'cls' for class methods
• Missing the @classmethod decorator
• Confusing static method syntax with class methods

3. What will be the output of this code?

class Example:
    count = 0

    def __init__(self):
        Example.count += 1

    @classmethod
    def get_count(cls):
        return cls.count

obj1 = Example()
obj2 = Example()
print(Example.get_count())

medium

A. 2

B. 0

C. 1

D. Error

Solution

1. Step 1: Understand the constructor behavior

   Each time an Example object is created, the class variable 'count' increases by 1. Two objects are created, so count becomes 2.

2. Step 2: Understand the class method output

   The class method 'get_count' returns the current value of 'count', which is 2 after creating two objects.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Class variable incremented twice = 2 [OK]

Hint: Class methods access shared data like 'count' [OK]

Common Mistakes:

• Thinking count resets per instance
• Confusing instance and class variables
• Expecting an error due to method call

4. Identify the error in this code snippet:

class Calculator:
    @staticmethod
    def add(x, y):
        return x + y

    @classmethod
    def multiply(cls, x, y):
        return x * y

print(Calculator.add(2, 3))
print(Calculator.multiply(2, 3))

medium

A. No error, code runs correctly

B. Class method 'multiply' missing 'self' parameter

C. Static method 'add' missing 'self' parameter

D. Class method 'multiply' missing 'cls' parameter

Solution

1. Step 1: Check static method definition

   Static methods do not require 'self' or 'cls'; 'add' is correctly defined with two parameters.

2. Step 2: Check class method definition

   Class method 'multiply' correctly has 'cls' as the first parameter and two others; usage is correct.

3. Final Answer:

   No error, code runs correctly -> Option A

4. Quick Check:

   Static and class methods correctly defined [OK]

Hint: Static methods no 'self'; class methods need 'cls' first [OK]

Common Mistakes:

• Expecting 'self' in static methods
• Confusing 'self' and 'cls' in class methods
• Assuming method calls require instance

5. You want to create a method in a class that logs a message but does not need access to instance or class data. Which method type should you use and why?

hard

A. Instance method, because it can access instance data

B. Class method, because it can access class data

C. Static method, because it does not require instance or class data

D. Global function, because it is outside the class

Solution

1. Step 1: Identify method requirements

   The method only logs a message and does not need to access instance or class data.

2. Step 2: Choose appropriate method type

   Static methods are designed for tasks related to the class but do not use instance or class data, making them ideal here.

3. Final Answer:

   Static method, because it does not require instance or class data -> Option C

4. Quick Check:

   Logging without data access = static method [OK]

Hint: Use static methods for utility tasks without data access [OK]

Common Mistakes:

• Using instance or class methods unnecessarily
• Confusing static methods with global functions
• Thinking logging requires instance data