python singleton design pattern super() 多繼承

python  singleton design pattern 

1.  decorate

2.  baseclass

3.  metaclass

4.  import module

5. super()

1、A decorator

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 自己已是一個函數。不是一個類，因此你不能經過它來調用類的方法。因此對於

m=MyClass() n = MyClass()  o=type(n)()   m==n and m!=o and n != o  將會是True

 

2、baseclass

class Singleton(object):
    _instance = None
    def __new__(class_, *args, **kwargs):
        if not isinstance(class_._instance, class_):
            # class_._instance = object.__new__(class_)   這行語句和下一行語句做用同樣的
            class_._instance=super(Singleton,class_).__new__(class_)
        return class_._instance
class MyClass(Singleton):
    def __init__(self,name):
        self.name = name
        print(name)

 

pros  

　　是真的類

cons:

在多繼承的時候要注意

3、metaclass

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

 

Pros

• It's a true class
• Auto-magically covers inheritance
• Uses __metaclass__ for its proper purpose (and made me aware of it)

---

 

4、經過導入模塊

 

 

 

---

 

5、

super(type[,object or type])

 

If the second argument is omitted, the super object returned is unbound. If the second argument is an object, isinstance(obj, type) must be true.

If the second argument is a type, issubclass(type2, type) must be true (this is useful for classmethods).

 

 

note :super()  只能用於新式類

連接 https://rhettinger.wordpress.com/2011/05/26/super-considered-super/

 

多繼承，在python3 中所有都是新式類

新式類的繼承順序是廣度優先，python2 中的經典類是深度優先

經過一個例子來理解

class A(object):
    def f1(self):
        print('a.f1')

class B(A):
    def f2(self):
        print('b.f1')
    
class F(object):
    def f1(self):
        print('f.f1')

class C(B,F):
    def f3(self):
        print('c.f1')

insta = C()
insta.f1()

 

關係圖

        

 

 將會打印出a.f1

若是代碼改成

class A(object):
    def f1(self):
        print('a.f1')

class B(A):
    def f2(self):
        print('b.f1')
    
class F(A):
    def f1(self):
        print('f.f1')

class C(B,F):
    def f3(self):
        print('c.f1')

insta = C()
insta.f1()

 

 關係圖以下：

 

 運行結果是f.f1

 

 

---

 

python 2 代碼以下

class A:  #經典類
    def foo(self):
        print'A'
class B(A):

    def foo(self):
        print'B'
class C(A):
    pass
    #def foo(self):
     #   print'C'
class D(B):
    #def foo(self):
     #   print 'D'
    pass

class F(B):
    #pass
    def foo(self):
        print 'F'
        pass

class G(D,F):
    pass
g1=G()
g1.foo()  #打印出  B

 

 

 

---

python 3 代碼

class A(object):
    def f1(self):
        print('a.f1')

class B(A):
    pass
     def f1(self):
         print('b.f1')
    
class C(A):
    def f1(self):
        print('c.f1')

class D(B):
    pass
    # def f1(self):
    #     print('D.f1')

class F(B):
    pass
    def f1(self):
        print('f.f1')

class G(D,F):
    # def f1(self):
    #     print('g.f1')
    pass
    
insta = G()
insta.f1()  #打印出f.f1