Python -How to define public, private and protected variables in a class

Introduction

Python, as an object-oriented programming language, provides various ways to encapsulate data within a class.
One of the key aspects of this encapsulation is the visibility of class variables, which can be categorized as public, protected, and private. In this article, we'll explore how to define public, private, and protected variables in a Python class.

The behaviour of these variables is quiet different from other programming language. These access controls are just the naming conventions in python rather than actual hiding of objects.

1. Public Variables

Public variables are the most accessible type of variable. They can be accessed from anywhere, both inside and outside the class. In Python, all class variables are public by default unless explicitly defined otherwise.

Example:

class MyClass:
    def __init__(self, name):
        self.name = name  # Public variable

obj = MyClass("John")
print(obj.name)  # Accessible outside the class
#Output : John

In this example, name is a public variable. You can access and modify it from outside the class without any restrictions.

2. Protected Variables

Protected variables are intended to be accessed only within the class and its subclasses. While Python doesn't enforce strict access controls, the convention for indicating that a variable is protected is to prefix its name with a single underscore (_).

Example:

class MyClass:
    def __init__(self, name, age):
        self._age = age  # Protected variable

class ChildClass(MyClass):
    def display(self):
        print(f"Age: {self._age}")  # Accessible within a subclass

obj = ChildClass("John", 30)
obj.display()  
# Output: Age: 30

In this example, age is a protected variable. Although Python doesn’t prevent you from accessing it directly outside the class, doing so goes against the intended usage.

3. Private Variables

Private variables are meant to be accessed only within the class that defines them. Python signifies private variables by prefixing the variable name with a double underscore (__). This triggers name mangling, which makes it harder (but not impossible) to access private variables from outside the class.

Example:

class MyClass:
    def __init__(self, name, age, salary):
        self.__salary = salary  # Private variable

    def display_salary(self):
        print(f"Salary: {self.__salary}")  # Accessible within the class

obj = MyClass("John", 30, 50000)
obj.display_salary()  # Output: Salary: 50000

# Trying to access the private variable outside the class
print(obj.__salary)  # Raises AttributeError

In this example, salary is a private variable. If you try to access it directly from outside the class, Python will raise an AttributeError. However, you can still access it using the name-mangled version, though this is discouraged.

Example of Name Mangling:

print(obj._MyClass__salary)  # Output: 50000

This line of code demonstrates how private variables are internally renamed to include the class name, making them less accessible.

Summary

• Public Variables: Accessible from anywhere; no underscores.
• Protected Variables: Accessible within the class and its subclasses; prefixed with a single underscore (_).
• Private Variables: Accessible only within the class; prefixed with a double underscore (__).

While Python’s access controls are based on naming conventions rather than strict enforcement, following these conventions helps maintain code clarity and integrity. Understanding how to define and use public, protected, and private variables is crucial for effective object-oriented programming in Python.