Classes & Objects in Python

Python Classes & Objects :

A class is a user-defined data structure that encapsulates data and functions together. It represents a blueprint or template for creating objects of that class.

Objects, on the other hand, are instances of a class that embody the properties and behaviors defined in the class.

Creation of a Class :

Instantiating Object :

Accessing Attributes and Methods :

To access attributes and methods of an object, use dot operator. Here's an example:

              
                
                  # Accessing attributes
                  print(person.name)  # Output: John
                  print(person.age)   # Output: 30

                  # Calling methods
                  person.greet()      # Output: Hello, my name is John and I am 30 years old.
                
              
            

In this example, we access the 'name' and 'age' attributes of the person object and call the 'greet' method of the class 'Person'.

Class Variables vs. Instance Variables :

Class variables are shared among all instances of a class, while instance variables are specific to each instance. Class variables are defined within the class, but outside any method. Instance variables are defined within the constructor or other methods using the 'self' keyword.

Here's an example for better understanding:

              
                
                  class Car:
                    # Class variable
                    category = "Vehicle"
                    
                    def __init__(self, brand, color):
                        # Instance variables
                        self.brand = brand
                        self.color = color
                
              
            

In this example, category is a class variable and is shared by all instances of the 'Car' class, while 'brand' and 'color' are instance variables specific to each car object.

Class Methods and Static Methods :

In addition to instance methods, Python allows the definition of class methods and static methods within a class.

• Class Methods :
  Class methods are defined using the '@classmethod' decorator and operate on the class itself rather than instances of the class. They are typically used to perform operations that involve the class as a whole. Class methods receive the class itself as the first parameter, conventionally named 'cls', instead of the instance ('self').
  Example:
  
  

                    
                      
                        class Circle:
                        radius = 5
                        
                        @classmethod
                        def from_diameter(cls, diameter):
                            radius = diameter / 2
                          return cls(radius)
                      
                    
                  

  
  In this example, the from_diameter method creates a new instance of the Circle class by accepting the diameter and calculating the radius.


• Static Methods:
  Static methods are defined using the '@staticmethod''@staticmethod' decorator and do not receive the instance or class as implicit parameters. They are independent of the class state and can be called on the class itself or an instance. Static methods are commonly used for utility functions that are related to the class but do not require access to instance-specific or class-specific data.
  Example:
  
  

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

  
  In this example, the multiply static method performs a simple multiplication operation.

Special Methods :

Python provides a set of special methods, often referred to as "magic methods" or "dunder methods" (double underscores), that allow classes to define certain behaviors and operations. These methods have reserved names and are automatically invoked under specific circumstances. Some commonly used magic methods include:

• __init__:
  The constructor method that is called when creating a new instance of the class.


• __str__:
  Defines the string representation of the class instance and is invoked by the str() built-in function or when printing the instance.


• __len__:
  Specifies the behavior when the len() built-in function is called on an instance of the class.


• __eq__, __ne__:
  Define the equality and inequality comparison behavior for instances of the class.


• __getitem__, __setitem__:
  Enable object indexing and assignment by implementing these methods.

By defining and utilizing these magic methods, we can customize the behavior of your classes to suit specific requirements.

Public, Private, and Protected Attributes :

In Python, attributes and methods are not strictly enforced as public, private, or protected. However, there are naming conventions that indicate the intended visibility of these attributes and methods.

• Public Attributes :
  Public attributes have no special naming conventions and can be accessed and modified directly by external code or from outside the class.


• Private Attributes :
  Private attributes are conventionally prefixed with a double underscore (__). Although they are not entirely inaccessible, their naming convention suggests that they should not be accessed directly from outside the class.


• Protected Attributes :
  Protected attributes are conventionally prefixed with a single underscore (_). While they are accessible, the naming convention indicates that they are intended for internal use within the class or its subclasses.

It's important to note that these naming conventions are merely conventions, and Python does not enforce strict access control. Developers are encouraged to follow these conventions to maintain code readability and integrity.

Benefits of Classes and Objects :