Python 단일 모드: 5 가지 실현 방식

목차
  • 단일 모드
  • 모듈 구현 사례
  • 류 장식 기 실현
  • 클래스 바 인 딩 방법 기반
  • new 방법 으로 실현
  • 원 류 는 단일 모델
  • 을 실현 한다.

    단일 모드
    단일 모드 (Singleton mode): 흔히 볼 수 있 는 소프트웨어 디자인 모델 로 이 디자인 모델 의 주요 목적 은 특정한 유형 에 하나의 인 스 턴 스 만 존재 하도록 확보 하 는 것 이다.
    예 를 들 어 많은 인 스 턴 스 가 생 겼 는데 그들 이 하 는 일 은 메 일 을 보 내 는 기능 만 수행 할 뿐이다.이것 은 인 스 턴 스 를 자주 만 들 고 소각 하기 때문에 메모리 자원 을 특히 낭비 할 것 이다.
    장점:
    1. 단일 모드 는 메모리 에 하나의 인 스 턴 스 만 있 기 때문에 메모리 지출 을 줄 일 수 있 습 니 다. 특히 한 대상 이 자주 만 들 고 소각 해 야 할 때 만 들 거나 소각 할 때 성능 이 최적화 되 지 못 하기 때문에 단일 모드 는 2. 단일 모드 는 자원 에 대한 다 중 점용 을 피 할 수 있 습 니 다.한 번 에 한 명의 사용자 만 받 아들 이 고 방문 해서 사용 하려 면 이전 사용 이 끝 날 때 까지 기 다 려 야 한다.
    단점:
    1. 변화 하 는 대상 에 적용 되 지 않 습 니 다. 만약 에 같은 유형의 대상 이 서로 다른 사례 장면 에서 변 화 를 일 으 키 려 면 단일 사례 는 데이터 의 오 류 를 일 으 키 고 서로의 상 태 를 저장 할 수 없습니다.2. 단일 모드 는 추상 층 이 없고 확장 이 어렵 습 니 다. 확장 하려 면 코드 를 수정 하 는 것 외 에 다른 선택 이 없습니다.
    모듈 구현 사례
    모듈 을 알 아 보면 첫 번 째 방문 모듈 이후. pyc 파일 을 생 성하 여 첫 번 째 방문 상 태 를 저장 합 니 다.이후 의 매번 접근 모듈 은 그. pyc 파일 을 직접 불 러 옵 니 다.이 점 에서 알 수 있 듯 이 Python 모듈 은 천연 적 인 단일 모델 이다.
    시작 실례:
    # test.py
    class People:
        pass
            
    people = People()
    
    # run.py
    from test import people
    
    p1 = people
    
    p2 = people
    
    print(p1 is p2) # is             ,    ,          
    

    실행 결과
    True
    

    클래스 장식 기 구현
    def Signleton(cls):
        instance = False  #      ,         
    
        def inner(*args, **kwargs):
            nonlocal instance
    
            if not instance:  #     ,       
                instance = cls(*args, **kwargs)  #   People ,      
    
            instance.__init__(*args, **kwargs)  #            
            return instance  #       
    
        #  instance      ,if     ,                 
    
        return inner
    
    
    @Signleton
    class People:  # People = Signleton(People) = inner
        def __init__(self, name):
            self.name = name
    
        def send_email(self):
            print(f'{self.name}     ~')
    
    
    p1 = People('jack')  #    inner  
    p1.send_email()
    
    p2 = People('tom')
    p2.send_email()
    
    p1.send_email() #     p1,         
    
    print(p1 is p2)  # is             ,    ,          
    

    실행 결과
    'jack     ~'
    'tom     ~'
    'tom     ~'
    True
    

    같은 인 스 턴 스 를 사용 하기 때문에 두 번 째 사용 시 이 인 스 턴 스 의 속성 을 변경 한 것 을 볼 수 있 습 니 다.그래서 내용 을 다시 인쇄 하 는 것 이 마지막 변경 결과 입 니 다.
    클래스 기반 바 인 딩 방법
    class People:
        instance = False #      ,     
    
        def __init__(self,name):
            self.name = name
    
        @classmethod #      
        def get_signleton_obj(cls,*args,**kwargs):
            if not cls.instance: #   instance  ,       
                cls.instance = cls(*args,**kwargs)
                #   People ,      ,   instance  
    		
            cls.instance.__init__(*args,**kwargs) #              
            return cls.instance
    
        def send_email(self):
            print(f'{self.name}     ~')
    
    p1 = People.get_signleton_obj('jack')
    p1.send_email()
    
    p2 = People.get_signleton_obj('tom')
    p2.send_email()
    
    print(p1 is p2) # is             ,    ,          
    
    'jack     ~'
    'tom     ~'
    True
    

    new 방법 으로 구현
    class People:
        instance = None #         
        
        def __new__(cls, *args, **kwargs):
            if not cls.instance: #   instance  ,       
                cls.instance = super().__new__(cls)
    
            return cls.instance
    	
    	#           ,     new  ,   init      
        def __init__(self,name):
            self.name = name
    
        def send_email(self):
            print(f'{self.name}     ~')
    
    p1 = People('jack')
    p1.send_email()
    
    p2 = People('tom')
    p2.send_email()
    
    print(p1 is p2)
    

    실행 결과
    'jack     ~'
    'tom     ~'
    True
    

    메타 클래스 구현 단일 예 모드
    class MyType(type):
        instance = False  #      
    
        def __call__(self, *args, **kwargs):
            #           instance,               
            if not self.instance:
                #           ,          。
                self.instance = super().__call__(*args, **kwargs)
    
            #                 
            self.instance.__init__(*args, **kwargs)
            
            return self.instance #       
    
    		#             instance,            ,   True  ,   if,               
    
    
    class People(metaclass=MyType):
    
        def __init__(self,name):
            self.name = name
    
        def send_email(self):
            print(f'{self.name}     ~')
    
    
    p = People('jack')
    p.send_email()
    
    p1 = People('tom')
    p1.send_email()
    
    print(id(p), id(p1))  #            ,           
    

    이상 은 필자 가 생각 할 수 있 는 Python 을 사용 하여 단일 모델 을 실현 하 는 5 가지 방식 이다.
    기술 소 백 은 학습 과정 을 기록 하고 잘못 되 거나 이해 되 지 않 는 부분 이 있 으 면 지적 해 주 십시오. 만약 이 글 이 당신 에 게 도움 이 된다 면 + 자정 에 당신 의 관심 을 기대 해 주 십시오. 지지 해 주 셔 서 감사합니다!

    좋은 웹페이지 즐겨찾기