Bu soru, tektonlu tasarım deseninin istenip istenmediği, bir anti-desen olup olmadığı veya herhangi bir dini savaş için tartışılmak değil, bu desenin Python'da en çok pitonik bir şekilde en iyi nasıl uygulandığını tartışmak içindir. Bu örnekte, 'en az şaşkınlık ilkesini' izlediği anlamına gelen 'en pitonik' tanımlıyorum .

Tek tek haline gelecek birden çok sınıfım var (benim kullanım durumum bir logger içindir, ama bu önemli değil). Ben sadece miras veya süslemek zaman ekledi gumph ile birkaç sınıflar dağınık istemiyorum.

En iyi yöntemler:

Yöntem 1: Bir dekoratör

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

Artıları

• Dekoratörler, genellikle birden fazla mirastan daha sezgisel bir şekilde katkı maddesidir.

Eksileri

• MyClass () kullanılarak oluşturulan nesneler gerçek tekli nesneler olsa da, MyClass'ın kendisi bir sınıf değil, bir işlevdir, bu nedenle sınıf yöntemlerini çağıramazsınız. Ayrıca m = MyClass(); n = MyClass(); o = type(n)();o zaman içinm == n && m != o && n != o

Yöntem 2: Bir temel sınıf

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

Artıları

• Gerçek bir sınıf

Eksileri

• Çoklu kalıtım - eugh! __new__ikinci bir temel sınıftan miras sırasında üzerine yazılabilir mi? Kişi gereğinden fazla düşünmek zorundadır.

Yöntem 3: Metasınıf

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

Artıları

• Gerçek bir sınıf
• Kalıtımla otomatik olarak kaplanır
• __metaclass__Uygun amacı için kullanır (ve beni haberdar etti)

Eksileri

• Orada hiç?

Yöntem 4: Aynı ada sahip bir sınıf döndüren dekoratör

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

Artıları

• Gerçek bir sınıf
• Kalıtımla otomatik olarak kaplanır

Eksileri

• Her yeni sınıfı oluşturmak için ek yük yok mu? Burada tek bir ders yapmak istediğimiz her sınıf için iki sınıf yaratıyoruz. Benim durumumda bu iyi olsa da, bunun ölçeklenmeyebileceğinden endişeleniyorum. Tabii ki bu kalıbı ölçeklendirmenin çok kolay olup olmadığı konusunda bir tartışma konusu var ...
• _sealedÖzelliğin amacı nedir
• Aynı sınıftaki yöntemleri temel sınıflarda çağıracakları için çağıramazlar super(). Bu __new__, çağrı yapmanız gereken bir sınıfı özelleştiremeyeceğiniz ve sınıflandıramayacağınız anlamına gelir __init__.

Yöntem 5: bir modül

bir modül dosyası singleton.py

Artıları

• Basit karmaşık olmaktan iyidir

Eksileri

Metasınıf Kullan

Yöntem # 2'yi öneririm , ancak bir temel sınıftan daha çok bir metasınıf kullanmaktan daha iyisiniz . İşte örnek bir uygulama:

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

Veya Python3'te

class Logger(metaclass=Singleton):
    pass

__init__Sınıf her çağrıldığında çalıştırmak istiyorsanız ,

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

için ifde açıklamada Singleton.__call__.

Metasınıflar hakkında birkaç söz. Metasınıf bir sınıfın sınıfıdır ; yani, sınıf meta sınıfının bir örneğidir . Python'da bir nesnenin metasınıfını ile bulabilirsiniz type(obj). Normal yeni stil sınıfları türdedir type. Loggeryukarıdaki kodda class 'your_module.Singleton', tıpkı (yalnızca) örneğinin Loggertipte olacağı gibi class 'your_module.Logger'. Birlikte logger aradığınızda Logger(), Python ilk metaclass sorar Logger, Singleton, örnek oluşturma önceden empted sağlayan ne yapacağını. Bu işlem, bir sınıfa __getattr__özniteliklerinden birine başvurarak ne yapılacağını soran Python ile aynıdır myclass.attribute.

Bir metasınıf esasen bir sınıf tanımının ne anlama geldiğine ve bu tanımın nasıl uygulanacağına karar verir . Örneğin , bkz. Http://code.activestate.com/recipes/498149/ , temelde structmetasınıflar kullanarak Python'daki C stilini yeniden oluşturur . İplik Metasınıflar için bazı (somut) kullanım durumları nelerdir? ayrıca bazı örnekler de sağlarlar, özellikle ORM'lerde kullanıldığı gibi, genellikle bildirimsel programlama ile ilişkili görünmektedirler.

Bu durumda, Yöntem # 2'nizi kullanırsanız ve bir alt sınıf bir __new__yöntem tanımlarsa , her aradığınızda yürütülürSubClassOfSingleton() - depolanan örneği döndüren yöntemi çağırmaktan sorumludur. Bir metasınıfla, tek örnek oluşturulduğunda yalnızca bir kez çağrılacaktır . Sınıfa göre karar vermenin ne anlama geldiğini özelleştirmek istersiniz .

Genel olarak, bir singleton uygulamak için bir metasınıf kullanmak mantıklıdır . Singleton özeldir, çünkü sadece bir kez oluşturulur ve metasınıf bir sınıfın oluşturulmasını özelleştirmenizdir . Bir metasınıf kullanmak , singleton sınıf tanımlarını başka şekillerde özelleştirmeniz gerektiğinde size daha fazla kontrol sağlar .

Teklitonlarınızın birden fazla kalıtıma ihtiyacı yoktur (metasınıf temel bir sınıf olmadığından), ancak birden fazla kalıtım kullanan oluşturulan sınıfın alt sınıfları için , singleton sınıfının, yeniden tanımlayan bir metasınıflı ilk / en soldaki sınıf olduğundan emin olmanız gerekir. __call__Bunun bir sorun olması pek olası değildir. Örnek diktesi, örneğin ad alanında değildir, dolayısıyla yanlışlıkla üzerine yazmaz.

Ayrıca, tekil paternin "Tek Sorumluluk İlkesi" ni ihlal ettiğini de duyacaksınız - her sınıf sadece bir şey yapmalıdır . Bu şekilde, kodun bir başkasını değiştirmeniz gerekiyorsa bir şeyi karıştırmaktan endişelenmenize gerek kalmaz, çünkü bunlar ayrı ve kapsüllenmiştir. Metaclass uygulaması bu testi geçer . Metaclass, kalıbın uygulanmasından sorumludur ve yaratılan sınıf ve alt sınıfların tekton olduklarının farkında olmaları gerekmez . Yöntem 1. Birlikte belirtildiği gibi, bu testi başarısız "ondan sınıf yöntemleri çağırmak olamaz yani kendisi aa fonksiyon, bir sınıftır Sınıfım."

Python 2 ve 3 Uyumlu Sürüm

Hem Python2 hem de 3'te çalışan bir şey yazmak biraz daha karmaşık bir şema kullanmayı gerektirir. Metasınıflar genellikle tip alt sınıflar olduğundan , metasınıfı typeolarak çalışma zamanında dinamik olarak bir ara taban sınıfı oluşturmak için birini kullanmak ve daha sonra bunu kamu Singletontaban sınıfının temel sınıfı olarak kullanmak mümkündür. Daha sonra açıklandığı gibi açıklamak daha zordur:

# 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

Bu yaklaşımın ironik bir yönü, bir metasınıf uygulamak için alt sınıflandırma kullanmasıdır. Olası bir avantaj, saf bir metasınıfın aksine isinstance(inst, Singleton)geri dönmesidir True.

Düzeltmeler

Başka bir konuda, muhtemelen bunu zaten fark ettiniz, ancak orijinal yayınınızdaki temel sınıf uygulaması yanlış. _instancesihtiyaçlar edilecek sınıfına başvurulan , kullanmak gerekmez super()veya sen recursing ve __new__sen zorunda aslında statik bir yöntemdir için sınıf geçmek fiili sınıf olarak değil, bir sınıf yöntemi oluşturulmadı henüz ne zaman denir. Bütün bunlar bir metasınıf uygulaması için de geçerli olacak.

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()

Sınıf Dönen Dekoratör

Başlangıçta bir yorum yazıyordum ama çok uzundu, bu yüzden buraya ekleyeceğim. Yöntem # 4 , diğer dekoratör sürümünden daha iyidir, ancak tek birton için gerekenden daha fazla koddur ve ne yaptığı açık değildir.

Temel problemler sınıfın kendi temel sınıfı olmasından kaynaklanmaktadır. Birincisi, bir sınıfın, yalnızca __class__özniteliğinde var olan aynı ada sahip neredeyse aynı sınıfın bir alt sınıfı olması garip değil mi? Bu aynı zamanda tanımlamak anlamına gelir onların temel sınıf aynı adı taşıyan yöntemini çağırın herhangi yöntemleri ile super()onlar Recurse çünkü. Bu, sınıfınızın özelleştirilemeyeceği __new__ve __init__çağrılması gereken sınıflardan türeyemeyeceği anlamına gelir .

Singleton paterni ne zaman kullanılır?

Kullanım durumunuz, singleton kullanmak isteyebileceğiniz en iyi örneklerden biridir. Bir yorumda "Bana göre giriş her zaman Singletons için doğal bir aday gibi göründü" diyorsunuz. Sen kesinlikle doğru .

İnsanlar singletonların kötü olduğunu söylediklerinde en yaygın neden örtülü paylaşılan devlet olmalarıdır . Genel değişkenler ve üst düzey modül içe aktarmaları açık paylaşılan durum olsa da, iletilen diğer nesneler genellikle somutlaştırılır. Bu iki istisna dışında iyi bir nokta .

Birincisi ve çeşitli yerlerde bahsedilen, tektonların sabit olduğu zamandır . Küresel sabitler, özellikle çeteleler kullanımı yaygın olarak kabul ve aklı başında sayılır, çünkü ne olursa olsun, başka bir kullanıcı için kullanıcı hiçbiri mahvedebilir onları . Bu, sabit bir singleton için de aynı şekilde geçerlidir.

Daha az bahsedilen ikinci istisna tam tersidir - singleton bir veri kaynağı değil, doğrudan veya dolaylı olarak sadece bir veri havuzu olduğunda. Bu nedenle logger'lar singletonlar için "doğal" bir kullanım gibi hissederler. Çeşitli kullanıcılar , günlükçüleri diğer kullanıcıların önem verdiği şekilde değiştirmediği için , gerçekten paylaşılan bir durum yoktur . Bu, singleton desenine karşı birincil argümanı reddeder ve görev için kullanım kolaylığı nedeniyle onları makul bir seçim yapar .

Http://googletesting.blogspot.com/2008/08/root-cause-of-singletons.html adresinden bir alıntı :

Şimdi, bir tür Singleton var. Bu, ulaşılabilir tüm nesnelerin değişmez olduğu bir singleton. Tüm nesneler Singleton'dan değişmezse, her şey sabit olduğu için küresel bir durumu yoktur. Ancak bu tür singletonu mutable olana dönüştürmek çok kolaydır, çok kaygan bir eğimdir. Bu nedenle, bu Singletonlara da karşıyım, kötü oldukları için değil, kötü gitmeleri çok kolay olduğu için. (Bir yan not olarak Java numaralandırması sadece bu tür tekil tonlardır. Numaralandırmanıza durum koymadığınız sürece sorun değil, lütfen yapmayın.)

Yarı-kabul edilebilir olan diğer Singletons, kodunuzun yürütülmesini etkilemeyenlerdir, "yan etkisi" yoktur. Günlüğe kaydetme mükemmel bir örnektir. Singletons ve global durum ile yüklenir. Uygulamanız belirli bir günlükçünün etkinleştirilip etkinleştirilmediği konusunda farklı davranmadığı için (içinde olduğu gibi size zarar vermeyecektir) kabul edilebilir. Buradaki bilgiler tek bir şekilde akar: Uygulamanızdan kaydediciye. Günlükçülerden uygulamanıza hiçbir bilgi akışı olmadığından, günlükçüler küresel durumdur, günlükçüler kabul edilebilir. Testinizin bir şeyin günlüğe kaydedildiğini iddia etmesini istiyorsanız, kaydedicinizi enjekte etmelisiniz, ancak genel olarak Logger'lar durum dolu olmasına rağmen zararlı değildir.

class Foo(object):
     pass

some_global_variable = Foo()

Modüller sadece bir kez içe aktarılır, diğer her şey aşırı düşünülür. Singleton kullanmayın ve globalleri kullanmamaya çalışın.

Bir modül kullanın. Yalnızca bir kez içe aktarılır. İçindeki bazı küresel değişkenleri tanımlayın - bunlar singleton'un 'nitelikleri' olacaktır. Bazı fonksiyonlar ekleyin - singleton'un 'yöntemleri'.

Muhtemelen Python'da asla bir singletona ihtiyacınız yoktur. Tüm verilerinizi ve işlevlerinizi bir modülde tanımlayın ve fiili bir tektonuz var.

Gerçekten kesinlikle bir singleton sınıf olması gerekiyorsa ben ile gitmek istiyorum:

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

my_singleton = My_Singleton()

Kullanmak:

from mysingleton import my_singleton
my_singleton.foo()

Burada mysingleton.py, My_Singleton'un tanımlandığı dosya adınızdır. Bu, bir dosyanın ilk kez içe aktarılmasından sonra Python'un kodu yeniden yürütmediği için çalışır.

İşte size bir astar:

singleton = lambda c: c()

İşte nasıl kullanacağınız:

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

assert wat.get_x() == 1

Nesneniz hevesle başlatılıyor. İstediğiniz şey bu olabilir veya olmayabilir.

Yığın Taşması sorusuna göz atın Python'da tek tonları tanımlamanın basit ve zarif bir yolu var mı? birkaç çözüm ile.

Alex Martelli'nin python'daki tasarım kalıpları hakkındaki görüşmelerini izlemenizi şiddetle tavsiye ediyorum: bölüm 1 ve bölüm 2 . Özellikle, 1. bölümde singleton / paylaşılan devlet nesneleri hakkında konuşuyor.

İşte benim singleton uygulaması. Tek yapmanız gereken sınıfı süslemektir; singleton'u elde etmek için, Instanceyöntemi kullanmanız gerekir . İşte bir örnek:

   @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

Ve işte kod:

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)

Yöntem 3 çok düzgün gibi görünüyor, ancak her ikisi de pistine Programınızı istiyorsanız Python 2 ve Python 3 , bu işi yapmaz. Python 3 sürümü Python 2'de sözdizimi hatası verdiğinden, ayrı varyantları Python sürümü testleriyle korumak bile başarısız olur.

Mike Watkins'e teşekkürler: http://mikewatkins.ca/2008/11/29/python-2-and-3-metaclasses/ . Programın hem Python 2 hem de Python 3'te çalışmasını istiyorsanız, aşağıdaki gibi bir şey yapmanız gerekir:

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

Ödevde 'nesne' yerine 'BaseClass' değiştirilmesi gerektiğini varsayıyorum, ama bunu denemedim (Ben gösterildiği gibi kodu denedim).

Peki, modül düzeyinde küresel olma konusunda genel Pythonic önerisini kabul etmek dışında, buna ne dersiniz:

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)

Çıktı:

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

Buna ne dersin:

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

Tekli olması gereken bir sınıfta dekoratör olarak kullanın. Bunun gibi:

@singleton
class MySingleton:
    #....

Bu singleton = lambda c: c()başka bir cevapta dekoratöre benzer . Diğer çözüm gibi, tek örnek de class ( MySingleton) adına sahiptir . Ancak, bu çözüm ile yine de sınıftan örnekler yaratabilirsiniz (aslında tek örneği alırsınız) MySingleton(). Ayrıca yaparak type(MySingleton)()(aynı örneği döndüren) ek örnekler oluşturmanızı da engeller .

Benimkini ringe atacağım. Basit bir dekoratör.

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.

Avantajları Bence diğer bazı çözümler üzerinde:

• Açık ve özlüdür (gözüme; D).
• Eylemi tamamen kapsüllenmiştir. Uygulamasının tek bir şeyi değiştirmenize gerek yoktur YourClass. Bu, sınıfınız için bir metasınıf kullanmaya gerek duymamayı içerir (yukarıdaki metasınıfın "gerçek" sınıfta değil, fabrikada olduğunu unutmayın).
• Maymun yamalı hiçbir şeye dayanmaz.
• Arayanlar için şeffaftır:
  • Arayanlar hala içe aktarıyor YourClass, bir sınıf gibi görünüyor (çünkü) ve normal olarak kullanıyorlar. Arayanları fabrika işlevine uyarlamaya gerek yoktur.
  • Ne YourClass()başlatır hala gerçek bir örneğidir YourClassyan etkileri şansı o kaynaklanan nedenle, her türlü değil, bir vekil uyguladı.
  • isinstance(instance, YourClass) ve benzer işlemler hala beklendiği gibi çalışır (bu bit abc gerektirmesine rağmen Python <2.6'yı engeller).

Benim için bir dezavantaj oluşuyor: gerçek sınıfın sınıf yöntemleri ve statik yöntemleri, onu gizleyen fabrika sınıfı aracılığıyla şeffaf bir şekilde çağrılamaz. Bunu nadiren bu ihtiyaçla karşılaşmayacak kadar kullandım, ancak __getattr__()gerçek sınıfa tüm-ish öznitelik erişimini delege etmek için uygulayan fabrikada özel bir metasınıf kullanılarak kolayca düzeltilebilir .

Aslında daha yararlı bulduğum ilgili bir desen (bu tür şeylerin çok sık gerekli olduğunu söylemiyorum), aynı argümanlarla sınıfı başlatmanın aynı örneği geri getirmesiyle sonuçlanan "Benzersiz" bir modeldir . Yani bir "argüman başına singleton". Yukarıdakiler bu kuyuya uyum sağlar ve daha da özlü hale gelir:

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

Tüm bunlar, bunlardan birine ihtiyacınız olduğunu düşünüyorsanız, muhtemelen bir anlığına durmanız ve kendinize gerçekten yapıp yapmadığınızı sormanız gerektiğine dair genel tavsiyeye katılıyorum. Zamanın% 99'u YAGNI.

• Biri ama, aynı sınıfın örnekleri çoklu sayıda istiyorsa Args veya kwargs farklıdır yalnızca, birini kullanabilirsiniz bu
• Ör.
  1. Sınıf işleme serialiletişiminiz varsa ve seri bağlantı noktasını argüman olarak göndermek istediğiniz bir örnek oluşturmak istiyorsanız, geleneksel yaklaşımla çalışmaz
  2. Yukarıda bahsedilen dekoratörler kullanılarak, bağımsız değişkenler farklıysa sınıfın birden çok örneği oluşturulabilir.
  3. Aynı argümanlar için, dekoratör zaten oluşturulmuş olan aynı örneği döndürür.

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

Tolli'nin cevabına dayanan kod .

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

Açıklama:

1. Verilen sınıftan devralınan yeni sınıf oluşturun cls
   ( clsörneğin, birisinin istemesi durumunda değişmez singleton(list))

2. Örnek oluştur. Geçersiz kılmadan önce __new__çok kolay.

3. Şimdi, kolayca örnek oluşturduğumuzda, __new__an önce tanımlanmış yöntemi kullanarak geçersiz kılar .

4. İşlev instanceyalnızca arayanın beklediği zaman döner , aksi takdirde yükselir TypeError.
   Birisi dekore edilmiş sınıftan miras almaya çalıştığında koşul karşılanmaz.

5. Eğer __new__()döner bir örneği cls, daha sonra yeni örneğinin __init__()yöntemi çağrılır gibi __init__(self[, ...])kendini yeni örneği olduğu ve kalan argümanlar geçirildi aynıdır __new__().

   instancezaten başlatılmış olduğundan işlev __init__hiçbir şey yapmadan işlevle değiştirilir .

Çevrimiçi çalıştığını görün

Fab'ın cevabına biraz benziyor ama tam olarak aynı değil.

Singleton sözleşme biz kurucu birden fazla kez çağırmak mümkün olmasını gerektirmez. Bir singleton sadece bir kez yaratılacağı için, sadece bir kez yaratıldığı görülmemeli midir? "Kimlik sahtekarlığı" kurucu okunabilirliği tartışmalı bir şekilde bozar.

Benim önerim sadece şu:

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()

Bu, kurucunun veya alanın instancekullanıcı koduna göre kullanılmasını engellemez :

if Elvis() is King.instance:

... Elvisbunun henüz yaratılmadığından ve bu yaratıldığından eminseniz King.

Ancak kullanıcıları yöntemi evrensel olarak kullanmaya teşvik ederthe :

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

Bu da geçersiz olabilir eksiksiz yapmak için __delattr__()bir girişimde silmek yapılırsa bir özel durum yükseltmek instanceve geçersiz kılmayı __del__()bir özel durum yükseltir, böylece (biz programı sona eriyor bilmedikleri sürece ...)

Diğer iyileştirmeler

Yorum ve düzenlemelere yardımcı olanlara teşekkür ediyorum. Jython'u kullanırken, bu daha genel çalışmalı ve iş parçacığı açısından güvenli olmalıdır.

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()

Dikkat edilecek noktalar:

1. Python2.x dosyasındaki nesneden alt sınıf almazsanız, kullanmayan eski bir sınıf alırsınız __new__
2. Dekorasyon yaparken __new__@classmethod ile süslemeniz gerekir veya __new__ilişkisiz bir örnek yöntemi olacaktır.
3. Bu muhtemelen bir metasınıfın kullanımı yoluyla geliştirilebilir, çünkü bu, thesınıf düzeyinde bir özellik oluşturmanıza izin verir , muhtemeleninstance

Bir astar (Gurur duymuyorum, ama işi yapıyor):

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

Singleton örneğinin tembel başlatılmasına ihtiyacınız yoksa, aşağıdakiler kolay ve iş parçacığı açısından güvenli olmalıdır:

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

Bu şekilde Amodül içe aktarmada başlatılan tek bir ton.

Belki tekil kalıbı yanlış anlıyorum ama benim çözümüm bu basit ve pragmatik (pitonik?). Bu kod iki hedefi tamamlar

1. Örneğini yapın FooErişilebilirlik her yerde erişilebilir hale getirin (global).
2. Yalnızca bir örneği Foobulunabilir.

Kod budur.

#!/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()

Çıktı

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!

Bir süre bununla uğraştıktan sonra nihayetinde aşağıdakileri buldum, böylece yapılandırma nesnesi ayrı modüller çağrıldığında yalnızca bir kez yüklenecekti. Metasınıf, şu anda uygun bir programı küresel olarak saklamanın en güzel yolu gibi görünen yerleşik bir dikte içinde küresel bir sınıf örneğinin depolanmasına izin verir.

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

Bu çözümü nerede bulduğumu hatırlamıyorum, ancak Python uzmanı olmayan bakış açımdan en 'zarif' olduğunu düşünüyorum:

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

Bunu neden sevdim? Dekoratörler yok, meta sınıfları yok, çoklu kalıtım yok ... ve artık Singleton olmasını istemediğinize karar verirseniz, __new__yöntemi silin . Python'da (ve genel olarak OOP'da) yeni olduğumdan, birinin neden bu korkunç bir yaklaşım olduğu konusunda beni düzleştireceğini umuyorum?

Tektonları uygulamak için tercih ettiğim yol:

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

Bu cevap muhtemelen aradığınız şey değil. Karşılaştırma için sadece o nesnenin kimliğine sahip olması anlamında bir singleton istedim. Benim durumumda bir Sentinel Değeri . Cevabın çok basit olduğu, herhangi bir nesneyi yapın mything = object()ve python'un doğası gereği, sadece o şeyin kimliği olacaktır.

#!python
MyNone = object()  # The singleton

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

Bu çözüm, modül düzeyinde bazı ad alanı kirliliğine neden olur (sadece bir değil üç tanım), ancak takip etmeyi kolay buluyorum.

Böyle bir şey yazabilmek istiyorum (tembel başlatma), ancak ne yazık ki sınıflar kendi tanımlarının gövdesinde mevcut değil.

# 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

Bu mümkün olmadığından, başlatma işlemini ve statik örneği

İstekli Başlatma:

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

Tembel başlatma:

İstekli Başlatma:

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