Це питання не для обговорення того, бажана чи не однотонна модель дизайну , є антидіаграмою чи для будь-яких релігійних війн, а для обговорення того, як цей шаблон найкраще реалізується в Python таким чином, який є найбільш пітонічним. У цьому випадку я визначаю "найбільш пітонічний", щоб означати, що він відповідає "принципу найменшого здивування" .

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

Найкращі методи:

Спосіб 1: декоратор

def singleton(class_):
    instances = {}
    def getinstance(*args, **kwargs):
        if class_ not in instances:
            instances[class_] = class_(*args, **kwargs)
        return instances[class_]
    return getinstance

@singleton
class MyClass(BaseClass):
    pass

Плюси

• Декоратори додають добавку таким чином, який часто є більш інтуїтивним, ніж багаторазове успадкування.

Мінуси

• Хоча об'єкти, створені за допомогою MyClass (), будуть істинними однотонними об'єктами, сам MyClass є функцією aa, а не класом, тому ви не можете викликати з нього методи класу. Також для m = MyClass(); n = MyClass(); o = type(n)();тогоm == n && m != o && n != o

Метод 2: Базовий клас

class Singleton(object):
    _instance = None
    def __new__(class_, *args, **kwargs):
        if not isinstance(class_._instance, class_):
            class_._instance = object.__new__(class_, *args, **kwargs)
        return class_._instance

class MyClass(Singleton, BaseClass):
    pass

Плюси

• Це справжній клас

Мінуси

• Багаторазова спадщина - е-е! __new__може бути перезаписано під час успадкування з другого базового класу? Треба думати більше, ніж потрібно.

Метод 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]

#Python2
class MyClass(BaseClass):
    __metaclass__ = Singleton

#Python3
class MyClass(BaseClass, metaclass=Singleton):
    pass

Плюси

• Це справжній клас
• Автоматично магічно охоплює спадщину
• Використовує __metaclass__для власного призначення (і дав мені про це знати)

Мінуси

• Чи є?

Спосіб 4: декоратор, що повертає клас з однойменною назвою

def singleton(class_):
    class class_w(class_):
        _instance = None
        def __new__(class_, *args, **kwargs):
            if class_w._instance is None:
                class_w._instance = super(class_w,
                                    class_).__new__(class_,
                                                    *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(BaseClass):
    pass

Плюси

• Це справжній клас
• Автоматично магічно охоплює спадщину

Мінуси

• Чи не існує накладних витрат для створення кожного нового класу? Тут ми створюємо два класи для кожного класу, який хочемо зробити одиночним. Хоча в моєму випадку це нормально, я переживаю, що це може не змінитися. Звичайно, існує питання дебатів щодо того, чи може бути занадто легко масштабувати цю модель ...
• У чому сенс _sealedатрибута
• Не можна викликати однойменні методи в базових класах, super()оскільки вони будуть повторюватися. Це означає, що ви не можете налаштувати __new__та не можете підкласирувати клас, до якого потрібно дзвонити __init__.

Метод 5: модуль

файл модуля singleton.py

Плюси

• Просте - краще, ніж складне

Мінуси

Використовуйте метаклас

Я б рекомендував метод №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/ , який по суті відтворює C-стилі structв Python, використовуючи метакласи. Нитка Які деякі (конкретні) випадки використання для метакласів? також наводить деякі приклади, вони, як правило, пов'язані з декларативним програмуванням, особливо, як це використовується в ORM.

У цій ситуації, якщо ви використовуєте ваш метод №2 , а підклас визначає __new__метод, він буде виконуватися щоразу, коли ви викликаєте SubClassOfSingleton()- тому що він відповідає за виклик методу, який повертає збережений екземпляр. З метакласом він буде викликаний лише один раз , коли буде створений єдиний екземпляр. Ви хочете налаштувати, що означає називати клас , який визначається його типом.

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

Вашим одиночним клавішам не буде потрібно багатократне успадкування (оскільки метаклас не є базовим класом), але для підкласів створеного класу, які використовують множинне успадкування, вам потрібно переконатися, що клас однотонних є першим / лівим лівим з метакласом, який визначає повторно __call__Це навряд чи буде проблемою. Дікт екземпляра відсутній у просторі імен екземпляра, тому його випадково не перезаписати.

Ви також почуєте, що одинарний зразок порушує "Принцип єдиної відповідальності" - кожен клас повинен робити лише одне . Таким чином, вам не доведеться турбуватися про те, щоб зіпсувати одне, що робить код, якщо вам потрібно змінити інше, оскільки вони є окремими та інкапсульованими. Реалізація метакласу проходить цей тест . Метаклас відповідає за виконання шаблону, і створений клас та підкласи не повинні знати про те, що вони є однотонними . Метод №1 провалює цей тест, як ви зазначили з "MyClass сам по собі є функцією aa, а не класом, тому ви не можете викликати методи класу з нього."

Сумісна версія Python 2 та 3

Для написання чогось, що працює як в Python2, так і в 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 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__їх використання.

Коли використовувати одинарний візерунок

Ваш випадок використання - один з кращих прикладів бажань використовувати одиночний. Ви говорите в одному з коментарів: "Мені реєстрація завжди здавалася природним кандидатом для одиноких". Ви абсолютно праві .

Коли люди кажуть, що одиночні особи погані, найпоширенішою причиною є те, що це неявний загальний стан . У той час як глобальні змінні та імпорт модулів вищого рівня є явним загальним станом, інші об'єкти, які передаються навколо, як правило, інстанціюються. Це хороший момент, за двома винятками .

Перше і те, що згадується в різних місцях, це коли одинаки постійні . Використання глобальних констант, особливо переліків, є загальноприйнятим і вважається розумним, тому що, незважаючи ні на що, жоден з користувачів не може зіпсувати їх іншим користувачам . Це однаково справедливо для постійного сингтона.

Другий виняток, про який менше згадують, - навпаки - коли сингтон - це лише раковина даних , а не джерело даних (прямо чи опосередковано). Ось чому лісоруби відчувають себе як "природне" використання для одиночних. Оскільки різні користувачі не змінюють реєстратори способами, якими будуть піклуватися інші користувачі, стан справді не є спільним . Це заперечує основний аргумент проти однотонної картини і робить їх розумним вибором через їх простоту використання для виконання завдання.

Ось цитата з http://googletesting.blogspot.com/2008/08/root- why-of-singletons.html :

Тепер є один вид Сінглтона, який добре. Це синглтон, де всі доступні об'єкти незмінні. Якщо всі об'єкти незмінні, то Сінглтон не має глобального стану, оскільки все є постійним. Але так легко перетворити цей вид одинарного в перемінний, це дуже слизький схил. Тому я і проти цих синглтонів, не тому, що вони погані, а тому, що їм дуже просто погано. (Як бічна примітка, перерахування Java - це лише такі одинаки. Поки ви не введете стан у свій перелік, ви все в порядку, тому, будь ласка, не робіть це.)

Інший вид Сінглтонів, які є напівприйнятними, - це ті, які не впливають на виконання вашого коду. Вони не мають "побічних ефектів". Ідеальний приклад - ведення журналів. Він завантажений Singletons та глобальним станом. Це прийнятно (так як це не зашкодить вам), оскільки ваша програма не поводиться нічим, незалежно від того, включений чи ні той реєстратор. Інформація тут протікає одним способом: із вашої програми до реєстратора. Навіть думки реєстраторів є глобальним станом, оскільки від реєстраторів до вашої програми не надходить інформація, реєстратори є прийнятними. Ви все одно повинні вводити свій реєстратор, якщо ви хочете, щоб ваш тест стверджував, що щось зареєстровано, але в цілому Logger не є шкідливим, незважаючи на те, що він повний.

class Foo(object):
     pass

some_global_variable = Foo()

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

Використовуйте модуль. Він імпортується лише один раз. Визначте в ньому деякі глобальні змінні - вони будуть атрибутами сингтона. Додайте деякі функції - "методи" синглтона.

Напевно, ніколи не потрібен сингл в Python. Просто визначте всі свої дані та функції в модулі, і у вас є фактичний синглтон.

Якщо вам дійсно потрібно мати однокласний клас, то я б пішов з:

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? з кількома рішеннями.

Я настійно рекомендую спостерігати за розмовами Алекса Мартеллі щодо моделей дизайну в пітоні: частина 1 та частина 2 . Зокрема, у частині 1 він розповідає про одиночні / спільні об'єкти стану.

Ось моя власна реалізація синглів. Все, що вам потрібно зробити - це прикрасити клас; щоб отримати синглтон, тоді вам доведеться скористатися 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», але я цього не пробував (я спробував код як показано).

Ну, крім згоди з загальною пітонічною пропозицією щодо глобального рівня модулів, як щодо цього:

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)()(що також повертає той самий екземпляр).

Я кину міну на ринг. Це простий декоратор.

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. Сюди входить відсутність необхідності використовувати метаклас для вашого класу (зауважте, що вищевказаний метаклас знаходиться на фабриці, а не на "реальному" класі).
• Він не покладається на те, що пов'язує мавпу.
• Це зрозуміло для абонентів:
  • Абоненти все ще просто імпортують YourClass, це схоже на клас (адже він є), і вони його використовують нормально. Не потрібно адаптувати абонентів до заводської функції.
  • Що YourClass()інстанції все ще є справжнім екземпляром реалізованого YourClassвами, а не проксі-сервера будь-якого типу, тому жодних шансів побічних ефектів, що виникають внаслідок цього, не є.
  • isinstance(instance, YourClass) і подібні операції все ще працюють, як очікувалося (хоча цей біт вимагає abc, тому виключає Python <2.6).

Мені трапляється один недолік: classmethods та staticmethods реального класу не можна прозоро викликати через фабричний клас, який приховує його. Я використовував це досить рідко, щоб ніколи не стикався з цією потребою, але це було б легко виправити, використовуючи спеціальний метаклас на заводі, який реалізує __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% часу, YAGNI.

• Якщо ви хочете мати декілька примірників одного класу, але тільки якщо арги або kwargs різні, можна використовувати це
• Вих.
  1. Якщо у вас є serialспілкування з класом , і щоб створити екземпляр, який ви хочете надіслати послідовний порт як аргумент, тоді з традиційним підходом не вийде
  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
>>>

Код на основі відповіді Толлі .

#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. Якщо __new__()повертається екземпляр cls, то __init__()метод нового екземпляра буде викликаний як __init__(self[, ...]), де self - це новий екземпляр, а решта аргументів такі ж, як і передані __new__().

   instanceвже ініціалізований, тому функція замінює __init__функцію, яка нічого не робить.

Дивіться, як це працює в Інтернеті

Він трохи схожий на відповідь 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

Якщо вам не потрібна ледача ініціалізація екземпляра Singleton, то наступне має бути простим і безпечним для потоків:

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

Цей спосіб Aє синхронізованим при імпорті модуля.

Можливо, я неправильно розумію однотонний малюнок, але моє рішення таке просте і прагматичне (пітонічне?). Цей код заповнює дві мети

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!

Після деякого бою з цим я врешті-решт придумав наступне, так що об’єкт config буде завантажений лише один раз, коли викликається з окремих модулів. Метаклас дозволяє зберігати екземпляр глобального класу у вбудованому диктаті, що в даний час представляється найменшим способом зберігання належної програмної глобальної програми.

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>...

Я не можу пригадати, де я знайшов це рішення, але вважаю, що воно є найелегантнішим з моєї точки зору, що не є 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

Чому мені це подобається? Ні декораторів, ні мета-класів, ні багаторазового успадкування ... і якщо ви вирішите, що більше не хочете, щоб це було Singleton, просто видаліть __new__метод. Оскільки я новачок у Python (і OOP взагалі), я сподіваюся, що хтось поставить мене прямо, чому це жахливий підхід?

Це мій кращий спосіб реалізації синглів:

class Test(object):
    obj = None

    def __init__(self):
        if Test.obj is not None:
            raise Exception('A Test Singleton instance already exists')
        # Initialization code here

    @classmethod
    def get_instance(cls):
        if cls.obj is None:
            cls.obj = Test()
        return cls.obj

    @classmethod
    def custom_method(cls):
        obj = cls.get_instance()
        # Custom Code here

Ця відповідь, ймовірно, не те, що ви шукаєте. Я хотів, щоб одинак ​​був у тому сенсі, що лише цей об'єкт мав свою ідентичність для порівняння. У моєму випадку він використовувався як значення Sentinel . На що відповідь дуже проста, зробіть будь-який предмет mything = object()і за природою пітона, тільки ця річ матиме свою ідентичність.

#!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