Python Access Modifiers Explained for Beginners

Introduction

Python is a powerful and easy-to-learn programming language. When working with object-oriented programming (OOP) in Python, understanding Python access modifiers is essential. Access modifiers control the visibility of class attributes and methods, helping developers encapsulate data and protect it from unwanted access. In this blog, we’ll explore Python’s access modifiers, their types, and how to use them effectively.

What are Access Modifiers?

Access modifiers are keywords or conventions that define the scope of access for class members (attributes and methods). They determine whether a variable or method can be accessed:

• Within the same class
• By derived classes
• Outside the class

Python supports three types of access modifiers:

1. Public
2. Protected
3. Private

1. Public Access Modifier

• Definition: Public members are accessible from anywhere, both inside and outside the class.
• Syntax: No underscore prefix is required.

Example:

class Car:
    def __init__(self, model, color):
        self.model = model    # Public attribute
        self.color = color    # Public attribute

    def display(self):
        print(f"Car Model: {self.model}, Color: {self.color}")

# Create object
car1 = Car("Toyota", "Red")

# Access public attributes and method
print(car1.model)       # Output: Toyota
car1.display()          # Output: Car Model: Toyota, Color: Red

Key Points:

• Public members are default in Python.
• They can be freely accessed inside and outside the class.

---

2. Protected Access Modifier

• Definition: Protected members are intended to be accessible only within the class and its subclasses.
• Syntax: Prefix the member name with a single underscore _.

Example:

class Vehicle:
    def __init__(self, type):
        self._type = type   # Protected attribute

    def _display_type(self): # Protected method
        print(f"Vehicle Type: {self._type}")

class Bike(Vehicle):
    def show(self):
        print("Accessing protected member inside subclass:")
        self._display_type()

v = Vehicle("Car")
b = Bike("Motorbike")

# Access protected member outside class (possible but not recommended)
print(v._type)  # Output: Car

# Access protected member in subclass
b.show()        # Output: Vehicle Type: Motorbike

Key Points:

• Python does not enforce strict protection, it’s more of a convention.
• Protected members are meant for internal use in classes and subclasses.

3. Private Access Modifier

• Definition: Private members are accessible only within the class.
• Syntax: Prefix the member name with double underscores __.

Example:

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance   # Private attribute

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

    def get_balance(self):
        return self.__balance

account = BankAccount(1000)

# Access private member directly (will raise AttributeError)
# print(account.__balance)

# Access through public method
account.deposit(500)
print(account.get_balance())  # Output: 1500

Key Points:

• Private members use name mangling to prevent direct access outside the class.
• Accessing __balance directly as account.__balance will fail.
• You can access it using _ClassName__attribute but it’s not recommended.

Why Use Access Modifiers?

1. Encapsulation: Protect sensitive data inside classes.
2. Data Integrity: Prevent accidental modification from outside the class.
3. Better Code Organization: Clarifies which members are meant for internal use.
4. Security: Hides critical information from external access.

Quick Summary Table

Modifier	Prefix	Access Level
Public	None	Accessible everywhere
Protected	_	Accessible in class and subclasses (convention)
Private	__	Accessible only inside the class (name mangling)

Best Practices

• Use public members for data or methods that need to be accessed by users of the class.
• Use protected members for variables or methods meant for internal use and inheritance.
• Use private members for sensitive data like passwords or bank balances.
• Avoid relying on Python’s protection; always follow naming conventions to maintain clean code.

Conclusion

Understanding Python access modifiers is crucial for writing clean, secure, and maintainable object-oriented code. While Python does not enforce strict access rules like some other languages, following these conventions helps you protect data, structure your classes, and prevent unintended usage.

By mastering public, protected, and private members, beginners can write Python programs that are robust, scalable, and professional.