[PYTHON] Borg 패턴이 파이썬의 싱글 톤 패턴보다 나은 이유는 무엇입니까?

Borg 패턴이 파이썬의 싱글 톤 패턴보다 나은 이유는 무엇입니까?

보그 패턴이 싱글 톤 패턴보다 나은 이유는 무엇입니까?

나는 그들이 다른 결과를 가져 오는 것을 보지 못하기 때문에 물어 본다.

도시 :

class Borg:
  __shared_state = {}
  # init internal state variables here
  __register = {}
  def __init__(self):
    self.__dict__ = self.__shared_state
    if not self.__register:
      self._init_default_register()

하나씩 일어나는 것:

class Singleton:
  def __init__(self):
    # init internal state variables here
    self.__register = {}
    self._init_default_register()

# singleton mechanics external to class, for example this in the module
Singleton = Singleton()

여기에 표시하고자하는 것은 Borg 또는 Singleton으로 구현되었는지 여부에 관계없이 서비스 객체가 사소한 내부 상태 (일부 서비스를 제공함)를 갖고 있다는 것입니다 (즉, 유용한 점은 Singleton / Borg가 아니라 장난).

그리고이 국가는 입성해야합니다. 여기서 우리는 init을 전역 상태의 셋업으로 간주하기 때문에 Singleton 구현은보다 직관적이다. Borg 객체가 내부 상태를 질의하여 자신을 업데이트해야하는지를 확인해야한다는 것은 어색한 일입니다.

그것은 당신이 가진 내부 상태가 더욱 악화됩니다. 예를 들어 객체가 디스크에 등록 정보를 저장하기 위해 응용 프로그램의 티 아웃 (teardown) 신호를 수신해야하는 경우 해당 등록은 한 번만 수행해야하며 싱글 톤을 사용하면 더 쉽습니다.

해결법

1. ==============================

   1.borg가 다른 진짜 이유는 하위 클래스 화에 있습니다.

   borg가 다른 진짜 이유는 하위 클래스 화에 있습니다.

   borg를 서브 클래스 화하면 서브 클래스의 공유 상태를 명시 적으로 대체하지 않는 한 서브 클래스의 오브젝트는 해당 부모 클래스 오브젝트와 동일한 상태를 갖습니다. 싱글 톤 패턴의 각 하위 클래스는 고유 한 상태를 가지므로 서로 다른 객체를 생성합니다.

   또한 싱글 톤 패턴에서 객체는 실제 상태와 동일하지만 상태 (실제적으로 유일한 상태 임에도 불구하고)는 동일합니다.

2. ==============================

   2.Python에서는 어디서나 액세스 할 수있는 고유 한 "객체"를 원할 경우 정적 속성 인 @staticmethods 및 @classmethods 만 포함하는 고유 클래스를 만듭니다. 당신은 그것을 Unique Pattern이라고 부를 수 있습니다. 여기에서는 3 가지 패턴을 구현하고 비교합니다.

   Python에서는 어디서나 액세스 할 수있는 고유 한 "객체"를 원할 경우 정적 속성 인 @staticmethods 및 @classmethods 만 포함하는 고유 클래스를 만듭니다. 당신은 그것을 Unique Pattern이라고 부를 수 있습니다. 여기에서는 3 가지 패턴을 구현하고 비교합니다.

   독특한

   #Unique Pattern
   class Unique:
   #Define some static variables here
       x = 1
       @classmethod
       def init(cls):
           #Define any computation performed when assigning to a "new" object
           return cls
   

   하나씩 일어나는 것

   #Singleton Pattern
   class Singleton:
   
       __single = None 
   
       def __init__(self):
           if not Singleton.__single:
               #Your definitions here
               self.x = 1 
           else:
               raise RuntimeError('A Singleton already exists') 
   
       @classmethod
       def getInstance(cls):
           if not cls.__single:
               cls.__single = Singleton()
           return cls.__single
   

   도시

   #Borg Pattern
   class Borg:
   
       __monostate = None
   
       def __init__(self):
           if not Borg.__monostate:
               Borg.__monostate = self.__dict__
               #Your definitions here
               self.x = 1
   
           else:
               self.__dict__ = Borg.__monostate
   

   테스트

   #SINGLETON
   print "\nSINGLETON\n"
   A = Singleton.getInstance()
   B = Singleton.getInstance()
   
   print "At first B.x = {} and A.x = {}".format(B.x,A.x)
   A.x = 2
   print "After A.x = 2"
   print "Now both B.x = {} and A.x = {}\n".format(B.x,A.x)
   print  "Are A and B the same object? Answer: {}".format(id(A)==id(B))
   
   
   #BORG
   print "\nBORG\n"
   A = Borg()
   B = Borg()
   
   print "At first B.x = {} and A.x = {}".format(B.x,A.x)
   A.x = 2
   print "After A.x = 2"
   print "Now both B.x = {} and A.x = {}\n".format(B.x,A.x)
   print  "Are A and B the same object? Answer: {}".format(id(A)==id(B))
   
   
   #UNIQUE
   print "\nUNIQUE\n"
   A = Unique.init()
   B = Unique.init()
   
   print "At first B.x = {} and A.x = {}".format(B.x,A.x)
   A.x = 2
   print "After A.x = 2"
   print "Now both B.x = {} and A.x = {}\n".format(B.x,A.x)
   print  "Are A and B the same object? Answer: {}".format(id(A)==id(B))
   

   산출:

   제 생각에는 고유 구현이 가장 쉽고, Borg이고, 마지막으로 Singleton이 정의에 필요한 두 가지 함수의 추악한 수입니다.

3. ==============================

   3.그렇지 않습니다. 일반적으로 권장되지 않는 것은 python에서 이와 같은 패턴입니다.

   그렇지 않습니다. 일반적으로 권장되지 않는 것은 python에서 이와 같은 패턴입니다.

   class Singleton(object):
   
    _instance = None
   
    def __init__(self, ...):
     ...
   
    @classmethod
    def instance(cls):
     if cls._instance is None:
      cls._instance = cls(...)
     return cls._instance
   

   클래스 메소드를 사용하여 생성자 대신 인스턴스를 가져옵니다. 파이썬의 메타 프로그래밍은 훨씬 더 나은 방법을 허용합니다. 위키 피 디아에있는 것 :

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

4. ==============================

   4.클래스는 기본적으로 객체의 내부 상태에 액세스 (읽기 / 쓰기)하는 방법을 설명합니다.

   클래스는 기본적으로 객체의 내부 상태에 액세스 (읽기 / 쓰기)하는 방법을 설명합니다.

   싱글 톤 패턴에는 단일 클래스 만있을 수 있습니다. 즉, 모든 객체가 공유 상태에 대한 동일한 액세스 포인트를 제공합니다. 즉, 확장 API를 제공해야한다면 래퍼 (wrapper)를 작성하고 싱글 톤 (singleton)을 둘러 싸야합니다.

   borg 패턴에서는 기본 "borg"클래스를 확장 할 수 있으므로 API를보다 편리하게 확장 할 수 있습니다.

5. ==============================

   5.실제로 차이가 나는 경우는 극히 적습니다. 서브 클래 싱 할 때처럼. Borg 패턴은 매우 드문 일이며, 필자는 10 년 동안의 Python 프로그래밍에서 그 사실을 절대 필요로하지 않았다.

   실제로 차이가 나는 경우는 극히 적습니다. 서브 클래 싱 할 때처럼. Borg 패턴은 매우 드문 일이며, 필자는 10 년 동안의 Python 프로그래밍에서 그 사실을 절대 필요로하지 않았다.

6. ==============================

   6.또한 Borg-like 패턴을 사용하면 클래스 사용자가 상태를 공유하거나 별도의 인스턴스를 만들지 여부를 선택할 수 있습니다. (이것이 좋은 아이디어 일지 여부는 별도의 주제입니다)

   또한 Borg-like 패턴을 사용하면 클래스 사용자가 상태를 공유하거나 별도의 인스턴스를 만들지 여부를 선택할 수 있습니다. (이것이 좋은 아이디어 일지 여부는 별도의 주제입니다)

   class MayBeBorg:
       __monostate = None
   
       def __init__(self, shared_state=True, ..):
           if shared_state:
   
               if not MayBeBorg.__monostate:
                   MayBeBorg.__monostate = self.__dict__
               else:
                   self.__dict__ = MayBeBorg.__monostate
                   return
           self.wings = ..
           self.beak = ..
   

from https://stackoverflow.com/questions/1318406/why-is-the-borg-pattern-better-than-the-singleton-pattern-in-python by cc-by-sa and MIT license