Python Encapsulation and Abstraction CL-22

Python Encapsulation and Abstraction

Introduction to Object-Oriented Programming (OOP)

Introduction to OOP: Object-Oriented Programming, often abbreviated as OOP, is a way of writing computer programs using a concept called "objects." It's like a blueprint for creating things in the digital world. These objects have attributes (characteristics) and behaviors (actions) just like real-world objects.

Example: Real-world vs. OOP: Imagine you're building a car. In the real world, a car has attributes like color, make, and model, and it can perform actions like starting, stopping, and honking the horn. In OOP, you'd create a "Car" object with attributes (color, make, model) and behaviors (start, stop, honk).

Encapsulation and Abstraction: 

Two essential principles in OOP are encapsulation and abstraction.


Encapsulation is like putting your car's engine under a hood. It hides the complex parts and only shows what's necessary. In OOP, we group data (attributes) and actions (methods) together in objects. We use classes to define these objects.

Example: Encapsulation in Python:
class Car: def __init__(self, color, make, model): self.color = color # Attributes self.make = make self.model = model def start(self): print("Car started") # Method def stop(self): print("Car stopped") my_car = Car("Red", "Toyota", "Camry") print(my_car.color) # Accessing attributes my_car.start() # Calling a method


Abstraction is like driving a car without knowing how the engine works. You don't need to understand the internal details to use it. In OOP, we create abstract classes and methods that define what an object should do without specifying how it does it. Subclasses provide the actual implementation.

Example: Abstraction in Python:
from abc import ABC, abstractmethod class Vehicle(ABC): # Abstract class @abstractmethod def start(self): pass @abstractmethod def stop(self): pass class Car(Vehicle): # Concrete class def start(self): print("Car started") def stop(self): print("Car stopped") my_car = Car() my_car.start() my_car.stop()

In summary, OOP helps us organize code by modeling real-world entities as objects with attributes and behaviors. Encapsulation groups data and methods, and abstraction lets us define what objects should do without worrying about how they do it. These principles make our code more organized and easier to work with.

Encapsulation in details

Encapsulation in programming is like putting your belongings in a bag or a box. It's about bundling data (attributes) and methods (functions) that work with that data into a single unit called a class. Think of a class as a container that holds everything related to a specific concept or object.

Importance of Encapsulation:

Now, let's understand why encapsulation is essential:
Data Hiding: Imagine you have a wallet. You don't want everyone to see how much money you have in it. Similarly, in programming, you don't want every part of your code to access and modify your data directly. Encapsulation allows you to hide some data, so it's not easily accessible from outside the class.

Data Protection: Just like you don't want anyone to take money from your wallet without permission, you don't want data to be modified in unexpected ways. Encapsulation helps protect your data by controlling how it can be changed.

Encapsulation in Python:

In Python, encapsulation is achieved by using classes and access control modifiers. These modifiers specify who can access the data and methods within a class.

There are three main access control modifiers in Python:
Public (Default): Public attributes and methods can be accessed from anywhere.

Private (Using a Double Underscore Prefix): Private attributes and methods are meant to be accessed only from within the class, and their names are indicated by a double underscore prefix (e.g., __my_variable). Python uses name mangling to make it slightly more difficult to access these attributes from outside the class.

Protected (Using a Single Underscore Prefix): Protected attributes and methods are meant to be treated as non-public parts of the API, but they can still be accessed from outside the class. Their names are indicated by a single underscore prefix (e.g., _my_variable). It's a convention to signal that they should not be accessed directly, but it's not enforced by the Python interpreter.

Let's create a simple class to demonstrate encapsulation and access control modifiers in Python:
class Person: def __init__(self, name, age): = name # Public attribute self._age = age # Protected attribute self.__salary = 0 # Private attribute def get_salary(self): return self.__salary def set_salary(self, salary): if salary > 0: self.__salary = salary def display_info(self): print(f"Name: {}") print(f"Age: {self._age}") print(f"Salary: {self.get_salary()}") # Creating an object person = Person("Alice", 30) # Accessing public attributes print( # Output: Alice # Accessing protected attributes print(person._age) # Output: 30 # Accessing private attributes using a getter method print(person.get_salary()) # Output: 0 # Modifying private attributes using a setter method person.set_salary(50000) # Displaying information person.display_info()

In this example, we've used public, protected, and private attributes, along with getter and setter methods to control access to the private attribute __salary. Encapsulation helps us manage data access and modification effectively while maintaining data integrity.

Access Control Modifiers in Python:

In Python, access control modifiers are used to control the visibility and accessibility of class attributes and methods. These modifiers help define the level of encapsulation and protection for the members of a class. Let's dive deeper into the access control modifiers in Python:

1. Public:
Definition: Public members (attributes and methods) are accessible from anywhere, both within and outside the class.
class MyClass: def __init__(self): self.public_var = "This is a public variable" def public_method(self): return "This is a public method" obj = MyClass() # Accessing public variable and method print(obj.public_var) # Output: This is a public variable print(obj.public_method()) # Output: This is a public method

In this example, public_var and public_method are public members and can be accessed freely.

2. Private (underscore prefix): 
Definition: Private members are not meant to be accessed directly from outside the class. They are indicated by a single underscore prefix (e.g., _my_variable).
class MyClass: def __init__(self): self._private_var = "This is a private variable" def _private_method(self): return "This is a private method" obj = MyClass() # Accessing private variable and method (not recommended) print(obj._private_var) # Output: This is a private variable print(obj._private_method()) # Output: This is a private method

In Python, you can still access private members, but it's a convention that they should not be accessed directly from outside the class.

3. Protected (underscore prefix): 
Definition: Protected members are slightly less restrictive than private members. They are meant to be accessed by subclasses or within the same module. They are also indicated by a single underscore prefix (e.g., _my_variable).
class MyBaseClass: def __init__(self): self._protected_var = "This is a protected variable" def _protected_method(self): return "This is a protected method" class MyDerivedClass(MyBaseClass): def __init__(self): super().__init__() obj = MyDerivedClass() # Accessing protected variable and method from a subclass print(obj._protected_var) # Output: This is a protected variable print(obj._protected_method()) # Output: This is a protected method

Protected members can be accessed from subclasses, but it's still a convention not to access them from outside the class or subclass.

Name Mangling for Private Attributes:

Python uses a technique called name mangling to make private attributes less accessible but still possible to access. Name mangling involves adding the class name as a prefix to the private attribute's name.

Example of using name mangling for private attributes:
class MyClass: def __init__(self): self.__private_var = "This is a private variable" obj = MyClass() # Accessing private variable using name mangling print(obj._MyClass__private_var) # Output: This is a private variable

In this example, __private_var is name-mangled to _MyClass__private_var, making it less likely to be accidentally accessed outside the class.

It's important to note that while Python provides these access control mechanisms, they are primarily based on conventions and not strict access restrictions enforced by the language. Developers are expected to follow these conventions to maintain code integrity and readability.

Abstraction in Details

Abstraction is like looking at a complex object and focusing only on the most important aspects while ignoring the less important details. In programming, it's the process of simplifying complex reality by modeling classes based on the essential properties and behaviors of objects. Abstraction allows us to hide the unnecessary details of an object and expose only what's relevant.

How Abstraction Works:

Imagine you're driving a car. You don't need to understand how the engine works or the intricate details of the transmission. Instead, you interact with a simplified interface - the steering wheel, pedals, and dashboard. This interface abstracts away the complex mechanics of the car, allowing you to focus on driving. 

Similarly, in programming: We create classes that represent objects, and these classes contain attributes (properties) and methods (actions). Abstraction lets us define what these classes should do without worrying about how they do it.

Abstract Classes and Methods in Python (Using the ABC Module):

In Python, we can use abstract classes and abstract methods to implement abstraction. We do this using the abc module (Abstract Base Classes). An abstract class is like a blueprint for other classes. It defines a set of methods that must be implemented by any concrete (non-abstract) subclass.

Let's create an abstract class Shape that defines an abstract method area(). We'll then create concrete subclasses Circle and Rectangle that inherit from Shape and provide their implementations of the area() method.
from abc import ABC, abstractmethod # Abstract class class Shape(ABC): @abstractmethod def area(self): pass # Concrete subclass 1 class Circle(Shape): def __init__(self, radius): self.radius = radius def area(self): return 3.1415 * self.radius ** 2 # Concrete subclass 2 class Rectangle(Shape): def __init__(self, width, height): self.width = width self.height = height def area(self): return self.width * self.height # Creating objects circle = Circle(5) rectangle = Rectangle(4, 6) # Calling the area method for each object print("Area of Circle:", circle.area()) # Output: Area of Circle: 78.53750000000001 print("Area of Rectangle:", rectangle.area()) # Output: Area of Rectangle: 24

In this example: Shape is an abstract class with the abstract method area().
Circle and Rectangle are concrete subclasses that inherit from Shape and provide their own implementations of the area() method.
We create objects of these subclasses and call the area() method to calculate the areas of a circle and a rectangle.

Abstraction helps us define a common interface (area() in this case) for different shapes, and concrete subclasses provide their specific implementations. This simplifies complex concepts, making code more organized and easier to understand.

Practical Examples of Encapsulation and Abstraction:

Scenario 1: Banking System

In a banking system, encapsulation helps protect sensitive customer data. Let's say we have a BankAccount class:
class BankAccount: def __init__(self, account_number, balance): self._account_number = account_number # Protected attribute self._balance = balance # Protected attribute def deposit(self, amount): if amount > 0: self._balance += amount def withdraw(self, amount): if amount > 0 and self._balance >= amount: self._balance -= amount # Getter method for balance def get_balance(self): return self._balance

We abstract the concept of a bank account, hiding the internal details of transactions. Users interact with deposit and withdrawal methods, not the account number or balance directly.
account = BankAccount("12345", 1000) account.deposit(500) account.withdraw(200) print("Account Balance:", account.get_balance()) # Output: Account Balance: 1300

Encapsulation ensures data integrity by controlling access to account details.
Abstraction simplifies the user experience, making it easy to deposit and withdraw funds.

Scenario 2: Vehicle Management System

In a vehicle management system, encapsulation ensures that vehicle data is protected. Here's a simplified Vehicle class:
class Vehicle: def __init__(self, make, model): self._make = make # Protected attribute self._model = model # Protected attribute # Getter method for make def get_make(self): return self._make # Setter method for model def set_model(self, model): self._model = model

Abstraction allows us to create different types of vehicles without worrying about the internal details. Subclasses like Car and Motorcycle provide specific implementations:
class Car(Vehicle): def __init__(self, make, model, doors): super().__init__(make, model) self._doors = doors class Motorcycle(Vehicle): def __init__(self, make, model, engine_type): super().__init__(make, model) self._engine_type = engine_type

Encapsulation ensures that make and model are protected.
Abstraction allows us to create various vehicle types with different properties.

  • Encapsulation protects data integrity by controlling access to attributes (e.g., account_number, balance).
  • Abstraction simplifies code by hiding complex details and providing a clear interface (e.g., deposit, withdraw).
  • Getter and setter methods (e.g., get_balance, set_model) enable controlled access to attributes.
  • Benefits include code readability, reusability (e.g., creating different types of vehicles), and extensibility (e.g., adding more features to banking or vehicle management systems) while keeping the internal complexity hidden.

Post a Comment

Previous Post Next Post