Explain the open/closed principle within SOLID.

Modules (classes, functions) should be open for extension but closed for modification.

• Open for extension: New functionality can be added without changing existing code. This is achieved through inheritance, interfaces, abstract classes, and design patterns (e.g., Strategy, Decorator).
• Closed for modification: Changes to existing code should require minimal effort or none at all when adding new functionality. This reduces the risk of introducing errors into already working code and simplifies maintenance.

Example:

Instead of tightly coupling to a specific implementation, use abstraction:

# Violation of the principle
class ReportGenerator:
    def generate_pdf(self, data):
        # PDF generation logic
        pass

    def generate_excel(self, data):
        # Excel generation logic
        pass

# Adding a new format (e.g., CSV) requires modifying the ReportGenerator class

# Adherence to the principle
class ReportGenerator:
    def __init__(self, report_format):
        self.report_format = report_format

    def generate_report(self, data):
        self.report_format.generate(data)

class ReportFormat:
    def generate(self, data):
        pass

class PdfReportFormat(ReportFormat):
    def generate(self, data):
        # PDF generation logic
        pass

class ExcelReportFormat(ReportFormat):
    def generate(self, data):
        # Excel generation logic
        pass

class CsvReportFormat(ReportFormat): # Easily add a new format without changing ReportGenerator
    def generate(self, data):
        # CSV generation logic
        pass

# Usage
pdf_generator = ReportGenerator(PdfReportFormat())
excel_generator = ReportGenerator(ExcelReportFormat())
csv_generator = ReportGenerator(CsvReportFormat())

This principle promotes creating more flexible, change-resistant, and easily maintainable systems.