Adapter Pattern in Python

Adapter mode is a structural design mode that allows incompatible interfaces to work together. It converts the interface of the class like a "translator", so that the old system connects with the new library without rewriting the logic. Applicable scenarios include reusing existing classes, unified subclass interfaces, encapsulating third-party APIs, etc. In the implementation, the target object is wrapped by creating an adapter class, calling its methods and converting the interface, such as adapting NewLogger to the OldLogger interface with LoggerAdapter. Unlike appearance mode, adapters focus on interface conversion, while appearance focuses on simplifying complex interfaces. Abuse should be avoided when using it and pay attention to clear naming.

Use adapter mode in Python, mainly to enable incompatible interfaces to work together . It is a type of structural design pattern and is often used to avoid large-scale modifications to existing code when system expansion or integration of third-party libraries.

What is Adapter Mode?

Simply put, the adapter pattern is like a "translator", converting the interface of one class into the interface expected by another class. In this way, even if the two classes cannot communicate directly, they can work together.

For example, if you have a logging module for the old system, you want to replace it with a new log library, but the interface of the new library is different from the old one. At this time, you can use an adapter to connect to both sides, instead of rewriting the entire calling logic.

When should I use adapter mode?

Adapter mode is suitable for these situations:

• It is necessary to reuse existing classes, but its interface does not meet the current requirements
• Want to introduce new interface implementation without affecting existing code
• There are differences between multiple subclasses, and we also hope to unify the consistent interfaces that are exposed to the outside world.

Common scenarios include encapsulating third-party APIs, integrating different data formats, bridging new and old systems, etc.

How to implement adapters in Python?

Python's dynamic features make implementing adapters more flexible than static languages. Here is a simple example:

Suppose you have two classes:

 class OldLogger:
    def log_message(self, msg):
        print("OldLogger:", msg)

class NewLogger:
    def write_log(self, level, message):
        print(f"NewLogger [{level}]: {message}")

You want to replace OldLogger with NewLogger , but don't want to change all calls. You can write an adapter:

 class LoggerAdapter:
    def __init__(self, logger):
        self.logger = logger

    def log_message(self, msg):
        self.logger.write_log("INFO", msg)

Then when replacing, just need to do this:

 logger = LoggerAdapter(NewLogger())
logger.log_message("This is a log.")

This will keep the original call method unchanged and access new functions.

What is the difference between an adapter and an appearance mode?

This is also something that many people are prone to confusion. The main difference between the two is the purpose:

• Adapter mode : The focus is on interface conversion , so that existing interfaces can be used compatible.
• Appearance mode : The focus is on simplifying the interface and providing a unified high-level interface for a set of complex interfaces.

For example:

• The adapter is like changing the socket connector for the plug
• It looks like installing a master switch for a bunch of buttons

Therefore, although both are structural models, they are applicable to different occasions.

Tips: Don't abuse the adapter

Although the adapter is practical, there are some things to note:

• Do not overuse it, otherwise it may cause system structure chaos
• Try to be clear in the name so that you can tell at a glance that this is a "middle layer"
• If the parameter order is just different, you can use a wrapper function instead of the complete adapter

Basically that's it. Adapters are not written every day, but they are indeed a very handy gadget when integrating the system or refactoring the code.

The above is the detailed content of Adapter Pattern in Python. For more information, please follow other related articles on the PHP Chinese website!