Un exemple d'introduction au « Modèle d'apparence » pour apprendre les modèles de conception Python

En Python, le Design Pattern et le Appearance Pattern préconisent de diviser le code en plusieurs modules pour réduire le couplage. Les exemples suivants sont utilisés pour illustrer.

Fonctionnalités de l'application :

Lorsque de nombreuses fonctions complexes et petites doivent être appelées, et que ces appels sont souvent liés dans une certaine mesure, c'est-à-dire qu'un appel est une série.

Caractéristiques structurelles :

Unifiez le complexe d'origine et les nombreux appels en une seule classe d'entrée, et à partir de maintenant, vous ne pouvez appeler que via cette seule entrée.

Exemple de structure de code :

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()

est quelque peu similaire au Mode proxy, la différence est que le mode d'apparence n'est pas seulement proxy Les fonctions de chaque module du sous-système, du point de vue du sous-système, fournissent des interfaces de niveau supérieur avec le monde extérieur en combinant les fonctions de chaque module du sous-système, satisfaisant ainsi sémantiquement les besoins du sous-système. niveau.

Avec l'expansion continue des fonctions du système, lorsque le système doit être divisé en plusieurs sous-systèmes ou sous-modules pour réduire le couplage, réduire la complexité du code système et améliorer la maintenabilité, le mode proxy entre généralement en jeu.

Regardons un autre exemple :

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()

Résultat :

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!