Question

What is the difference between class method (static) and instance method?

Short answer

Class methods are bound to the class; instance methods are bound to the object.

Step-by-step solution

Understand the Concept of Methods in Classes

In object-oriented programming, methods are functions defined within a class that describe the behaviors or actions that objects of the class can perform. Methods can interact with class attributes and instance attributes or can perform operations related to the class.

Define Class (Static) Methods

Class methods are methods that are bound to the class and not the instance of the class. They can access and modify class state that applies across all instances of the class. Class methods are defined using the @classmethod decorator and the first parameter is always 'cls' which refers to the class itself.

Example of a Class Method

Consider a class `Car` with a class method: ```python class Car: num_wheels = 4 @classmethod def display_wheel_count(cls): return f'All cars have {cls.num_wheels} wheels.' ``` Here, the method `display_wheel_count` uses `cls` to access the class attribute `num_wheels`. It does not require an instance of the class to be called.

Define Instance Methods

Instance methods are methods that are bound to the instance of the class. They can access and modify the object state or instance attributes. These methods take 'self' as the first parameter, which refers to the individual instance of the class.

Example of an Instance Method

Consider the same class `Car` with an instance method: ```python class Car: def __init__(self, color): self.color = color def display_color(self): return f'This car is {self.color}.' ``` The method `display_color` accesses an instance attribute `color` specific to that instance. It is called on an object of the class.

Compare and Contrast

Class methods apply to the class as a whole and do not require an object to be instantiated, whereas instance methods operate on individual objects with their unique data. Class methods can modify class-level data that applies to all instances, while instance methods typically manipulate data specific to an object.

Key concepts

Class Methods

Class methods are a fundamental concept in object-oriented programming (OOP). These methods are associated with the class itself rather than any particular instance of the class. This means you can call a class method even if no instances of the class have been created.

• Class methods are defined using the `@classmethod` decorator.
• The first parameter of a class method is always `cls`, representing the class.
• They can access class attributes and modify their values, affecting all instances of the class.

Consider the class `Car` example provided earlier. The `display_wheel_count` method is a class method that uses `cls` to refer to the class attribute `num_wheels`. This example shows that class methods are perfect for operations that are relevant to the entire class.

Instance Methods

Instance methods are what you might first think of when you hear about methods in object-oriented programming. These methods work on instances, also known as objects, of the class. This allows them to operate on data specific to particular instances.

• Instance methods automatically receive the instance object as their first parameter (commonly named `self`).
• They can access and modify instance attributes, which are unique to each object.
• They are called on an object, and perform operations using the object's data.

Using the earlier `Car` class example, the method `display_color` is an instance method, utilizing `self` to work with the instance attribute `color`. Each `Car` object can have its own color, demonstrating the power of instance methods in handling unique object data.

Class Attributes

Class attributes are shared across all instances of a class and are defined directly in the class body. These attributes are great for storing information relevant to the class itself, rather than specific to any one instance.

• Class attributes are accessed using the class name or the `cls` parameter in class methods.
• They provide a way to store shared data between all instances.
• Any changes made to a class attribute are reflected across all instances.

In the provided `Car` example, `num_wheels` is a class attribute. This means all `Car` objects will have `num_wheels` equal to 4 unless explicitly modified at the class level. Class attributes are powerful for maintaining consistent information across multiple instances.

Instance Attributes

Instance attributes in OOP are specific to an object and defined within methods like `__init__`, usually using `self`. These attributes let different instances of the same class maintain their unique data.

• Instance attributes are accessed using the `self` keyword.
• They allow objects to have their own state, separate from other instances.
• They are ideal for data that varies between objects but is not shared class-wide.

Returning to the earlier example, the `color` attribute of the `Car` class is an instance attribute. Each `Car` object can have a distinct color, showing how instance attributes allow for unique, object-specific data within a class.