[学習メモ]Pytho3で学ぶデザインパターン~生成に関するデザインパターン~

from abc import ABC,abstractclassmethod

class Factory(ABC):
    '''Creatorに該当する
    '''
    def __init__(self):
        self.registered_owner = []

    def create(self,owner):
        self.owner = owner
        product = self.create_product(owner)
        self.register_product(product)
        return product

    @abstractclassmethod
    def create_product(self):
        pass

    @abstractclassmethod
    def register_product(self):
        pass

class Car(ABC):
    '''Productに該当する
    '''
    @abstractclassmethod
    def use(self):
        pass

class SportsCar(Car):
    '''ConcreteProduct1に該当する
    '''
    def __init__(self,owner):
        self.owner = owner

    def use(self):
        print(f'{self.owner}のスポーツカーです')

class GeneralCar(Car):
    '''ConcreteProduct2に該当する
    '''
    def __init__(self,owner):
        self.owner = owner

    def use(self):
        print(f'{self.owner}の一般車です')

class SportsCarFactory(Factory):
    '''ConcreteCreator1に該当する
    '''
    def create_product(self,owner):
        return SportsCar(owner)

    def register_product(self, product: SportsCar):
        return self.registered_owner.append(product.owner)

class GeneralCarFactory(Factory):
    '''ConcreteCreator2に該当する
    '''
    def create_product(self,owner):
        return GeneralCar(owner)

    def register_product(self, product: GeneralCar):
        return self.registered_owner.append(product.owner)

sports_car_factory = SportsCarFactory()
# CarFactoryの継承元のCreate()を呼び出す
hoge_owner_car = sports_car_factory.create("HOGE")
hoge_owner_car.use()
fuga_owner_car = sports_car_factory.create("FUGA")
fuga_owner_car.use()
print(sports_car_factory.registered_owner)

general_car_factory = GeneralCarFactory()
hoge_owner_car = general_car_factory.create("PIYO")
hoge_owner_car.use()
fuga_owner_car = general_car_factory.create("POYO")
fuga_owner_car.use()
print(general_car_factory.registered_owner)

HOGEのスポーツカーです
FUGAのスポーツカーです
['HOGE', 'FUGA']
PIYOの一般車です
POYOの一般車です
['PIYO', 'POYO']

import random
from abstract_factory import (MotheBoardItem,
                              PcCaseItem,
                              Factory)

class MiddleTowerMotheBoard(MotheBoardItem):

    def __init__(self, name, maker):
        super().__init__(name, maker)
        self.id = random.randint(50,100)
    
    def make_parts(self):
        info = self.create()
        return '商品ID:{}・マザーボード名:{}・メーカー名:{}。'.format(self.id,info["商品名"],info["メーカー名"])

class MiddleTowerPcCase(PcCaseItem):
    def __init__(self, name, maker):
        super().__init__(name, maker)

    def make_parts(self):
        info = self.create()
        return 'PCケース名:{}・メーカー名:{}。'.format(info["商品名"],info["メーカー名"])


class MiddleTowerFactory(Factory):
    def create_pc(self, motheboard, pc_case):
        return print('PCが完成しました、内容:{}_{}'.format(motheboard,pc_case))

    def create_base_motheboard(self, name, maker):
        return MiddleTowerMotheBoard(name, maker)

    def create_base_pc_case(self, name, maker):
        return MiddleTowerPcCase(name, maker)


middle_tower_factory = MiddleTowerFactory()
gigabyte_base_motheboard = middle_tower_factory.create_base_motheboard('hoge','gigabyte')
gigabyte_motheboard = gigabyte_base_motheboard.make_parts()

asus_base_pc_case = middle_tower_factory.create_base_pc_case('fuge','ASUS')
asus_pc_case = asus_base_pc_case.make_parts()

middle_tower_factory.create_pc(gigabyte_motheboard,asus_pc_case)

from abc import ABCMeta, abstractmethod
class Item(metaclass = ABCMeta):
    '''抽象製品(インターフェース)
    '''
    def __init__(self, name, maker):
        self.name = name
        self.maker = maker
    
    @abstractmethod
    def make_parts(self):
        pass

class MotheBoardItem(Item):
    '''マザーボード商品クラス（抽象的）
    '''
    def __init__(self, name, maker):
        self.name = name
        self.maker = maker
    
    def create(self):
        return {
            '商品名': self.name,
            'メーカー名': self.maker
        }

class PcCaseItem(Item):
    '''PCケース商品クラス（抽象的）
    '''
    def __init__(self, name, maker):
        self.name = name
        self.maker = maker

    def create(self):
        return {
            '商品名': self.name,
            'メーカー名': self.maker
        }

class Factory(metaclass = ABCMeta):
    '''抽象工場(インターフェース)
    '''
    @abstractmethod
    def create_pc(self, name, maker):
        pass

    @abstractmethod
    def create_base_motheboard(self, name, maker):
        pass

    @abstractmethod
    def create_base_pc_case(self, name, maker):
        pass

class Hoge():
    def __init__(self, hoge="",fuga="",piyo="",poyo=""・・・・・):

from abc import ABC, abstractclassmethod

class Builder(ABC):
    '''抽象クラス(インターフェース)
    '''
    @abstractclassmethod
    def build_base(self):
        pass

    @abstractclassmethod
    def build_frame(self):
        pass

    @abstractclassmethod
    def build_wall(self):
        pass

class JapaneseStyleHouseBuilder(Builder):
    def __init__(self, material:dict):
        self.material = material

    def build_base(self):
        return '床材は{}で作成'.format(self.material["base"])

    def build_frame(self):
        return '柱は{}で作成'.format(self.material["frame"])

    def build_wall(self):
        return '壁は{}で作成'.format(self.material["wall"])

class ApartmentBuilder(Builder):
    def __init__(self, material:dict):
        self.material = material

    def build_base(self):
        return '床材は{}で作成'.format(self.material["base"])

    def build_frame(self):
        return '柱は{}で作成'.format(self.material["frame"])

    def build_wall(self):
        return '壁は{}で作成'.format(self.material["wall"])

class Director:
    def construct(self, builder:Builder):
        base = builder.build_base()
        frame = builder.build_frame()
        wall = builder.build_wall()
        return print(f'家は{base}。{frame}。{wall}で完成')

japanese_style_material = {
    "base" : "コンクリート",
    "frame" : "木材",
    "wall": "石膏"
    }
apartment_material = {
    "base" : "コンクリート",
    "frame" : "鉄筋",
    "wall": "石膏"
    }
japanese_style_house = JapaneseStyleHouseBuilder(japanese_style_material)
apartment = ApartmentBuilder(apartment_material)

director = Director()
director.construct(japanese_style_house)
director.construct(apartment)

from abc import ABCMeta, abstractmethod
import copy

class Prototype(metaclass = ABCMeta):

    @abstractmethod
    def call(self, s):
        pass

    @abstractmethod
    def create_clone(self):
        pass

class Sheep(Prototype):
    def __init__(self, name):
        self.name = name
        
    def call(self):
        return print(self.name)

    def create_clone(self):
        copy_object = copy.deepcopy(self)
        return copy_object

    @property
    def set_name(self):
        return self.name
    
    @set_name.setter
    def clone_set_name(self,name):
        self.name = name

merry = Sheep('メリーさん')
merry.call()
dolly = merry.create_clone()
dolly.name = 'ドリーさん'
dolly.call()

メリーさん
ドリーさん

from abc import ABCMeta, abstractmethod

class Prototype(metaclass = ABCMeta):

    @abstractmethod
    def call(self, s):
        pass

    @abstractmethod
    def create_clone(self):
        pass

class Sheep(Prototype):
    def __init__(self, name):
        self.name = name

    def call(self):
        return print(self.name)

    def create_clone(self):
        copy_object = self.__class__(self)
        return copy_object

    @property
    def set_name(self):
        return self.name
    
    @set_name.setter
    def clone_set_name(self,name):
        self.name = name

merry = Sheep('メリーさん')
merry.call()
dolly = merry.create_clone()
dolly.name = 'ドリーさん'
dolly.call()

メリーさん
ドリーさん

class Singleton():
    
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance
s_1 = Singleton()
s_2 = Singleton()
print(id(s_1),id(s_2))
print(s_1==s_2)

4531207904 4531207904
True

class Singleton2:
    _instance = None

    def __init__(self):
        if self._instance is None:
            Singleton2._instance = self

    @staticmethod
    def get_instance():
        if Singleton2._instance == None:
            Singleton2()
        return Singleton2._instance
s_2_1 = Singleton2.get_instance()
s_2_2 = Singleton2.get_instance()
print(id(s_2_1),id(s_2_2))
print(s_2_1==s_2_2)

4531207808 4531207808
True