Master Python Encapsulation: Classes, Private Attributes, Getters & Setters

Concept

Encapsulation is a core object‑oriented principle that binds data (attributes) and the functions that manipulate that data (methods) inside a class, exposing only a limited public interface. It improves code reuse, maintainability, and safety.

Key elements:

Class : Blueprint defining attributes and methods.

Object : Instance of a class with its own state.

Attributes : Variables that store data, typically initialized in __init__.

Methods : Functions defined in a class; the first parameter is usually self to access the instance.

Python does not enforce strict access modifiers, but naming conventions convey intent: _single_leading_underscore: Indicates a protected member, discouraged from external use. __double_leading_underscore: Triggers name mangling to make the member harder to access from subclasses, providing a form of pseudo‑private protection.

Getter and setter methods allow controlled access to attributes, enabling validation or additional logic.

Example: BankAccount

class BankAccount:
    def __init__(self, balance=0):
        self.__balance = balance  # private attribute
    def deposit(self, amount):
        """Add amount to balance"""
        if amount > 0:
            self.__balance += amount
        else:
            print("Deposit amount must be greater than 0")
    def withdraw(self, amount):
        """Subtract amount from balance"""
        if 0 < amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Insufficient funds or invalid amount")
    def get_balance(self):  # getter
        return self.__balance

account = BankAccount(100)
account.deposit(50)   # valid operation
account.withdraw(150)  # triggers error message
print(account.get_balance())  # retrieve balance via getter

The BankAccount class hides the balance using a double‑underscore attribute and provides public methods for deposit, withdrawal, and balance retrieval.

Simple Encapsulation: Circle

class Circle:
    def __init__(self, radius):
        self.radius = radius  # public attribute
    def area(self):
        """Return the area of the circle"""
        return 3.14 * (self.radius ** 2)

circle = Circle(5)
print(circle.area())  # outputs the area

This example shows a straightforward class where the attribute is public and the method computes a derived value.

Private Attributes and Methods: Temperature

class Temperature:
    def __init__(self, celsius):
        self.__celsius = celsius  # private attribute
    def __to_fahrenheit(self):  # private method
        return (self.__celsius * 9/5) + 32
    def convert_to_fahrenheit(self):
        """Public method that uses the private conversion"""
        return self.__to_fahrenheit()

temp = Temperature(25)
print(temp.convert_to_fahrenheit())  # prints Fahrenheit value

The class hides the Celsius value and the conversion logic, exposing only a clean public interface.

Getter and Setter: Employee

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.__salary = salary  # private attribute
    def get_salary(self):  # getter
        return self.__salary
    def set_salary(self, value):  # setter with validation
        if value >= 0:
            self.__salary = value
        else:
            print("Salary cannot be negative.")

emp = Employee("Alice", 50000)
print(emp.get_salary())  # get salary
emp.set_salary(-1000)    # attempts invalid update
print(emp.get_salary())  # salary remains unchanged

Using getters and setters enables validation before mutating private data.

Property Decorator: Car

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
    @property
    def age(self):  # property getter
        return 2023 - self.year

car = Car("Toyota", "Camry", 2018)
print(car.age)  # accesses age as an attribute

The @property decorator provides a Pythonic way to expose computed attributes without explicit getter calls.

Inheritance and Encapsulation

class Animal:
    def __init__(self, name):
        self._name = name  # protected attribute
    def speak(self):
        pass  # abstract method

class Dog(Animal):
    def speak(self):
        return f"{self._name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self._name} says Meow!"

dog = Dog("Buddy")
cat = Cat("Whiskers")
print(dog.speak())
print(cat.speak())

Subclasses inherit the protected _name attribute and implement their own speak behavior, illustrating how inheritance works together with encapsulation.