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.
Top comments (0)