6.7 Access Modifiers in Python

Access modifiers in Python are a mechanism used to signify the intended scope and visibility of class attributes and methods. They play a crucial role in implementing encapsulation, a fundamental principle of object-oriented programming (OOP), by protecting data from unintended external access or modification.

Unlike languages such as Java or C++, Python does not enforce strict access control through keywords like public, private, or protected. Instead, Python relies on naming conventions to indicate the intended access level of class members.

Types of Access Modifiers in Python

Python uses prefixes in member names to indicate their intended access level:

1. Public Members

Public members are the default. Any attribute or method defined in a Python class without any special prefix is considered public. They are accessible from anywhere, both inside and outside the class.

class Student:
    def __init__(self, roll_number, branch):
        self.roll_number = roll_number  # Public attribute
        self.branch = branch            # Public attribute

# Creating an instance of the Student class
s1 = Student(101, "Mechanical")

# Accessing public attributes from outside the class
print(s1.roll_number)
print(s1.branch)

Output:

101
Mechanical

2. Protected Members

Protected members are conventionally intended for use within the class and its subclasses (inheritance). They are indicated by prefixing the member name with a single underscore (_).

Important Note: Python does not strictly enforce this. Protected members are still technically accessible from outside the class, but the underscore serves as a signal to developers that they should not be accessed directly from outside the class or its subclasses.

class Student:
    def __init__(self, name, gpa):
        self.name = name          # Public attribute
        self._gpa = gpa           # Protected attribute

class Graduate(Student):
    def display_gpa(self):
        # Accessing protected member from a subclass
        print("Protected GPA:", self._gpa)

# Creating an instance of the Graduate class
g1 = Graduate("Divya", 3.7)
g1.display_gpa()

# While not recommended, protected members can still be accessed directly
# print("Direct access to protected GPA:", g1._gpa)

Output:

Protected GPA: 3.7

3. Private Members

Private members are intended to be accessible only within the class where they are defined. They are indicated by prefixing the member name with double underscores (__).

Python uses a technique called name mangling for private members. When you define a member with __, Python internally renames it to _ClassName__memberName to make it harder (though not impossible) to access from outside the class.

class Student:
    def __init__(self, name, marks):
        self.name = name          # Public attribute
        self.__marks = marks      # Private attribute

s1 = Student("Arun", 88)

# Accessing public member
print(s1.name)

# Attempting to access private member directly (will raise an AttributeError)
try:
    print(s1.__marks)
except AttributeError as e:
    print(e)

Output:

Arun
'Student' object has no attribute '__marks'

Name Mangling in Python

As mentioned, Python performs name mangling on private members. You can technically access these members by using their mangled name, but this is strongly discouraged as it bypasses the intended privacy and can lead to brittle code.

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

s1 = Student("Arun", 88)

# Accessing private member using name mangling (not recommended)
print(s1._Student__marks)

Output:

88

Using property() for Encapsulation

Python's built-in property() function is a powerful tool for managing access to private data, providing a cleaner and more Pythonic way to implement getters and setters. It allows you to define methods that act like attributes.

Syntax:

property(fget=None, fset=None, fdel=None, doc=None)

• fget: A function to get the value of the attribute.
• fset: A function to set the value of the attribute.
• fdel: A function to delete the attribute.
• doc: A docstring for the property.

Example with Getters and Setters

This example demonstrates how to use explicit getter and setter methods for private attributes.

class Student:
    def __init__(self, name, score):
        self.__name = name    # Private attribute
        self.__score = score  # Private attribute

    # Getter for name
    def get_name(self):
        return self.__name

    # Setter for name
    def set_name(self, new_name):
        self.__name = new_name

    # Getter for score
    def get_score(self):
        return self.__score

    # Setter for score
    def set_score(self, new_score):
        if new_score >= 0 and new_score <= 100: # Adding validation in setter
            self.__score = new_score
        else:
            print("Score must be between 0 and 100.")

# Creating an instance
s1 = Student("Riya", 92)

# Using getter methods
print("Name:", s1.get_name())
print("Score:", s1.get_score())

# Using setter methods to modify attributes
s1.set_name("Neha")
s1.set_score(95)

print("Updated Name:", s1.get_name())
print("Updated Score:", s1.get_score())

# Example of invalid score
s1.set_score(110)

Output:

Name: Riya
Score: 92
Updated Name: Neha
Updated Score: 95
Score must be between 0 and 100.

Using property() to Create Managed Attributes

Instead of manually calling getter/setter methods, you can define properties that provide a cleaner attribute-like interface. This is often preferred for better encapsulation and control over attribute access.

class Student:
    def __init__(self, name, grade):
        self.__name = name    # Private attribute
        self.__grade = grade  # Private attribute

    # Getter method for name
    def get_name(self):
        return self.__name

    # Setter method for name
    def set_name(self, name):
        self.__name = name

    # Getter method for grade
    def get_grade(self):
        return self.__grade

    # Setter method for grade
    def set_grade(self, grade):
        self.__grade = grade

    # Creating a property named 'name' that uses the get_name and set_name methods
    name = property(get_name, set_name)
    # Creating a property named 'grade' that uses the get_grade and set_grade methods
    grade = property(get_grade, set_grade)

# Creating an instance
s1 = Student("Karan", "A")

# Accessing attributes using the property interface (looks like direct access)
print("Name:", s1.name)
print("Grade:", s1.grade)

# Modifying attributes using the property interface
s1.name = "Tarun"
s1.grade = "B+"

print("Updated Name:", s1.name)
print("Updated Grade:", s1.grade)

Output:

Name: Karan
Grade: A
Updated Name: Tarun
Updated Grade: B+

Note on Decorators: Python also offers the @property and @setter decorators, which are a more concise and commonly used alternative to the property() function for creating managed attributes.

Conclusion

Understanding and applying Python's naming conventions for access modifiers is fundamental to writing well-structured, maintainable, and secure object-oriented code. While Python's access control is not as strictly enforced as in some other languages, adhering to these conventions promotes data integrity and encapsulation, leading to more robust applications. Using property() or the @property decorator enhances this by providing a clean interface for managing access to internal data.

Interview Questions

• What are access modifiers in Python, and how do they differ from those in languages like Java or C++?
• Explain the concepts of public, protected, and private members in Python, providing code examples for each.
• How does Python implement access control without explicit keywords like public, private, or protected?
• What is name mangling in Python, and what is its purpose?
• Is it possible to access a "private" variable from outside the class? If so, how, and under what circumstances might this be done (and why is it generally discouraged)?
• What is the role of the property() function in Python, and how does it aid in encapsulation?
• How do getter and setter methods contribute to encapsulation in Python?
• What are the advantages of using @property and @setter decorators for managing attribute access?
• What is the practical difference between a protected member (_name) and a private member (__name) in Python, beyond just the naming convention?
• When would you choose to use property() (or the @property decorator) over implementing traditional getter and setter methods directly?