Eine beispielhafte Einführung in „Appearance Pattern“ zum Erlernen von Python-Entwurfsmustern

In Python befürworten das Design Pattern und das Appearance Pattern die Aufteilung des Codes in mehrere Module, um die Kopplung zu reduzieren. Die folgenden Beispiele werden 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()

ähnelt etwas dem Proxy-Modus, der Unterschied besteht darin, dass der Darstellungsmodus nicht nur ein Proxy ist 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 des Subsystems semantisch erfüllen Ebene.

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.

Sehen 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

Das obige ist der detaillierte Inhalt vonEine beispielhafte Einführung in „Appearance Pattern“ zum Erlernen von Python-Entwurfsmustern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!