Encapsulation and abstraction are two fundamental principles of object-oriented programming (OOP) that help manage complexity by organizing code in a systematic way.

### Encapsulation

Encapsulation is the concept of wrapping data (attributes) and methods (functions that can operate on the data) into a single unit called a class. It restricts direct access to some of the object’s components, which can prevent the accidental modification of data. This makes the code more secure and easier to maintain.

In Python, encapsulation is achieved using private or protected attributes:

– **Private Attributes**: These are typically denoted by a double underscore, e.g., `__attribute`. They are not accessible directly from outside the class and are used to hide the implementation details.

– **Protected Attributes**: These are denoted by a single underscore, e.g., `_attribute`. Though they are accessible from outside the class, they are intended for use only within the class and its subclasses.

### Abstraction

Abstraction focuses on exposing only the necessary parts of the code and hiding the implementation details to reduce complexity. It allows the programmer to focus on interacting with an object at a higher level without worrying about the inner workings.

### Private and Protected Attributes Example

Below is an example of a class `PaymentProcessor` using encapsulation:

“`python
class PaymentProcessor:
def __init__(self, gateway):
self.__gateway = gateway # Private attribute

def process_payment(self, amount):
if self.__validate(amount):
self.__execute_transaction(amount)
else:
print(“Invalid payment amount”)

def __validate(self, amount): # Private method
return amount > 0

def __execute_transaction(self, amount): # Private method
print(f”Processing payment of ${amount} through {self.__gateway}”)

processor = PaymentProcessor(‘PayPal’)
processor.process_payment(100)
“`

In this example:
– `__gateway`, `__validate`, and `__execute_transaction` are private, which means they cannot be accessed directly outside the class. This encapsulates the details of how payments are processed.

### Abstract Classes with `abc` Module

Abstract classes in Python are a way to enforce a common interface across multiple implementations. They can define methods that must be created within any subclass derived from the abstract class. The `abc` module provides the tools to create abstract classes.

Here’s an example of using abstract classes in a payment processing system:

“`python
from abc import ABC, abstractmethod

class PaymentGateway(ABC):
@abstractmethod
def process(self, amount):
pass

@abstractmethod
def refund(self, amount):
pass

class PayPal(PaymentGateway):
def process(self, amount):
print(f”Processing ${amount} using PayPal gateway.”)

def refund(self, amount):
print(f”Refunding ${amount} using PayPal gateway.”)

class Stripe(PaymentGateway):
def process(self, amount):
print(f”Processing ${amount} using Stripe gateway.”)

def refund(self, amount):
print(f”Refunding ${amount} using Stripe gateway.”)

# The following code will raise an error if you try to instantiate PaymentGateway
# gateway = PaymentGateway() # This would raise TypeError

paypal_gateway = PayPal()
paypal_gateway.process(100)
paypal_gateway.refund(50)

stripe_gateway = Stripe()
stripe_gateway.process(200)
stripe_gateway.refund(100)
“`

In this example:
– `PaymentGateway` is an abstract class with two abstract methods `process` and `refund`. Any subclass must implement these methods.
– `PayPal` and `Stripe` are concrete implementations of the `PaymentGateway`.
– Trying to instantiate `PaymentGateway` directly results in an error, enforcing that only complete implementations are used.

These examples showcase how encapsulation and abstraction promote organized code structure, hide implementation details, and enforce consistent APIs across different parts of an application.