Python - Classes

In Python, instance variables are variables that are bound to an instance of a class. They represent the attributes of an object and are defined within the __init__ method of the class. Each instance of the class has its own set of instance variables, allowing different objects to have different values for these variables.

Let's demonstrate the concept of instance variables with an example:

class Car:
    def __init__(self, make, model, year):
        self.make = make  # Instance variable
        self.model = model  # Instance variable
        self.year = year  # Instance variable

    def display_info(self):
        print(f"{self.year} {self.make} {self.model}")

# Creating objects of the Car class
car1 = Car("Toyota", "Camry", 2022)
car2 = Car("Ford", "Mustang", 2023)

# Accessing object attributes (instance variables)
car1.display_info()
car2.display_info()

# Modifying instance variable for car1
car1.year = 2024

# Displaying updated information
car1.display_info()

In this example, the Car class has three instance variables (make, model, and year), and these variables are initialized within the __init__ method. Each object created from the class has its own set of these variables.

We create two objects, car1 and car2, and access their attributes using the display_info method. We then modify the year instance variable of car1 and display the updated information.

Output:

2022 Toyota Camry
2023 Ford Mustang
2024 Toyota Camry

In Python, the self parameter in class methods refers to the instance of the class that the method is associated with. It is a convention in Python to name this first parameter as self, though you could technically use any name. The self parameter allows you to access and modify the instance variables and call other methods within the class.

Let's explore the significance of the self parameter with an example:

class Calculator:
    def __init__(self, value):
        self.result = value

    def add(self, x):
        self.result += x

    def multiply(self, y):
        self.result *= y

    def get_result(self):
        return self.result

# Creating an object of the Calculator class
calculator = Calculator(10)

# Calling methods with the self parameter
calculator.add(5)
calculator.multiply(2)

# Getting the final result
final_result = calculator.get_result()

# Displaying the final result
print(final_result)

In this example, the Calculator class has an __init__ method to initialize the result instance variable. The add and multiply methods take additional parameters and use the self parameter to access and modify the instance variable.

We create an object calculator of the Calculator class, call the add and multiply methods, and then retrieve the final result using the get_result method.

Output:

30

In Python, you create an instance of a class by calling the class constructor. The class constructor is usually the __init__ method, which is automatically called when you create a new object. You can pass arguments to the constructor to initialize the object's attributes.

Let's create an instance of a class using an example:

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def display_info(self):
        print(f"Name: {self.name}, Age: {self.age}")

# Creating an object (instance) of the Dog class
my_dog = Dog("Buddy", 3)

# Accessing object attributes
my_dog.display_info()

In this example, we have a Dog class with an __init__ method that initializes the name and age attributes. We then create an object my_dog of the Dog class by calling the constructor and passing values for the attributes.

Finally, we call the display_info method to print information about the created instance.

Output:

Name: Buddy, Age: 3

In Python, class variables and instance variables serve different purposes in object-oriented programming. The key differences lie in their scope, lifespan, and how they are accessed.

Class Variables:

Class variables are shared by all instances of a class. They are defined outside of any method in the class and are usually placed at the top. Class variables are accessed using the class name and can be used to store data that is common to all instances of the class.

class Car:
    # Class variable
    wheels = 4

    def __init__(self, make, model):
        # Instance variables
        self.make = make
        self.model = model

# Accessing class variable using the class name
print(f"Number of wheels for all cars: {Car.wheels}")

# Creating objects with different values for instance variables
car1 = Car("Toyota", "Camry")
car2 = Car("Ford", "Mustang")

# Accessing instance variables
print(f"{car1.make} {car1.model} has {Car.wheels} wheels.")
print(f"{car2.make} {car2.model} has {Car.wheels} wheels.")

Instance Variables:

Instance variables are specific to each instance of a class. They are defined within the methods of the class, typically in the __init__ method. Each instance of the class can have different values for its instance variables.

class Dog:
    # Class variable
    species = "Canine"

    def __init__(self, name, age):
        # Instance variables
        self.name = name
        self.age = age

# Accessing class variable using the class name
print(f"Dog species: {Dog.species}")

# Creating objects with different values for instance variables
dog1 = Dog("Buddy", 3)
dog2 = Dog("Charlie", 5)

# Accessing instance variables
print(f"{dog1.name} is {dog1.age} years old and is a {Dog.species}.")
print(f"{dog2.name} is {dog2.age} years old and is a {Dog.species}.")

In the first example, the wheels variable is a class variable, shared among all instances of the Car class. In the second example, the species variable is a class variable for the Dog class.

The instance variables make, model, name, and age are specific to each instance of the respective classes.

Outputs:

Number of wheels for all cars: 4
Toyota Camry has 4 wheels.
Ford Mustang has 4 wheels.

Dog species: Canine
Buddy is 3 years old and is a Canine.
Charlie is 5 years old and is a Canine.