Beispielerklärung zum Python-Entwurfsmuster „Darstellungsmuster“.

Das Erscheinungsmuster von Entwurfsmustern in Python empfiehlt die Aufteilung des Codes in mehrere Module, um die Kopplung zu reduzieren. Im Folgenden werden Beispiele zur Veranschaulichung verwendet.

Anwendungsfunktionen:

Wenn viele komplexe und kleine Funktionen aufgerufen werden müssen und diese Aufrufe oft bis zu einem gewissen Grad miteinander verbunden sind, das heißt, ein Aufruf ist eine Serie.

Strukturelle Merkmale:

Vereinen Sie die ursprünglichen komplexen und zahlreichen Aufrufe in einer Eintragsklasse, und von nun an können Sie nur noch über diesen einen Eintrag aufrufen.

Beispiel für die Codestruktur:

class ModuleOne(object):
  def Create(self):
    print 'create module one instance'
  def Delete(self):
    print 'delete module one instance'
class ModuleTwo(object):
  def Create(self):
    print 'create module two instance'
  def Delete(self):
    print 'delete module two instance'
class Facade(object):
  def __init__(self):
    self.module_one = ModuleOne()
    self.module_two = ModuleTwo()
  def create_module_one(self):
    self.module_one.Create()
  def create_module_two(self):
    self.module_two.Create()
  def create_both(self):
    self.module_one.Create()
    self.module_two.Create()
  def delete_module_one(self):
    self.module_one.Delete()
  def delete_module_two(self):
    self.module_two.Delete()
  def delete_both(self):
    self.module_one.Delete()
    self.module_two.Delete()

Es ähnelt in gewisser Weise dem Proxy-Modus. Der Unterschied besteht im Darstellungsmodus nicht nur Proxy Die Funktionen jedes Moduls des Subsystems stellen aus Sicht des Subsystems übergeordnete Schnittstellen zur Außenwelt bereit, indem sie die Funktionen jedes Moduls des Subsystems kombinieren und so die Anforderungen der Subsystemebene semantisch erfüllen.

Mit der kontinuierlichen Erweiterung der Systemfunktionen kommt normalerweise der Proxy-Modus ins Spiel, wenn das System in mehrere Subsysteme oder Submodule unterteilt werden muss, um die Kopplung zu verringern, die Komplexität des Systemcodes zu verringern und die Wartbarkeit zu verbessern.

Schauen wir uns ein weiteres Beispiel an:

class small_or_piece1: 
  def __init__(self): 
    pass 
    
  def do_small1(self): 
    print 'do small 1' 
    
class small_or_piece_2: 
  def __init__(self): 
    pass 
    
  def do_small2(self): 
    print 'do small 2' 
    
class small_or_piece_3: 
  def __init__(self): 
    pass 
    
  def do_small3(self): 
    print 'do small 3' 
  
class outside: 
  def __init__(self): 
    self.__small1 = small_or_piece1() 
    self.__small2 = small_or_piece_2() 
    self.__small3 = small_or_piece_3() 
    
  def method1(self): 
    self.__small1.do_small1()  ##如果这里调用的不只2两函数，作用就显示出来了，可以把原本复杂的函数调用关系清楚化，统一化 
    self.__small2.do_small2() 
      
  def method2(self): 
    self.__small2.do_small2() 
    self.__small3.do_small3() 
  
if __name__ == '__main__': 
  osd = outside() 
  osd.method1() 
  osd.method2()

Ergebnis:

do small 1 
do small 2 
do small 2 
do small 3