Python Class and Instance Variables Tutorial (With Examples)

Introduction to Class and Instance Variables

In object-oriented programming, classes serve as blueprints for creating objects. These objects can have attributes (variables) and methods (functions) associated with them. Class variables and instance variables are two types of attributes used in Python classes to store data that is specific to either the entire class or individual instances of the class. In this tutorial, we will delve into the concepts of class and instance variables, explore their differences, and provide practical examples to solidify your understanding.

Class Variables

Class variables are attributes that are shared among all instances of a class. They are defined within the class but outside any instance methods. These variables are typically used to store information that remains constant for all instances of the class. Class variables are accessed using the class name rather than through instances, making them globally accessible within the class.

Syntax for Defining Class Variables

class ClassName:
    class_variable = value

In the above syntax, class_variable is the name of the class variable, and value is the initial value assigned to it.

Accessing Class Variables

Class variables are accessed using the class name, followed by the dot operator and the variable name.

class MyClass:
    class_variable = 10

print(MyClass.class_variable)  # Output: 10

Example 1: Counting Instances

Let’s consider an example where we want to keep track of the number of instances created from a class using a class variable.

class Dog:
    num_dogs = 0

    def __init__(self, name):
        self.name = name
        Dog.num_dogs += 1

    def bark(self):
        print(f"{self.name} is barking!")

# Creating instances of the Dog class
dog1 = Dog("Buddy")
dog2 = Dog("Max")

print("Total number of dogs:", Dog.num_dogs)  # Output: Total number of dogs: 2

In this example, the num_dogs class variable keeps track of the number of instances created from the Dog class. Each time a new instance is created, the __init__ method increments the num_dogs count.

Instance Variables

Instance variables are attributes that are unique to each instance of a class. They are defined within the class methods, usually within the __init__ constructor. Instance variables store data that can vary from one instance to another, making them an essential part of object-oriented programming.

Syntax for Defining Instance Variables

class ClassName:
    def __init__(self, parameter1, parameter2):
        self.instance_variable1 = parameter1
        self.instance_variable2 = parameter2

In the above syntax, instance_variable1 and instance_variable2 are the names of the instance variables.

Accessing Instance Variables

Instance variables are accessed using the self keyword, which refers to the instance itself.

class MyClass:
    def __init__(self, value):
        self.instance_variable = value

obj = MyClass(42)
print(obj.instance_variable)  # Output: 42

Example 2: Bank Account

Suppose we want to create a BankAccount class to represent individual bank accounts. Each account should have a unique account number and an initial balance.

class BankAccount:
    def __init__(self, account_number, initial_balance):
        self.account_number = account_number
        self.balance = initial_balance

    def deposit(self, amount):
        self.balance += amount
        print(f"Deposited ${amount}. New balance: ${self.balance}")

    def withdraw(self, amount):
        if self.balance >= amount:
            self.balance -= amount
            print(f"Withdrew ${amount}. New balance: ${self.balance}")
        else:
            print("Insufficient funds.")

# Creating bank account instances
account1 = BankAccount("123456", 1000)
account2 = BankAccount("789012", 500)

account1.deposit(200)    # Output: Deposited $200. New balance: $1200
account2.withdraw(300)   # Output: Withdrew $300. New balance: $200
account1.withdraw(1500)  # Output: Insufficient funds.

In this example, each instance of the BankAccount class has its own account_number and balance instance variables, which are unique to that specific instance.

Difference Between Class and Instance Variables

To summarize, the key differences between class and instance variables are as follows:

Scope and Access: Class variables have a global scope within the class, and they are accessed using the class name. Instance variables are specific to each instance and are accessed using the self keyword.
Shared vs. Unique: Class variables are shared among all instances of the class and have the same value for each instance. Instance variables have unique values for each instance.
Initialization: Class variables are typically initialized outside of instance methods. Instance variables are usually initialized within the __init__ method.
Usage: Class variables are suitable for storing data that remains constant across all instances, such as constants or counters. Instance variables store data that can vary for each instance.

Conclusion

In this tutorial, we explored the concepts of class and instance variables in Python classes. Class variables provide a way to store shared data among all instances of a class, while instance variables allow for unique data storage specific to each instance. By understanding the differences between these two types of variables, you can design more flexible and efficient object-oriented programs. Remember to consider the nature of the data you want to store and access within your classes to determine whether to use class variables or instance variables. With this knowledge, you are now equipped to create well-organized and robust Python programs using classes and instance variables.