Есть ли простой, элегантный способ определить синглтоны?[дубликат]

Question

На этот вопрос уже есть ответ здесь:

• Создание синглтона в Python 20 ответов

Кажется, есть много способов определить одиночки на языке Python.Существует ли единое мнение по поводу переполнения стека?

Answer 1

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

Если вы действительно хотите использовать класс, в Python нет способа создавать частные классы или частные конструкторы, поэтому вы не можете защититься от нескольких экземпляров, кроме как с помощью соглашения об использовании вашего API.Я бы все равно просто поместил методы в модуль и рассматривал модуль как синглтон.

Answer 2

Вот моя собственная реализация одиночек.Все, что вам нужно сделать, это украсить класс;чтобы получить синглтон, вам затем нужно использовать 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. Also, the decorated class cannot be
    inherited from. 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.

    """

    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)

Answer 3

Вы можете переопределить __new__ метод, подобный этому:

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


if __name__ == '__main__':
    s1 = Singleton()
    s2 = Singleton()
    if (id(s1) == id(s2)):
        print "Same"
    else:
        print "Different"

Answer 4

Несколько иным подходом к реализации синглтона в Python является узор борга автор: Алекс Мартелли (сотрудник Google и гений Python).

class Borg:
    __shared_state = {}
    def __init__(self):
        self.__dict__ = self.__shared_state

Таким образом, вместо того, чтобы заставлять все экземпляры иметь одинаковый идентификатор, они совместно используют состояние.

Answer 5

Модульный подход работает хорошо.Если мне абсолютно нужен синглтон, я предпочитаю подход метакласса.

class Singleton(type):
    def __init__(cls, name, bases, dict):
        super(Singleton, cls).__init__(name, bases, dict)
        cls.instance = None 

    def __call__(cls,*args,**kw):
        if cls.instance is None:
            cls.instance = super(Singleton, cls).__call__(*args, **kw)
        return cls.instance

class MyClass(object):
    __metaclass__ = Singleton

Answer 6

Смотрите эту реализацию из PEP318, реализующий одноэлементный шаблон с помощью декоратора:

def singleton(cls):
    instances = {}
    def getinstance():
        if cls not in instances:
            instances[cls] = cls()
        return instances[cls]
    return getinstance

@singleton
class MyClass:
    ...

Answer 7

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

Имея это в виду, вот доказательство концепции:

def singleton(cls):
    obj = cls()
    # Always return the same object
    cls.__new__ = staticmethod(lambda cls: obj)
    # Disable __init__
    try:
        del cls.__init__
    except AttributeError:
        pass
    return cls

Смотрите на Модель данных Python для получения более подробной информации о __new__.

Пример:

@singleton
class Duck(object):
    pass

if Duck() is Duck():
    print "It works!"
else:
    print "It doesn't work!"

Примечания:

1. Вы должны использовать классы нового стиля (производные от object) для этого.

2. Синглтон инициализируется при его определении, а не при первом использовании.

3. Это всего лишь игрушечный пример.На самом деле я никогда не использовал это в производственном коде и не планирую этого делать.

Answer 8

Я очень не уверен в этом, но мой проект использует "условные синглтоны" (не принудительные синглтоны), то есть, если у меня есть класс с именем DataController, я определяю это в том же модуле:

_data_controller = None
def GetDataController():
    global _data_controller
    if _data_controller is None:
        _data_controller = DataController()
    return _data_controller

Это не элегантно, поскольку состоит из полных шести строк.Но все мои синглтоны используют этот шаблон, и он, по крайней мере, очень явный (то есть pythonic).

Answer 9

Тот Самый Документация на Python охватывает ли это:

class Singleton(object):
    def __new__(cls, *args, **kwds):
        it = cls.__dict__.get("__it__")
        if it is not None:
            return it
        cls.__it__ = it = object.__new__(cls)
        it.init(*args, **kwds)
        return it
    def init(self, *args, **kwds):
        pass

Я бы, вероятно, переписал его, чтобы он больше походил на этот:

class Singleton(object):
    """Use to create a singleton"""
    def __new__(cls, *args, **kwds):
        """
        >>> s = Singleton()
        >>> p = Singleton()
        >>> id(s) == id(p)
        True
        """
        self = "__self__"
        if not hasattr(cls, self):
            instance = object.__new__(cls)
            instance.init(*args, **kwds)
            setattr(cls, self, instance)
        return getattr(cls, self)

    def init(self, *args, **kwds):
        pass

Это должно быть относительно чисто, чтобы расширить это:

class Bus(Singleton):
    def init(self, label=None, *args, **kwds):
        self.label = label
        self.channels = [Channel("system"), Channel("app")]
        ...

Answer 10

Однажды, когда я писал синглтон на Python, я использовал класс, в котором все функции-члены имели classmethod decorator .

class foo:
  x = 1

  @classmethod
  def increment(cls, y = 1):
    cls.x += y

Answer 11

В блоге Google по тестированию также есть несколько интересных статей, в которых обсуждается, почему singleton являются / могут быть плохими и являются антишаблоном:

• Одиночки - патологические Лжецы
• Куда подевались все Синглтоны?
• Первопричина синглетонов

Answer 12

Создание одноэлементного декоратора (он же аннотация) - элегантный способ, если вы хотите украшать (аннотировать) классы в будущем.Затем вы просто ставите @singleton перед определением вашего класса.

def singleton(cls):
    instances = {}
    def getinstance():
        if cls not in instances:
            instances[cls] = cls()
        return instances[cls]
    return getinstance

@singleton
class MyClass:
    ...

Answer 13

Вот пример из Python IAQ Питера Норвига Как мне создать шаблон Singleton в Python? (Вы должны использовать функцию поиска вашего браузера, чтобы найти этот вопрос, прямой ссылки нет, извините)

Кроме того, у Брюса Экеля есть еще один пример в его книге Мышление на Python (опять же, прямой ссылки на код нет)

Answer 14

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

class NothingSpecial:
    pass

_the_one_and_only = None

def TheOneAndOnly():
    global _the_one_and_only
    if not _the_one_and_only:
        _the_one_and_only = NothingSpecial()
    return _the_one_and_only

Или если нет проблем с созданием экземпляра при первом импорте модуля:

class NothingSpecial:
    pass

THE_ONE_AND_ONLY = NothingSpecial()

Таким образом, вы можете писать тесты для новых экземпляров без побочных эффектов, и нет необходимости заполнять модуль глобальными инструкциями, и при необходимости вы можете создавать варианты в будущем.

Answer 15

Одноэлементный шаблон, реализованный с помощью Python любезно предоставлено ActiveState.

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

Answer 16

Будучи относительно новичком в Python, я не уверен, какая идиома наиболее распространена, но самое простое, что я могу придумать, - это просто использовать модуль вместо класса.То, что было бы методами экземпляра в вашем классе, становится просто функциями в модуле, а любые данные просто становятся переменными в модуле, а не членами класса.Я подозреваю, что это питонический подход к решению задач того типа, для которых люди используют синглтоны.

Если вам действительно нужен одноэлементный класс, есть разумная реализация, описанная на первое попадание в Google для "Python singleton", в частности:

class Singleton:
    __single = None
    def __init__( self ):
        if Singleton.__single:
            raise Singleton.__single
        Singleton.__single = self

Кажется, это делает свое дело.

Answer 17

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

Я назвал его Singleton_group, потому что он группирует похожие экземпляры вместе и предотвращает создание объекта того же класса с теми же аргументами:

# Peppelinux's cached singleton
class Singleton_group(object):
    __instances_args_dict = {}
    def __new__(cls, *args, **kwargs):
        if not cls.__instances_args_dict.get((cls.__name__, args, str(kwargs))):
            cls.__instances_args_dict[(cls.__name__, args, str(kwargs))] = super(Singleton_group, cls).__new__(cls, *args, **kwargs)
        return cls.__instances_args_dict.get((cls.__name__, args, str(kwargs)))


# It's a dummy real world use example:
class test(Singleton_group):
    def __init__(self, salute):
        self.salute = salute

a = test('bye')
b = test('hi')
c = test('bye')
d = test('hi')
e = test('goodbye')
f = test('goodbye')

id(a)
3070148780L

id(b)
3070148908L

id(c)
3070148780L

b == d
True


b._Singleton_group__instances_args_dict

{('test', ('bye',), '{}'): <__main__.test object at 0xb6fec0ac>,
 ('test', ('goodbye',), '{}'): <__main__.test object at 0xb6fec32c>,
 ('test', ('hi',), '{}'): <__main__.test object at 0xb6fec12c>}

Каждый объект содержит одноэлементный кэш...Это может быть злом, но для некоторых это отлично работает :)

Answer 18

class Singleton(object[,...]):

    staticVar1 = None
    staticVar2 = None

    def __init__(self):
        if self.__class__.staticVar1==None :
            # create class instance variable for instantiation of class
            # assign class instance variable values to class static variables
        else:
            # assign class static variable values to class instance variables

Answer 19

Мое простое решение, основанное на значении параметров функции по умолчанию.

def getSystemContext(contextObjList=[]):
    if len( contextObjList ) == 0:
        contextObjList.append( Context() )
        pass
    return contextObjList[0]

class Context(object):
    # Anything you want here

Answer 20

Сводный брат Синглтона

Я полностью согласен со стаале и оставляю здесь пример создания синглетного сводного брата:

class void:pass
a = void();
a.__class__ = Singleton

a теперь он сообщит, что принадлежит к тому же классу, что и singleton, даже если это не похоже на него.Таким образом, одиночки, использующие сложные классы, в конечном итоге зависят от того, что мы с ними особо не возимся.

Таким образом, мы можем добиться того же эффекта и использовать более простые вещи, такие как переменная или модуль.Тем не менее, если мы хотим использовать классы для наглядности и потому, что в Python класс - это объект, итак, у нас уже есть объект (не экземпляр and, но он будет делать то же самое).

class Singleton:
    def __new__(cls): raise AssertionError # Singletons can't have instances

Там у нас есть приятная ошибка утверждения, если мы пытаемся создать экземпляр, и мы можем сохранять в производных статические члены и вносить в них изменения во время выполнения (я люблю Python).Этот объект так же хорош, как и другие about half brothers (вы все еще можете создать их, если хотите), однако, как правило, он будет работать быстрее из-за простоты.

Answer 21

class Singeltone(type):
    instances = dict()

    def __call__(cls, *args, **kwargs):
        if cls.__name__ not in Singeltone.instances:            
            Singeltone.instances[cls.__name__] = type.__call__(cls, *args, **kwargs)
        return Singeltone.instances[cls.__name__]


class Test(object):
    __metaclass__ = Singeltone


inst0 = Test()
inst1 = Test()
print(id(inst1) == id(inst0))

Answer 22

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

class singleton(object):
  """Singleton decorator."""

  def __init__(self, cls):
      self.__dict__['cls'] = cls

  instances = {}

  def __call__(self):
      if self.cls not in self.instances:
          self.instances[self.cls] = self.cls()
      return self.instances[self.cls]

  def __getattr__(self, attr):
      return getattr(self.__dict__['cls'], attr)

  def __setattr__(self, attr, value):
      return setattr(self.__dict__['cls'], attr, value)