Can you explain the dependency inversion principle and its role in software system design?

The Dependency Inversion Principle (DIP) is one of the five SOLID principles, which states that:

• High-level modules should not depend on low-level modules. Both should depend on abstractions.
• Abstractions should not depend on details. Details should depend on abstractions.

This means that instead of a class directly creating or using specific implementations of dependencies, it should work through abstractions (such as interfaces or abstract classes). This increases flexibility and makes testing easier, as dependencies can be easily replaced with other implementations or mocks.

Example in Python:

from abc import ABC, abstractmethod

class Database(ABC):
    @abstractmethod
    def save(self, data):
        pass

class MySQLDatabase(Database):
    def save(self, data):
        print(f"Saving {data} to MySQL")

class UserService:
    def __init__(self, db: Database):
        self.db = db

    def create_user(self, user_data):
        # User creation logic
        self.db.save(user_data)

# Usage
mysql_db = MySQLDatabase()
service = UserService(mysql_db)
service.create_user({'name': 'Alice'})

Here, UserService depends on the abstraction Database, not on the specific implementation MySQLDatabase. This allows for easy swapping of the database without changing UserService.