Python - The constructor, class variables, and instance variables

Constructor, Class Variables, and Instance Variables in Python

Introduction

In Python, object-oriented programming (OOP) enables developers to structure programs using objects and classes. Three core components of Python classes that are essential to building robust OOP systems are constructors, class variables, and instance variables. These elements define how data is initialized, shared, or encapsulated in class definitions. In this guide, we’ll explore how these features work, their distinctions, and best practices for using them effectively.

1. Python Class Basics

What is a Class?

A class is a blueprint for creating objects (instances). A class defines attributes (variables) and behaviors (methods) that the created objects will have.

What is an Object?

An object is an instance of a class. It contains real data and interacts with the class’s functions.

Defining a Simple Class

class Car:
    def start(self):
        print("Car started")

my_car = Car()
my_car.start()

2. The Constructor in Python

What is a Constructor?

A constructor is a special method that is automatically invoked when an object is created from a class. In Python, the constructor method is called __init__(). It is used to initialize the instance’s attributes.

Basic Syntax

class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade

s1 = Student("Alice", "A")
print(s1.name)   # Alice

Understanding self

The self keyword represents the instance of the class. It allows access to the attributes and methods of the object.

Default Constructor vs Parameterized Constructor

Default Constructor has no parameters:

class Demo:
    def __init__(self):
        print("Default Constructor Called")

obj = Demo()

Parameterized Constructor initializes instance attributes with values passed as arguments:

class Demo:
    def __init__(self, x):
        self.x = x
        print("Value:", x)

obj = Demo(10)

Multiple Constructors?

Python does not support method overloading directly, but you can simulate multiple constructor behavior using default parameters or class methods.

class Person:
    def __init__(self, name=None):
        if name:
            self.name = name
        else:
            self.name = "Unknown"

p1 = Person()
p2 = Person("John")

print(p1.name)  # Unknown
print(p2.name)  # John

3. Instance Variables

Definition

Instance variables are variables that are unique to each instance of a class. They are declared within the constructor using the self keyword.

Characteristics of Instance Variables

• Defined inside __init__() or other instance methods
• Unique to each object
• Used to maintain state across instances

Example

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

e1 = Employee("Alice", 50000)
e2 = Employee("Bob", 60000)

print(e1.name, e1.salary)  # Alice 50000
print(e2.name, e2.salary)  # Bob 60000

Modifying Instance Variables

e1.salary = 55000
print(e1.salary)  # 55000

4. Class Variables

Definition

Class variables are shared among all instances of a class. They are declared inside the class but outside any instance methods or constructor.

Characteristics of Class Variables

• Declared within the class body
• Shared across all instances
• Accessed using the class name or instance

Example

class Student:
    school_name = "Greenwood High"  # Class variable

    def __init__(self, name):
        self.name = name

s1 = Student("Alice")
s2 = Student("Bob")

print(s1.school_name)  # Greenwood High
print(s2.school_name)  # Greenwood High

Modifying Class Variables

Student.school_name = "Bluebell School"
print(s1.school_name)  # Bluebell School
print(s2.school_name)  # Bluebell School

5. Class Variables vs Instance Variables

Comparison Table

6. Access Modifiers for Variables

Public Variables

Accessible from anywhere.

self.name = name

Protected Variables

By convention, prefix with a single underscore.

self._salary = salary

Private Variables

Prefix with two underscores.

self.__bank_account = "12345678"

7. Tracking Object Count with Class Variable

Example

class Counter:
    count = 0

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

c1 = Counter()
c2 = Counter()
print("Total:", Counter.count)  # 2

8. Dynamic Creation of Instance Variables

class Dynamic:
    pass

d = Dynamic()
d.attribute = "Added Later"
print(d.attribute)  # Added Later

9. Using Class Methods to Access Class Variables

Class Method Example

class Circle:
    pi = 3.14

    @classmethod
    def get_pi(cls):
        return cls.pi

print(Circle.get_pi())  # 3.14

10. Best Practices

• Use instance variables for data specific to an object.
• Use class variables for shared state or counters.
• Initialize instance variables only inside the constructor.
• Access class variables using class name for clarity.
• Protect sensitive data using private variables.

11. Real-World Example

class BankAccount:
    bank_name = "National Bank"  # Class variable
    total_accounts = 0

    def __init__(self, holder, balance):
        self.holder = holder        # Instance variable
        self.balance = balance
        BankAccount.total_accounts += 1

    def deposit(self, amount):
        self.balance += amount

a1 = BankAccount("Alice", 1000)
a2 = BankAccount("Bob", 500)

print(a1.holder, a1.balance)  # Alice 1000
print(a2.holder, a2.balance)  # Bob 500
print("Total Accounts:", BankAccount.total_accounts)  # 2

Understanding constructors, class variables, and instance variables is fundamental for effective object-oriented programming in Python. Constructors ensure proper initialization of objects, instance variables manage individual object data, and class variables enable shared state across all instances. By mastering these components, developers can build organized, reusable, and scalable Python applications that leverage the full power of OOP.