Encapsulation in Python Explained with Code

python
class Student:
    def __init__(self, name, age):
        self.name = name        # Public attribute
        self.age = age          # Public attribute
    
    def display_info(self):     # Public method
        print(f"Name: {self.name}, Age: {self.age}")

# Creating object and accessing public members
student1 = Student("John", 20)
print(student1.name)            # Accessing public attribute
student1.display_info()        # Calling public method

python
class BankAccount:
    def __init__(self, account_number, balance):
        self.account_number = account_number
        self._balance = balance          # Protected attribute
    
    def _calculate_interest(self):       # Protected method
        return self._balance * 0.05
    
    def get_balance(self):
        return self._balance

# Usage
account = BankAccount("12345", 1000)
print(account.get_balance())             # Proper way to access balance
print(account._balance)                  # Can access but shouldn't (convention)

python
class SecureAccount:
    def __init__(self, account_number, pin):
        self.account_number = account_number
        self.__pin = pin                 # Private attribute
        self.__balance = 0               # Private attribute
    
    def __validate_pin(self, entered_pin):  # Private method
        return self.__pin == entered_pin
    
    def withdraw(self, amount, pin):
        if self.__validate_pin(pin):
            if amount <= 1000 self.__balance: self.__balance -="amount" return true false def deposit(self, amount, pin): if self.__validate_pin(pin): +="amount" get_balance(self, let's create a comprehensive example that demonstrates encapsulation in python using an employee management system: pythonclass employee: __init__(self, emp_id, name, salary, department): self.emp_id="emp_id" # public self.name="name" name self._department="department" protected department info self.__salary="salary" private sensitive salary data self.__performance_score="0" internal metric method to get get_employee_info(self): f"id: {self.emp_id}, name: {self.name}, dept: {self._department}" with controlled access get_salary_range(self): < 30000: "junior level" elif 60000: "mid else: "senior for calculations _calculate_bonus(self): base_bonus="self.__salary" * 0.1 performance_bonus="self.__performance_score" operations __update_salary(self, new_salary): new_salary> 0:
            self.__salary = new_salary
            return True
        return False
    
    # Public method to safely update salary (with validation)
    def promote_employee(self, raise_percentage, manager_approval=False):
        if manager_approval and 0 < raise_percentage <= 0 50: new_salary="self.__salary" * (1 + raise_percentage 100) return self.__update_salary(new_salary) false # public method to set performance (with validation) def set_performance_score(self, score): if <="score" self.__performance_score="score" true get total compensation get_total_compensation(self): self.__salary self._calculate_bonus() usage example emp1='Employee("E001",' "alice johnson", 45000, "engineering") accessing members print(emp1.get_employee_info()) protected member (not recommended but possible) print(f"department: {emp1._department}") proper way work with private data emp1.set_performance_score(8) print(f"salary range: {emp1.get_salary_range()}") print(f"total compensation: ${emp1.get_total_compensation()}") secure salary update result="emp1.promote_employee(10," manager_approval="True)" print(f"promotion successful: {result}") self.__balance "access denied" account='SecureAccount("67890",' "1234") account.deposit(500, print(account.get_balance("1234")) correct access print(account.__pin) this would cause an error pre>
                    

python
class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius
    
    @property
    def celsius(self):
        """Getter method for celsius"""
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        """Setter method for celsius with validation"""
        if value < -273.15:
            raise ValueError("Temperature cannot be below absolute zero")
        self._celsius = value
    
    @property
    def fahrenheit(self):
        """Computed property for fahrenheit"""
        return (self._celsius * 9/5) + 32
    
    @fahrenheit.setter
    def fahrenheit(self, value):
        """Setter for fahrenheit that updates celsius"""
        if value < -459.67:
            raise ValueError("Temperature cannot be below absolute zero")
        self._celsius = (value - 32) * 5/9
    
    @property
    def kelvin(self):
        """Computed property for kelvin"""
        return self._celsius + 273.15

# Usage
temp = Temperature(25)
print(f"Celsius: {temp.celsius}")
print(f"Fahrenheit: {temp.fahrenheit}")
print(f"Kelvin: {temp.kelvin}")

# Setting temperature using different scales
temp.fahrenheit = 100
print(f"New Celsius: {temp.celsius}")

# Validation in action
try:
    temp.celsius = -300  # This will raise an error
except ValueError as e:
    print(f"Error: {e}") 

python
class FileManager:
    def __init__(self, filename, mode):
        self.__filename = filename
        self.__mode = mode
        self.__file = None
        self.__is_open = False
    
    def __enter__(self):
        """Context manager entry"""
        try:
            self.__file = open(self.__filename, self.__mode)
            self.__is_open = True
            return self.__file
        except IOError as e:
            print(f"Error opening file: {e}")
            return None
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        """Context manager exit"""
        if self.__is_open and self.__file:
            self.__file.close()
            self.__is_open = False
    
    def is_open(self):
        """Public method to check file status"""
        return self.__is_open
    
    def get_filename(self):
        """Public method to get filename"""
        return self.__filename

# Usage
with FileManager("example.txt", "w") as file:
    if file:
        file.write("This demonstrates encapsulation!")

python
class ShoppingCart:
    def __init__(self, customer_name):
        self.customer_name = customer_name
        self._items = []                    # Protected - internal list
        self.__total_amount = 0             # Private - sensitive data
        self.__discount_rate = 0            # Private - business logic
    
    def add_item(self, item_name, price, quantity=1):
        """Public method to add items with validation"""
        if price <= 0 or quantity <="0:" return false item="{" 'name': item_name, 'price': price, 'quantity': quantity, 'subtotal': price * } self._items.append(item) self.__calculate_total() true def remove_item(self, item_name): """public method to remove items""" for in self._items: if item['name']="=" item_name: self._items.remove(item) __calculate_total(self): """private internal calculations""" self.__total_amount="sum(item['subtotal']" self._items) _apply_discount(self, discount_rate): """protected discount # max 50% self.__discount_rate="discount_rate" apply_coupon(self, coupon_code): apply with validation""" coupon_discounts="{" 'save10': 0.10, 'save20': 0.20, 'welcome': 0.15 coupon_code coupon_discounts: self._apply_discount(coupon_discounts[coupon_code]) get_total(self): get final total""" discount_amount="self.__total_amount" - get_cart_summary(self): cart details""" summary='f"Cart' {self.customer_name}:\n" +='f"-' {item['name']}: ${item['price']} x {item['quantity']}='${item['subtotal']}\n"' ${self.__total_amount}\n"> 0:
            discount_amount = self.__total_amount * self.__discount_rate
            summary += f"Discount ({self.__discount_rate*100}%): -${discount_amount}\n"
        summary += f"Total: ${self.get_total()}"
        return summary

# Usage example
cart = ShoppingCart("John Doe")
cart.add_item("Laptop", 999.99, 1)
cart.add_item("Mouse", 29.99, 2)
cart.apply_coupon("SAVE10")

print(cart.get_cart_summary())