Python 디자인 모드

프 록 시 모드:https://blog.csdn.net/liuskyter/article/details/80362722
단일 모드:
__call__실현

class MyMeta(type):
    obj =None  #          
    def __call__(self,*args,**kwargs):  #call    init       ，               
        if not self.obj:       #  obj    None，   self player 
            obj = object.__new__(self)     #object    new  ，        
            self.obj = obj    #   self. self.obj  ，    ，           。
            self.__init__(obj,*args,**kwargs)  #  player  init  
        return self.obj   #  return       ，          if           ，    self.obj  ，          

   



class player(metaclass=MyMeta):
    obj =None

	def __init__(self,*args,**kwargs):
	    print('          ')
	    pass
	
	def play(self,path):
	    print('playing'+path)

__new__실현

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'instance'):
            cls.instance = super(Person,cls).__new__(cls)
        return cls.instance


a = Person('p1',20)
b = Person('p2',21)
print(a == b)

공장 모드
단순 공장
구조 가 간단 한 공장 은 모든 자동 차 를 예화 하 는 과정 을 안에 밀봉 했다.

class SimpleCarFactory(object):
    """    
    """
    @staticmethod
    def product_car(name):
        if name == 'mb':
            return Mercedes()
        elif name == 'bmw':
            return BMW()

Simple CarFactory 클래스 가 있 으 면 고정된 인터페이스 에 매개 변 수 를 입력 하여 원 하 는 대상 인 스 턴 스 를 얻 을 수 있 습 니 다.

c1 = SimpleCarFactory.product_car('mb')
c2 = SimpleCarFactory.product_car('bmw')

공장 방법

#coding=utf-8
import abc

class AbstractFactory(object):
    """    
    """
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def product_car(self):
        pass

class MercedesFactory(AbstractFactory):
    """      
    """
    def product_car(self):
        return Mercedes()

class BMWFactory(AbstractFactory):
    """    
    """
    def product_car(self):
        return BMW()

모든 공장 이 자신의 제품 을 생산 하 는 것 을 책임 지 는 것 도 우리 가 제품 을 새로 만 들 때 공장 의 코드 를 수정 해 야 하 는 것 을 피 할 수 있 고 해당 하 는 공장 만 늘 리 면 된다.Audi 제품 이 추가 되면 Audi 류 와 AudiFactory 류 만 추가 하면 됩 니 다.

c1 = MercedesFactory().product_car()
c2 = BMWFactory().product_car()

추상 공장
만약 우리 가 많은 제품 을 생산 하려 고 한다 면, 우리 역시 대응 하 는 공장 류 를 많이 써 야 한 다 는 것 을 알 게 될 것 이다.예 를 들 어 Mercedes Factory 와 BMW Factory 가 소형 자동차 뿐만 아니 라 SUV 도 생산 한다 면 우 리 는 공장 방법 으로 SUV 를 생산 하 는 두 개의 공장 류 를 더 만들어 야 한다.그래서 이 문 제 를 해결 하기 위해 우 리 는 한 공장 이 같은 종류의 여러 제품 을 생산 할 수 있 도록 더욱 추상 적 인 공장 류 를 만들어 야 한다. 이것 이 바로 추상 적 인 공장 이다.

#coding=utf-8
import abc

#      
class Mercedes_C63(object):
    """     C63
    """
    def __repr__(self):
        return "Mercedes-Benz: C63"

class BMW_M3(object):
    """   M3
    """
    def __repr__(self):
        return "BMW: M3"

#　  SUV
class Mercedes_G63(object):
    """     G63
    """
    def __repr__(self):
        return "Mercedes-Benz: G63"

class BMW_X5(object):
    """   X5
    """
    def __repr__(self):
        return "BMW: X5"

class AbstractFactory(object):
    """    
            ，     SUV
    """
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def product_car(self):
        pass

    @abc.abstractmethod
    def product_suv(self):
        pass

class MercedesFactory(AbstractFactory):
    """      
    """
    def product_car(self):
        return Mercedes_C63()

    def product_suv(self):
        return Mercedes_G63()

class BMWFactory(AbstractFactory):
    """    
    """
    def product_car(self):
        return BMW_M3()

    def product_suv(self):
        return BMW_X5()

우 리 는 기본 클래스 인 Abstract Factory 로 하여 금 자동차 와 SUV 를 동시에 생산 할 수 있 게 한 다음 에 Mercedes Factory 와 BMW Factory 로 하여 금 Abstract Factory 를 계승 하여 produt 을 다시 쓰 게 합 니 다.car 와 produtsuv 방법 이면 됩 니 다.

c1 = MercedesFactory().product_car()
s1 = MercedesFactory().product_suv()
print(c1, s1)
s2 = BMWFactory().product_suv()
c2 = BMWFactory().product_car()
print(c2, s2)

결론: 간단 한 공장 모델 은 만들어 야 할 대상 이 비교적 적 고 공장 방법 중의 업무 논리 가 너무 복잡 하지 않 은 상황 에서 적용 된다. 또한 사용 자 는 그런 유형의 인 스 턴 스 가 생 성 되 는 것 에 만 관심 을 가지 고 초기 화 과정 에 관심 을 가지 지 않 는 다. 예 를 들 어 다양한 데이터 베이스 (MySQL / MongoDB) 의 인 스 턴 스, 다양한 형식 파일 의 해석 기 (XML / JSON) 등 이다.공장 방법 모델 은 간단 한 공장 모델 의 장점 을 계승 하고 개선 되 었 다. 이 는 한 공장 류 를 통 해 모든 제품 의 설립 을 책임 지지 않 고 구체 적 인 설립 업 무 를 해당 하 는 서브 클래스 에 맡 기 면 공장 방법 모델 은 시스템 이 더욱 효율 적 으로 확 대 될 수 있다.실제 응용 에 서 는 시스템 로그 시스템 등 을 실현 할 수 있 습 니 다. 예 를 들 어 구체 적 인 프로그램 실행 로그, 네트워크 로그, 데이터베이스 로그 등 은 모두 구체 적 인 공장 류 로 만 들 수 있 습 니 다.추상 적 인 공장 모델 은 공장 방법 을 바탕 으로 공장 이 여러 제품 에 대한 지원 을 확 대 했 고 일부 대형 시스템 에 더욱 적합 하 다. 예 를 들 어 시스템 에 하나 이상 의 제품 족 이 있 고 이런 제품 족의 제품 은 똑 같은 인 터 페 이 스 를 실현 해 야 한다. 예 를 들 어 많은 소프트웨어 시스템 인터페이스 에서 주제 와 다른 버튼, 텍스트 상자, 글꼴 등 이다.
건설 자 모드
사격 게임 을 할 때 우리 가 주 무 기 를 샀 다 고 가정 하고 부품 을 맞 춰 야 한다 면 우리 가 구 매 한 주 무기 의 주 류 는?

class Main(object):
	def __init__(self, name):
		self.name = name
	def muffler_level(self,muffler_level):  #    
		self.muffler_level= muffler_level
	def capacity(self,capacity_level): #    
		self.capacity_level= capacity_level

주 무기 류 를 예화 하 다.

m4 = Main('m4')

그리고 저희 가 A 사 소음기 랑 B 사 핀 을 샀 어 요.
소음기

class Muffler(self, name,muffler_level):
	def __init__(self,name.muffler_level):
			self.name = name 
			self.muffler_level = muffler_level

탄창 류 용량

class Capacity(self,name,capacity_level):
	def __init__(self,capacity):
		self.name = name 
		self.capacity = capacity

두 부품 류 를 예화 하 다.

muffler_A =  Muffler('A',90)
capacity_B = Capacity('B','30')

무 기 를 조립 하고 우리 가 예화 한 m4 의 소음 효과 와 핀 용량 은 우리 가 구 매 한 소음기 A 와 핀 B 의 속성 에 달 려 있다. (하나의 속성 이나 예화 대상) 을 다른 종류의 속성 으로 밀봉 하 는 방식 을 우 리 는 건설 자 모델 이 라 고 부른다.

m4.muffler_level(muffler_A.muffler_level)
m4.capaciy(capacity_B.capacity)

관찰자 모드:
https://www.jianshu.com/p/730d7c5bd596