Premièrement, le premier mot

Dans de nombreuses impressions de nombreuses personnes, Python est également un langage de programmation dynamique qui implique rarement le mode de conception dans le développement quotidien. En fait, tout langage de programmation peut utiliser des conceptions, assurer des spécifications de code, une manière légèrement différente de toutes les langues. Aujourd'hui, nous parlons de l'entretien Python, souvent posé cinq designs, ils sont: un cas unique, modèle d'usine, régime de construction, mode proxy, mode d'observation.

Deuxièmement, le mode Single Shell

Le mode de conception unique est le mode de conception le plus simple et populaire, l'objectif principal est de garantir qu'un objet un objet n'existera que Réduire le Consommation de ressources, le modèle d'affaire Python présente de nombreuses implémentations, recommandées ci-dessous.

Réécrit le __New__

Détermination de la variation existante, garantissant que cette variable est uniquement initialisée une fois dans __New__ méthodeC
# 单例模式class Singleton(object): _instance = None def __new__(cls, *args, **kwargs): if cls._instance is None: cls._instance = object.__new__(cls, *args, **kwargs) return cls._instance La méthode d'utilisation est la suivante:

Deux 2, décorées sont définies à la fermeture if __name__ == '__main__': # 构建3个实例 instance1 = Singleton() instance2 = Singleton() instance3 = Singleton() # 打印出实例的内存地址，判断是否是同一个实例 print(id(instance1)) print(id(instance2)) print(id(instance3))
Identifier une seule façade de la clôture de la décoration de la coque, cachant le Définition de la classe en fonction fermée
Utilisation de la couche de décoration ci-dessus, l'exemple intégré peut garantir que le seul exemple est présent
def singleton(cls): """ 定义单例的装饰器（闭包） :param cls: :return: """ _instance = {} def _singleton(*args, **kargs): if cls not in _instance: _instance[cls] = cls(*args, **kargs) return _instance[cls] return _singleton

. @singletonclass Singleton(object): """单例实例""" def __init__(self, arg1): self.arg1 = arg1
Il convient de noter que le seul exemple créé ci-dessus ne s'applique pas à plusieurs flux
pour s'assurer que l'exemple d'objet est intégré dans de nombreux threads est un seul cas, lors de l'utilisation de flux () dans Fonction __New__, initialisez l'objet dans la tâche d'écoulement, exécutez le thème if __name__ == '__main__': instance1 = Singleton("xag") instance2 = Singleton("xingag") print(id(instance1)) print(id(instance2))

Cela garantit que la version de la création multi-threadé est une existence et ne causera pas de données sales!
MARDI, Mode d'usine class Singleton(object): """ 实例化一个对象 """ # 锁 _instance_lock = threading.Lock() def __init__(self): pass def __new__(cls, *args, **kwargs): if not hasattr(Singleton, "_instance"): with Singleton._instance_lock: if not hasattr(Singleton, "_instance"): Singleton._instance = object.__new__(cls) return Singleton._instance
Prenez trois types de choses comme un exemple, identifiant trois fruits, nommément des pommes, des bananes, des oranges
def task(arg): """ 任务 :param arg: :return: """ instance = Singleton() print(id(instance), '\n')if __name__ == '__main__': # 3个线程 for i in range(3): t = threading.Thread(target=task, args=[i, ]) t.start() Le modèle d'usine comprend: simple usine , méthode d'usine, usine abstraite

Factory simple

L'usine est simplement le modèle d'usine le plus populaire, adapté aux simples scènes d'affaires

d'abord, identifiez une couche d'usine, créant ainsi une méthode statique, selon Au type d'entrée, renvoie différents objets

lorsque le mode est comme suit: # 定义一系列水果class Apple(object): """苹果""" def __repr__(self): return "苹果"class Banana(object): """香蕉""" def __repr__(self): return "香蕉"class Orange(object): """橘子""" def __repr__(self): return "橘子"

2e éveil, usine
La méthode de la création d'objets sera déployé pour être déployé, garantissant que le code d'origine
n'a pas à modifier le code d'origine
, créer une couche d'usine publique abstraite et identifier une méthode de production d'un objet class FactorySimple(object): """简单工厂模式""" @staticmethod def get_fruit(fruit_name): if 'a' == fruit_name: return Apple() elif 'b' == fruit_name: return Banana() elif 'o' == fruit_name: return Orange() else: return '没有这种水果'

Ensuite, créant trois sous-classes de classes d'usine abstraites et de méthodes de réécriture, créez une expression et de retour

if __name__ == '__main__': # 分别获取3种水果 # 输入参数，通过简单工厂，返回对应的实例 instance_apple = FactorySimple.get_fruit('a') instance_banana = FactorySimple.get_fruit('b') instance_orange = FactorySimple.get_fruit('o')

La méthode d'utilisation finale est la suivante:
Séquences et usines Résumé
Si une usine devrait produire de nombreux produits, utilisez la méthode d'usine, vous devez écrire beaucoup d'usines, maisCreed, il peut résoudre ce problème avec une usine abstraite import abcfrom factory.fruit import *class AbstractFactory(object): """抽象工厂""" __metaclass__ = abc.ABCMeta @abc.abstractmethod def get_fruit(self): pass
Frit Deux plats dans le restaurant Sichuan et Xiang Hui, comme exemple
Premier, créez d'abord des plats Sichuan, de la cuisine Sichuan Petite viande frite, des légumes Hunan , 小 4 class AppleFactory(AbstractFactory): """生产苹果""" def get_fruit(self): return Apple()class BananaFactory(AbstractFactory): """生产香蕉""" def get_fruit(self): return Banana()class OrangeFactory(AbstractFactory): """生产橘子""" def get_fruit(self): return Orange()

if __name__ == '__main__': # 每个工厂负责生产自己的产品也避免了我们在新增产品时需要修改工厂的代码，而只要增加相应的工厂即可 instance_apple = AppleFactory().get_fruit() instance_banana = BananaFactory().get_fruit() instance_orange = OrangeFactory().get_fruit() print(instance_apple) print(instance_banana) print(instance_orange)
puis identifié une couche d'usine abstraite, dans la définition interne de deux méthodes, peut créer une petite viande frite et une viande frite

Suivant, deux couches d'enfants, des aliments Sichuan et des légumes Hunan et des méthodes réécrites, ont ensuite créé l'objet objet respectif

Enfin, deux plats ont été utilisés pour spéculer Dans la vérité de l'usine de Sichuan et l'usine végétarienne Hunan, et le modèle d'usine
utilise enfin quotidiennement. Deux designs les plus fréquents. class MaoXW_CC(object): """川菜-毛血旺""" def __str__(self): return "川菜-毛血旺"class XiaoCR_CC(object): """川菜-小炒肉""" def __str__(self): return "川菜-小炒肉"class MaoXW_XC(object): """湘菜-毛血旺""" def __str__(self): return "湘菜-毛血旺"class XiaoCR_XC(object): """湘菜-小炒肉""" def __str__(self): return "湘菜-小炒肉"