Используйте метакласс

Я бы порекомендовал метод 2, но лучше использовать метакласс, чем базовый класс. Вот пример реализации:

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]
        
class Logger(object):
    __metaclass__ = Singleton

Или в Python3

class Logger(metaclass=Singleton):
    pass

Если вы хотите запускать __init__ каждый раз при вызове класса, добавьте

        else:
            cls._instances[cls].__init__(*args, **kwargs)

к заявлению if в Singleton.__call__.

Несколько слов о метаклассах. Метакласс - это класс класса; то есть класс является экземпляром своего метакласса. Вы найдете метакласс объекта в Python с помощью type(obj). Обычные классы нового стиля относятся к типу type. Logger в приведенном выше коде будет иметь тип class 'your_module.Singleton', так же как (единственный) экземпляр Logger будет иметь тип class 'your_module.Logger'. Когда вы вызываете регистратор с Logger(), Python сначала спрашивает метакласс Logger, Singleton, что делать, что позволяет упредить создание экземпляра. Этот процесс аналогичен тому, что Python спрашивает класс, что делать, вызывая __getattr__, когда вы ссылаетесь на один из его атрибутов, выполняя myclass.attribute.

Метакласс по существу решает, что означает определение класса и как реализовать это определение. См., Например, http://code.activestate.com/recipes/498149/, который по существу воссоздает struct в стиле C в Python с помощью метаклассов. Поток Какие (конкретные) варианты использования metaclasses? также предоставляет несколько примеров, они обычно, кажется, связаны с декларативным программированием, особенно используемым в ORM.

В этой ситуации, если вы используете свой метод 2, а подкласс определяет метод __new__, он будет выполняться каждый раз, когда вы вызываете SubClassOfSingleton(), поскольку он отвечает за вызов метода, возвращающего сохраненный экземпляр. В случае метакласса он будет вызываться только один раз при создании единственного экземпляра. Вы хотите настроить то, что означает вызов класса, в зависимости от его типа.

В общем, имеет смысл использовать метакласс для реализации синглтона. Синглтон является особенным, потому что создается только один раз, а метакласс - это способ настройки создания класса. Использование метакласса дает вам больше контроля на случай, если вам потребуется настроить определения одноэлементного класса другими способами.

Вашим синглетонам не потребуется множественное наследование (поскольку метакласс не является базовым классом), но для подклассов созданного класса, которые используют множественное наследование, необходимо убедиться, что одноэлементный класс - это первый / крайний левый класс с метаклассом, который переопределяет __call__. Это маловероятно. Экземпляр dict не находится в пространстве имен экземпляра, поэтому он случайно не перезапишет его.

Вы также услышите, что шаблон singleton нарушает принцип единой ответственности - каждый класс должен делать только одно. Таким образом, вам не нужно беспокоиться о том, что код может испортить одно, если вам нужно изменить другое, потому что они разделены и инкапсулированы. Реализация метакласса проходит этот тест. Метакласс отвечает за соблюдение шаблона, и созданный класс и подклассы не должны быть осведомлены о том, что они одиночные. Метод №1 не проходит этот тест, поскольку вы заметили, что MyClass сам по себе является функцией, а не классом, поэтому вы не можете вызывать из него методы класса.

Версия, совместимая с Python 2 и 3

Чтобы написать что-то, что работает как на Python2, так и на Python 3, потребуется немного более сложная схема. Поскольку метаклассы обычно являются подклассами типа type, можно использовать один для динамического создания промежуточного базового класса во время выполнения с его метаклассом, а затем использовать этот в качестве базового класса общедоступного базового класса Singleton. Объяснить труднее, чем сделать, как показано ниже:

# works in Python 2 & 3
class _Singleton(type):
    """ A metaclass that creates a Singleton base class when called. """
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(_Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class Singleton(_Singleton('SingletonMeta', (object,), {})): pass

class Logger(Singleton):
    pass

Ирония этого подхода заключается в том, что он использует подклассы для реализации метакласса. Одно из возможных преимуществ состоит в том, что, в отличие от чистого метакласса, isinstance(inst, Singleton) вернет True.

Исправления

Что касается другой темы, вы, вероятно, уже заметили это, но реализация базового класса в вашем исходном сообщении неверна. _instances необходимо указать в классе, вам нужно использовать super(), иначе вы рекурсивно, а __new__ на самом деле является статическим методом, которому вы должны передать class к, а не к методу класса, поскольку фактический класс еще не был создан на момент его вызова. Все это будет справедливо и для реализации метакласса.

class Singleton(object):
  _instances = {}
  def __new__(class_, *args, **kwargs):
    if class_ not in class_._instances:
        class_._instances[class_] = super(Singleton, class_).__new__(class_, *args, **kwargs)
    return class_._instances[class_]

class MyClass(Singleton):
  pass

c = MyClass()

Декоратор, возвращающий класс

Изначально я писал комментарий, но он был слишком длинным, поэтому я добавлю его сюда. Метод №4 лучше, чем другая версия декоратора, но в нем больше кода, чем требуется для синглтона, и не так ясно, что он делает.

Основные проблемы связаны с тем, что этот класс является собственным базовым классом. Во-первых, не странно ли, что класс является подклассом почти идентичного класса с тем же именем, который существует только в его атрибуте __class__? Это также означает, что вы не можете определить какие-либо методы, которые вызывают метод с тем же именем в своем базовом классе с super(), потому что они будут рекурсивными. Это означает, что ваш класс не может настраивать __new__ и не может быть производным от каких-либо классов, для которых требуется __init__ вызов.

Когда использовать шаблон singleton

Ваш вариант использования - один из лучших примеров использования синглтона. Вы говорите в одном из комментариев. «Мне логгинг всегда казался естественным кандидатом в синглтоны». Вы абсолютно правы.

Когда люди говорят, что синглтоны - это плохо, наиболее частая причина - это неявное разделяемое состояние. В то время как глобальные переменные и импорт модулей верхнего уровня являются явным общим состоянием, другие объекты, которые передаются, обычно создаются. Это хороший момент, за двумя исключениями.

Первый и тот, который упоминается в разных местах, - это когда синглтоны постоянны. Использование глобальных констант, особенно перечислений, широко распространено и считается разумным, потому что, несмотря ни на что, ни один из пользователей не может испортить их для любого другого пользователя. Это в равной степени верно и для постоянного синглтона.

Второе исключение, о котором меньше упоминается, является противоположным - когда синглтон является только приемником данных, а не источником данных (прямо или косвенно). Вот почему логгеры кажутся естественным применением для одиночных игр. Поскольку различные пользователи не меняют регистраторы так, как другие пользователи будут интересоваться, существует состояние, не являющееся общедоступным. Это опровергает основной аргумент против одноэлементного шаблона и делает их разумным выбором из-за их простоты использования для этой задачи.

Вот цитата из http://googletesting.blogspot.com/2008/08/root-cause-of-singletons.html:

Теперь есть один вид синглтонов, который подходит. Это синглтон, в котором все доступные объекты неизменяемы. Если все объекты неизменяемы, то синглтон не имеет глобального состояния, так как все постоянно. Но такой синглтон настолько легко превратить в изменяемый, что это очень скользкая дорожка. Поэтому я тоже против этих синглтонов не потому, что они плохие, а потому, что им очень легко испортиться. (В качестве побочного примечания перечисление Java - это просто такие синглтоны. Пока вы не помещаете состояние в свое перечисление, все в порядке, поэтому, пожалуйста, не делайте этого.)

Другой тип синглтонов, которые являются полуприемлемыми, - это те, которые не влияют на выполнение вашего кода. Они не имеют побочных эффектов. Ведение журнала - прекрасный пример. Он загружен синглетонами и глобальным состоянием. Это приемлемо (так как это не повредит вам), потому что ваше приложение не ведет себя иначе, независимо от того, включен ли данный регистратор. Информация здесь течет в одном направлении: из вашего приложения в регистратор. Даже мысли, что регистраторы являются глобальным состоянием, поскольку никакая информация не поступает от регистраторов в ваше приложение, регистраторы приемлемы. Вам все равно следует ввести свой регистратор, если вы хотите, чтобы ваш тест утверждал, что что-то регистрируется, но в целом регистраторы не вредны, несмотря на то, что они заполнены состоянием.

class Foo(object):
     pass

some_global_variable = Foo()

Модули импортируются только один раз, все остальное зацикливается. Не используйте синглтоны и старайтесь не использовать глобальные переменные.

Используйте модуль. Импортируется только один раз. Определите в нем несколько глобальных переменных - они будут «атрибутами» синглтона. Добавьте несколько функций - «методы» синглтона.

Вероятно, вам никогда не понадобится синглтон в Python. Просто определите все свои данные и функции в модуле, и у вас будет де-факто синглтон:

import datetime
file_name=None

def set_file_name(new_file_name: str):
    global file_name
    file_name=new_file_name

def write(message: str):
    global file_name
    if file_name:
        with open(file_name, 'a+') as f:
            f.write("{} {}\n".format(datetime.datetime.now(), message))
    else:
        print("LOG: {}", message)

Использовать:

    import log
    log.set_file_name("debug.log")
    log.write("System starting")
    ...

Если вам действительно обязательно нужен одноэлементный класс, я бы пошел с:

    class My_Singleton(object):
        def foo(self):
            pass

    my_singleton = My_Singleton()

Использовать:

    from mysingleton import my_singleton
    my_singleton.foo()

где mysingleton.py - ваше имя файла, в котором определен My_Singleton. Это работает, потому что после первого импорта файла Python не выполняет код повторно.

Вот вам краткое изложение:

singleton = lambda c: c()

Вот как вы это используете:

@singleton
class wat(object):
    def __init__(self): self.x = 1
    def get_x(self): return self.x

assert wat.get_x() == 1

Ваш объект с нетерпением будет инстанциирован. Это может быть то, что вы хотите, а может и не быть.

Ознакомьтесь с вопросом о переполнении стека Есть ли простой и элегантный способ определения синглтонов в Python? с несколькими решениями .

Я настоятельно рекомендую посмотреть доклады Алекса Мартелли о шаблонах проектирования в Python: часть 1 и часть 2. В частности, в части 1 он говорит об одиночных объектах / объектах общего состояния.

• Если кто-то хочет иметь несколько экземпляров одного и того же класса, но только если аргументы или kwargs разные, можно использовать сторонний пакет python Удобные декораторы (пакет decorators).
• Ex.
  1. If you have a class handling serial communication, and to create an instance you want to send the serial port as an argument, then with traditional approach won't work
  2. Используя вышеупомянутые декораторы, можно создать несколько экземпляров класса, если аргументы разные.
  3. Для тех же аргументов декоратор вернет тот же экземпляр, который уже был создан.

>>> from decorators import singleton
>>>
>>> @singleton
... class A:
...     def __init__(self, *args, **kwargs):
...         pass
...
>>>
>>> a = A(name='Siddhesh')
>>> b = A(name='Siddhesh', lname='Sathe')
>>> c = A(name='Siddhesh', lname='Sathe')
>>> a is b  # has to be different
False
>>> b is c  # has to be same
True
>>>

Вот моя собственная реализация синглтонов. Все, что вам нужно сделать, это украсить класс; чтобы получить синглтон, вам нужно использовать метод Instance. Вот пример:

   @Singleton
   class Foo:
       def __init__(self):
           print 'Foo created'

   f = Foo() # Error, this isn't how you get the instance of a singleton

   f = Foo.Instance() # Good. Being explicit is in line with the Python Zen
   g = Foo.Instance() # Returns already created instance

   print f is g # True

А вот код:

class Singleton:
    """
    A non-thread-safe helper class to ease implementing singletons.
    This should be used as a decorator -- not a metaclass -- to the
    class that should be a singleton.

    The decorated class can define one `__init__` function that
    takes only the `self` argument. Other than that, there are
    no restrictions that apply to the decorated class.

    To get the singleton instance, use the `Instance` method. Trying
    to use `__call__` will result in a `TypeError` being raised.

    Limitations: The decorated class cannot be inherited from.

    """

    def __init__(self, decorated):
        self._decorated = decorated

    def Instance(self):
        """
        Returns the singleton instance. Upon its first call, it creates a
        new instance of the decorated class and calls its `__init__` method.
        On all subsequent calls, the already created instance is returned.

        """
        try:
            return self._instance
        except AttributeError:
            self._instance = self._decorated()
            return self._instance

    def __call__(self):
        raise TypeError('Singletons must be accessed through `Instance()`.')

    def __instancecheck__(self, inst):
        return isinstance(inst, self._decorated)

Метод 3 кажется очень удобным, но если вы хотите, чтобы ваша программа работала как на Python 2 и Python 3, это не работает. Даже защита отдельных вариантов с помощью тестов для версии Python не работает, потому что версия Python 3 дает синтаксическую ошибку в Python 2.

Спасибо Майку Уоткинсу: http://mikewatkins.ca/2008/11/29/python-2-and-3-metaclasses/. Если вы хотите, чтобы программа работала как на Python 2, так и на Python 3, вам нужно сделать что-то вроде:

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

MC = Singleton('MC', (object), {})

class MyClass(MC):
    pass    # Code for the class implementation

Я предполагаю, что «объект» в назначении необходимо заменить на «BaseClass», но я этого не пробовал (я пробовал код, как показано).

Я брошу свой на ринг. Это простой декоратор.

from abc import ABC

def singleton(real_cls):

    class SingletonFactory(ABC):

        instance = None

        def __new__(cls, *args, **kwargs):
            if not cls.instance:
                cls.instance = real_cls(*args, **kwargs)
            return cls.instance

    SingletonFactory.register(real_cls)
    return SingletonFactory

# Usage
@singleton
class YourClass:
    ...  # Your normal implementation, no special requirements.

Я думаю, что у него есть преимущества перед некоторыми другими решениями:

• Это ясно и лаконично (на мой взгляд; D).
• Его действие полностью инкапсулировано. Вам не нужно ничего менять в реализации YourClass. Это включает в себя отсутствие необходимости использовать метакласс для вашего класса (обратите внимание, что метакласс выше находится на фабрике, а не в «реальном» классе).
• Он не полагается ни на что от обезьяны-исправления.
• It's transparent to callers:
  • Callers still simply import YourClass, it looks like a class (because it is), and they use it normally. No need to adapt callers to a factory function.
  • То, что YourClass() создает экземпляры, по-прежнему является истинным экземпляром реализованного вами YourClass, а не прокси-сервером любого типа, поэтому никаких шансов на побочные эффекты в результате этого нет.
  • isinstance(instance, YourClass) и подобные операции по-прежнему работают, как ожидалось (хотя этот бит требует abc, что исключает Python ‹2.6).

Мне приходит в голову один недостаток: методы классов и статические методы реального класса не могут быть прозрачно вызваны через фабричный класс, скрывающий его. Я использовал это достаточно редко, чтобы никогда не столкнуться с этой потребностью, но это было бы легко исправить, используя настраиваемый метакласс на фабрике, который реализует __getattr__() для делегирования доступа к атрибутам all-ish реальному классу.

Связанный шаблон, который я на самом деле нашел более полезным (я не говорю, что такого рода вещи требуются вообще очень часто), является «Уникальным» шаблоном, при котором создается экземпляр класса с одинаковыми аргументами. в возвращении того же экземпляра. Т.е. «синглтон на аргументы». Вышеупомянутое хорошо адаптируется к этому и становится еще более кратким:

def unique(real_cls):

    class UniqueFactory(ABC):

        @functools.lru_cache(None)  # Handy for 3.2+, but use any memoization decorator you like
        def __new__(cls, *args, **kwargs):
            return real_cls(*args, **kwargs)

    UniqueFactory.register(real_cls)
    return UniqueFactory

Все это говорит о том, что я согласен с общим советом: если вы думаете, что вам нужна одна из этих вещей, вам действительно стоит остановиться на мгновение и спросить себя, действительно ли вам это нужно. В 99% случаев, ЯГНИ.

Использовать атрибут функции также очень просто

def f():
    if not hasattr(f, 'value'):
        setattr(f, 'value', singletonvalue)
    return f.value

Я предпочитаю это решение, которое я нашел очень ясным и простым. Например, он использует двойную проверку, если какой-то другой поток уже создал его. Еще одна вещь, которую следует учитывать, - это убедиться, что десериализация не создает никаких других экземпляров. https://gist.github.com/edediver/4396488

import threading


# Based on tornado.ioloop.IOLoop.instance() approach.
# See https://github.com/facebook/tornado
class SingletonMixin(object):
    __singleton_lock = threading.Lock()
    __singleton_instance = None

    @classmethod
    def instance(cls):
        if not cls.__singleton_instance:
            with cls.__singleton_lock:
                if not cls.__singleton_instance:
                    cls.__singleton_instance = cls()
        return cls.__singleton_instance


if __name__ == '__main__':
    class A(SingletonMixin):
        pass

    class B(SingletonMixin):
        pass

    a, a2 = A.instance(), A.instance()
    b, b2 = B.instance(), B.instance()

    assert a is a2
    assert b is b2
    assert a is not b

    print('a:  %s\na2: %s' % (a, a2))
    print('b:  %s\nb2: %s' % (b, b2))

Ну, кроме согласия с общим предложением Pythonic о глобальном уровне модуля, как насчет этого:

def singleton(class_):
    class class_w(class_):
        _instance = None
        def __new__(class2, *args, **kwargs):
            if class_w._instance is None:
                class_w._instance = super(class_w, class2).__new__(class2, *args, **kwargs)
                class_w._instance._sealed = False
            return class_w._instance
        def __init__(self, *args, **kwargs):
            if self._sealed:
                return
            super(class_w, self).__init__(*args, **kwargs)
            self._sealed = True
    class_w.__name__ = class_.__name__
    return class_w

@singleton
class MyClass(object):
    def __init__(self, text):
        print text
    @classmethod
    def name(class_):
        print class_.__name__

x = MyClass(111)
x.name()
y = MyClass(222)
print id(x) == id(y)

Выход:

111     # the __init__ is called only on the 1st time
MyClass # the __name__ is preserved
True    # this is actually the same instance

Как насчет этого:

def singleton(cls):
    instance=cls()
    cls.__new__ = cls.__call__= lambda cls: instance
    cls.__init__ = lambda self: None
    return instance

Используйте его как декоратор для класса, который должен быть одноэлементным. Нравится:

@singleton
class MySingleton:
    #....

Это похоже на декоратор singleton = lambda c: c() в другом ответе. Как и другое решение, единственный экземпляр имеет имя класса (MySingleton). Однако с этим решением вы все еще можете «создавать» экземпляры (фактически получать единственный экземпляр) из класса, выполняя MySingleton(). Это также предотвращает создание дополнительных экземпляров, выполняя type(MySingleton)() (который также возвращает тот же экземпляр).

Код основан на ответе Толли.

#decorator, modyfies new_cls
def _singleton(new_cls):
    instance = new_cls()                                              #2
    def new(cls):
        if isinstance(instance, cls):                                 #4
            return instance
        else:
            raise TypeError("I can only return instance of {}, caller wanted {}".format(new_cls, cls))
    new_cls.__new__  = new                                            #3
    new_cls.__init__ = lambda self: None                              #5
    return new_cls


#decorator, creates new class
def singleton(cls):
    new_cls = type('singleton({})'.format(cls.__name__), (cls,), {} ) #1
    return _singleton(new_cls)


#metaclass
def meta_singleton(name, bases, attrs):
    new_cls = type(name, bases, attrs)                                #1
    return _singleton(new_cls)

Объяснение:

1. Создать новый класс, унаследованный от заданного cls
   (он не изменяет cls на случай, если кто-то захочет, например singleton(list))

2. Создать экземпляр. Прежде чем переопределить __new__, это так просто.

3. Теперь, когда мы легко создали экземпляр, переопределяет __new__, используя метод, определенный момент назад.

4. Функция возвращает instance только тогда, когда это то, что ожидает вызывающий, иначе вызывает TypeError.
   Условие не выполняется, когда кто-то пытается наследовать от декорированного класса.

5. # P6 #

   # P7 #

Посмотрите, как это работает в Интернете

Это немного похоже на ответ fab, но не совсем то же самое.

Одноэлементный контракт не требует, чтобы мы могли вызывать конструктор несколько раз. Поскольку синглтон должен создаваться только один раз, разве не следует видеть, что он создается только один раз? «Подмена» конструктора, вероятно, ухудшает читаемость.

Итак, мое предложение таково:

class Elvis():
    def __init__(self):
        if hasattr(self.__class__, 'instance'):
            raise Exception()
        self.__class__.instance = self
        # initialisation code...

    @staticmethod
    def the():
        if hasattr(Elvis, 'instance'):
            return Elvis.instance
        return Elvis()

Это не исключает использования конструктора или поля instance пользовательским кодом:

if Elvis() is King.instance:

... если вы точно знаете, что Elvis еще не был создан, а что King.

Но это побуждает пользователей использовать метод the повсеместно:

Elvis.the().leave(Building.the())

Чтобы завершить это, вы также можете переопределить __delattr__(), чтобы вызвать исключение, если предпринята попытка удалить instance, и переопределить __del__(), чтобы он вызвал исключение (если мы не знаем, что программа завершается ...)

Дальнейшие улучшения

Я благодарен тем, кто помогал с комментариями и правками, и мы приветствуем их больше. Хотя я использую Jython, он должен работать в более общем плане и быть потокобезопасным.

try:
    # This is jython-specific
    from synchronize import make_synchronized
except ImportError:
    # This should work across different python implementations
    def make_synchronized(func):
        import threading
        func.__lock__ = threading.Lock()

        def synced_func(*args, **kws):
            with func.__lock__:
                return func(*args, **kws)

        return synced_func

class Elvis(object): # NB must be subclass of object to use __new__
    instance = None

    @classmethod
    @make_synchronized
    def __new__(cls, *args, **kwargs):
        if cls.instance is not None:
            raise Exception()
        cls.instance = object.__new__(cls, *args, **kwargs)
        return cls.instance

    def __init__(self):
        pass
        # initialisation code...

    @classmethod
    @make_synchronized
    def the(cls):
        if cls.instance is not None:
            return cls.instance
        return cls()

Примечания:

1. Если вы не подклассифицируете объект в python2.x, вы получите класс старого стиля, который не использует __new__
2. При декорировании __new__ вы должны украсить @classmethod, иначе __new__ будет несвязанным методом экземпляра
3. Возможно, это можно улучшить с помощью метакласса, так как это позволит вам сделать the свойство уровня класса, возможно, переименовав его в instance

Один лайнер (я не горжусь, но он выполняет свою работу):

class Myclass:
  def __init__(self):
      # do your stuff
      globals()[type(self).__name__] = lambda: self # singletonify

Если вам не нужна ленивая инициализация экземпляра синглтона, тогда следующее должно быть простым и потокобезопасным:

class A:
    instance = None
    # Methods and variables of the class/object A follow
A.instance = A()

Таким образом, A - это синглтон, инициализируемый при импорте модуля.

Возможно, я неправильно понимаю шаблон singleton, но мое решение настолько простое и прагматичное (питоническое?). Этот код преследует две цели

1. Сделайте экземпляр Foo доступным везде (глобально).
2. Может существовать только один экземпляр Foo.

Это код.

#!/usr/bin/env python3

class Foo:
    me = None

    def __init__(self):
        if Foo.me != None:
            raise Exception('Instance of Foo still exists!')

        Foo.me = self


if __name__ == '__main__':
    Foo()
    Foo()

Выход

Traceback (most recent call last):
  File "./x.py", line 15, in <module>
    Foo()
  File "./x.py", line 8, in __init__
    raise Exception('Instance of Foo still exists!')
Exception: Instance of Foo still exists!

После некоторой борьбы с этим я в конце концов пришел к следующему, так что объект конфигурации загружался бы только один раз при вызове из отдельных модулей. Метакласс позволяет хранить экземпляр глобального класса во встроенном dict, что в настоящее время, по-видимому, является самым изящным способом хранения надлежащего глобального программного обеспечения.

import builtins

# -----------------------------------------------------------------------------
# So..... you would expect that a class would be "global" in scope, however
#   when different modules use this,
#   EACH ONE effectively has its own class namespace.  
#   In order to get around this, we use a metaclass to intercept
#   "new" and provide the "truly global metaclass instance" if it already exists

class MetaConfig(type):
    def __new__(cls, name, bases, dct):
        try:
            class_inst = builtins.CONFIG_singleton

        except AttributeError:
            class_inst = super().__new__(cls, name, bases, dct)
            builtins.CONFIG_singleton = class_inst
            class_inst.do_load()

        return class_inst

# -----------------------------------------------------------------------------

class Config(metaclass=MetaConfig):

    config_attr = None

    @classmethod
    def do_load(cls):
        ...<load-cfg-from-file>...

Я порекомендую элегантное решение с использованием метаклассов

class Singleton(type): 
    # Inherit from "type" in order to gain access to method __call__
    def __init__(self, *args, **kwargs):
        self.__instance = None # Create a variable to store the object reference
        super().__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        if self.__instance is None:
            # if the object has not already been created
            self.__instance = super().__call__(*args, **kwargs) # Call the __init__ method of the subclass (Spam) and save the reference
            return self.__instance
        else:
            # if object (Spam) reference already exists; return it
            return self.__instance

class Spam(metaclass=Singleton):
    def __init__(self, x):
        print('Creating Spam')
        self.x = x


if __name__ == '__main__':
    spam = Spam(100)
    spam2 = Spam(200)

Выход:

Creating Spam

Как видно из вывода, создается только один объект.

Плюсы

Это настоящий класс. Авто-магическим образом покрывает наследование. Использует метакласс по назначению (и заставил меня об этом знать) Минусы

Есть ли?

Это будет проблемой при сериализации. Если вы попытаетесь десериализовать объект из файла (pickle), он не будет использовать __call__, поэтому он создаст новый файл, вы можете использовать наследование базового класса с __new__, чтобы предотвратить это.

Вы можете использовать metaclass, если хотите использовать instance как свойство. Например;

class SingletonMeta(type):
    def __init__(cls, *args, **kwargs):
        super().__init__(*args, **kwargs)
        cls._instance = None
        cls._locker = threading.Lock()

    @property
    def instance(self, *args, **kwargs):
        if self._instance is None:
            with self._locker:
                if self._instance is None:
                    self._instance = self(*args, **kwargs)
        return self._instance


class MyClass(metaclass=SingletonMeta):
    def __init__(self):
        # init here
        pass


# get the instance
my_class_instance = MyClass.instance

Я также предпочитаю синтаксис декоратора заимствовать из метакласса. Мои два цента:

from typing import Callable, Dict, Set


def singleton(cls_: Callable) -> type:
    """ Implements a simple singleton decorator
    """
    class Singleton(cls_):  # type: ignore
        __instances: Dict[type, object] = {}
        __initialized: Set[type] = set()

        def __new__(cls, *args, **kwargs):
            if Singleton.__instances.get(cls) is None:
                Singleton.__instances[cls] = super().__new__(cls, *args, **kwargs)
            return Singleton.__instances[cls]

        def __init__(self, *args, **kwargs):
            if self.__class__ not in Singleton.__initialized:
                Singleton.__initialized.add(self.__class__)
                super().__init__(*args, **kwargs)

    return Singleton


@singleton
class MyClass(...):
    ...

Это имеет некоторые преимущества по сравнению с другими декораторами:

• isinstance(MyClass(), MyClass) по-прежнему будет работать (возврат функции из клаузуры вместо класса приведет к сбою isinstance)
• property, classmethod и staticmethod будут работать должным образом
• __init__() конструктор выполняется только один раз
• Вы можете наследовать от своего декорированного класса (бесполезно?), Снова используя @singleton

Минусы:

• print(MyClass().__class__.__name__) вернет Singleton вместо MyClass. Если вам это все еще нужно, я рекомендую использовать метакласс, как предложено выше.

Если вам нужен другой экземпляр на основе параметров конструктора, это решение необходимо улучшить (решение предоставлено siddhesh-suhas-sathe обеспечивает это).

Наконец, как было предложено другими, рассмотрите возможность использования модуля в Python. Модули являются объектами. Вы даже можете передавать их в переменные и вставлять в другие классы.

Я не могу вспомнить, где я нашел это решение, но я считаю его наиболее «элегантным» с моей точки зрения, не являющейся экспертом по Python:

class SomeSingleton(dict):
    __instance__ = None
    def __new__(cls, *args,**kwargs):
        if SomeSingleton.__instance__ is None:
            SomeSingleton.__instance__ = dict.__new__(cls)
        return SomeSingleton.__instance__

    def __init__(self):
        pass

    def some_func(self,arg):
        pass

Почему мне это нравится? Никаких декораторов, метаклассов, множественного наследования ... и если вы решите, что больше не хотите, чтобы он был синглтоном, просто удалите метод __new__. Поскольку я новичок в Python (и в ООП в целом), я ожидаю, что кто-то объяснит мне, почему это ужасный подход?

Скорее всего, это не то, что вы ищете. Я хотел синглтон в том смысле, что только этот объект имел свою идентичность для сравнения. В моем случае оно использовалось как Sentinel Value. Ответ на этот вопрос очень прост: создайте любой объект mything = object(), и по природе Python только этот объект будет иметь свою идентичность.

#!python
MyNone = object()  # The singleton

for item in my_list:
    if item is MyNone:  # An Example identity comparison
        raise StopIteration

Это решение вызывает некоторое загрязнение пространства имен на уровне модуля (три определения, а не одно), но мне легко следовать.

Я хотел бы иметь возможность написать что-то вроде этого (ленивая инициализация), но, к сожалению, классы недоступны в теле их собственных определений.

# wouldn't it be nice if we could do this?
class Foo(object):
    instance = None

    def __new__(cls):
        if cls.instance is None:
            cls.instance = object()
            cls.instance.__class__ = Foo
        return cls.instance

Поскольку это невозможно, мы можем разделить инициализацию и статический экземпляр в

Жадная инициализация:

import random


class FooMaker(object):
    def __init__(self, *args):
        self._count = random.random()
        self._args = args


class Foo(object):
    def __new__(self):
        return foo_instance


foo_instance = FooMaker()
foo_instance.__class__ = Foo

Ленивая инициализация:

Жадная инициализация:

import random


class FooMaker(object):
    def __init__(self, *args):
        self._count = random.random()
        self._args = args


class Foo(object):
    def __new__(self):
        global foo_instance
        if foo_instance is None:
            foo_instance = FooMaker()
        return foo_instance


foo_instance = None