如何在 Python 中的模块之间共享相同的 object

Question

I'm creating a simple logging module (I'm aware of logging , let me reinvent the wheel, one simpler, suited to my needs and on top of everything that allows me to learn in the way I make it).

I'm trying to mimic the API of logging , thus the core of the logging system is a Logger instance that contains a list of handlers , which eventually deliver the info either through the console (via a StreamHandler object) or to text files (via a FileHandler object). These classes are all defined in a module, which I import to the main program and the libraries I want to use logging on.

The problem is that I'd like to define the logger just once , in the main program, and use it across the modules I import. I do not want to define different loggers not only because I'd like to set the logging setup once, but also because this object includes the handling of files, and I'd like to make this centralised, not with various objects adding lines to the same file from different places.

What's the most pythonic way to define this pattern?

Answer 1

you can define the logger in a class and use singleton pattern to be sure that the class will be instantiated only owns:

class SingletonMeta(type):
    """
    The Singleton class can be implemented in different ways in Python. Some
    possible methods include: base class, decorator, metaclass. We will use the
    metaclass because it is best suited for this purpose.
    """

    _instances = {}

    def __call__(cls, *args, **kwargs):
        """
        Possible changes to the value of the `__init__` argument do not affect
        the returned instance.
        """
        if cls not in cls._instances:
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        return cls._instances[cls]


class Singleton(metaclass=SingletonMeta):
    def some_business_logic(self):
        """
        Finally, any singleton should define some business logic, which can be
        executed on its instance.
        """

        # ...


if __name__ == "__main__":
    # The client code.

    s1 = Singleton()
    s2 = Singleton()

    if id(s1) == id(s2):
        print("Singleton works, both variables contain the same instance.")
    else:
        print("Singleton failed, variables contain different instances.")

or you can define your logger as a class and use a decorator (cache method):

def memoize(function):
  memo = {}
  def wrapper(*args):
    if args in memo:
      return memo[args]
    else:
      rv = function(*args)
      memo[args] = rv
      return rv
  return wrapper


class log:
    def __init__(self):
       ....
    def methdo(self):
       return logger

@memorize
def create_logger():

  return log.method()