20201207_115.设计模式_单例模式实现

设计模式_单例模式实现

单例模式（Singleton Pattern）的核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。
单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较多的资源，如读取配置文件、产生其他依赖对象时，可以产生一个“单例对象”，然后永久驻留内存中，其他需要读取配置参数的到这个读取了配置文件的对象中去引用就行了（读取配置文件的时候），从而极大的降低开销。
单例模式有多种实现的方式，这里根据已掌握的知识基础，只介绍“重写__new__()同时特殊定义构造函数”的方法。

【案例1】 “重写__new__()同时特殊定义构造函数”的方法举例，对象只创建和初始化了1次。

class MySingleton:
    __obj = None  # 把创建的单例保存在这个类属性中，单例创建好了之后，通过“类名._MySingleton__obj”访问这个单例。
    __init_flag = True

    def __new__(cls, *args, **kwargs):
        if cls.__obj is None:
            cls.__obj = object.__new__(cls)

        return cls.__obj  # 这句一定不能缺

    def __init__(self, name):
        if MySingleton.__init_flag:
            print('init...')
            self.name = name
            MySingleton.__init_flag = False


a = MySingleton('aa')
print(a)
b = MySingleton('bb')
print(b)

运行结果：

设计模式称之为“模式”，就是一些固定的套路。我们很容易用到其他场景上，比如前面讲的工厂模式，我们需要将工厂类定义成“单例”，只需要简单的套用即可实现：

【案例2】工厂模式和单例模式的一起使用

class CarFactory:
    """单例模式的工厂类"""
    __obj = None
    __init_flag = True

    def __new__(cls, *args, **kwargs):
        if cls.__obj is None:
            cls.__obj = object.__new__(cls)

        return cls.__obj  # 这句一定不能缺

    def __init__(self, name):
        if CarFactory.__init_flag:
            self.name = name
            print('汽车工厂类初始化完成。')
            CarFactory.__init_flag = False

    def creat_car(self, brand):
        if brand == '奔驰':
            return Benz()
        elif brand == '宝马':
            return BMW()
        elif brand == '比亚迪':
            return BYD()
        else:
            return '未知品牌，无法创建'


class Benz:
    pass


class BMW:
    pass


class BYD:
    pass


factory = CarFactory('gg')
f2 = CarFactory('tt')
print(factory, f2)
c1 = factory.creat_car('奔驰')
c2 = factory.creat_car('宝马')
print(c1)
print(c2)

运行结果：

实操作业8

1.如下代码测试对象的浅拷贝、深拷贝，请绘制出内存示意图。

# 测试对象的引用赋值、浅拷贝、深拷贝
import copy


class MobilePhone:

    def __init__(self, cpu, screen):
        self.cpu = cpu
        self.screen = screen


class CPU:

    def calculate(self):
        print('进行计算')
        print('CPU对象：{}'.format(self))


class Screen:

    def show(self):
        print('显示画面')
        print('屏幕对象：{}'.format(self))


c = CPU()
s = Screen()
m = MobilePhone(c, s)

m.cpu.calculate()

n = m  # 两个变量，但是指向了同一个对象
print(m, n)

m2 = copy.copy(m)  # m2是新浅拷贝的另一个手机对象
print(m, m2)

m.cpu.calculate()
m2.cpu.calculate()  # m2和m拥有一样的CPU、Screen对象

m3 = copy.deepcopy(m)
m3.cpu.calculate()  # m3和m拥有不一样的CPU、Screen对象

运行结果：
答：
内存示意图：

2.定义发动机类 Motor、底盘类 Chassis、座椅类 Seat，车辆外壳类 Shell，并使用组合关系定义汽车类。其他要求如下：
定义汽车的 run()方法，里面需要调用 Motor 类的 work()方法，也需要调用座椅类 Seat 的 work()方法，也需要调用底盘类 Chassis 的 work()方法。

答：

class Car:
    """汽车类"""
    def __init__(self, chassis, motor, seat, shell):
        self.chassis = chassis
        self.motor = motor
        self.seat = seat
        self.shell = shell

    def run(self):
        self.chassis.work()
        self.seat.work()
        self.motor.work()
        print('组件工作正常，{}出发...'.format(self))


class Chassis:
    def work(self):
        print('{}开始工作，进行控制信号传递...'.format(self))


class Motor:
    def work(self):
        print('{}开始运转，输出动力...'.format(self))


class Seat:
    def work(self):
        print('{}确认已就位。'.format(self))


class Shell:
    pass


c = Chassis()
m = Motor()
se = Seat()
sh = Shell()
car = Car(c, m, se, sh)
car.run()

运行结果：

3.使用工厂模式、单例模式实现如下需求：
(1) 电脑工厂类 ComputerFactory 用于生产电脑 Computer。工厂类使用单例模式，也就是说只能有一个工厂对象；
(2) 工厂类中可以生产各种品牌的电脑：联想、华硕、神舟；
(3) 各种品牌的电脑使用继承实现；
(4) 父类是 Computer 类，定义了 calculate 方法；
(5) 各品牌电脑类需要重写父类的 calculate 方法。

答：

class ComputerFactory:
    """电脑生产，工厂模式+单例模式"""
    __obj = None
    __init_flag = True

    def __new__(cls, *args, **kwargs):
        if cls.__obj is None:
            cls.__obj = object.__new__(cls)

        return cls.__obj

    def __init__(self):
        if ComputerFactory.__init_flag:
            print('电脑生产工厂初始化完成。')
            ComputerFactory.__init_flag = False

    def produce_computer(self, brand):
        brand_list = {'联想':Lenovo, '华硕':Asus, '神舟':Hasee}
        return brand_list[brand]()


class Computer:
    def __init__(self, cpu=None, screen=None):
        self.cpu = cpu
        self.screen = screen

    def calculate(self):
        print('{}运算中'.format(self))


class Lenovo(Computer):
    __brand = '华硕'

    def __init__(self, cpu=None, screen=None):
        Computer.__init__(self, cpu=None, screen=None)

    def calculate(self):
        print('我是联想，感谢您的使用。{}运算中...'.format(self))


class Asus(Computer):
    __brand = '华硕'

    def __init__(self, cpu=None, screen=None):
        Computer.__init__(self, cpu=None, screen=None)

    def calculate(self):
        print('欢迎您使用华硕电脑。{}运算中...'.format(self))


class Hasee(Computer):
    __brand = '神舟'

    def __init__(self, cpu=None, screen=None):
        Computer.__init__(self, cpu=None, screen=None)

    def calculate(self):
        print('神舟，国货当自强，感谢支持！{}运算中...'.format(self))


pcpd = ComputerFactory()
pcpd2 = ComputerFactory()
print(pcpd, pcpd2)
h1 = pcpd.produce_computer('神舟')
h1.calculate()

运行结果：

4.定义一个 Employee 雇员类，要求如下：
(1) 属性有：id、name、salary；
(2) 运算符重载+：实现两个对象相加时，默认返回他们的薪水和；
(3) 构造方法要求：输入 name、salary，不输入 id。id 采用自增的方式，从 1000 开始自增，第一个新增对象是 1001，第二个新增对象是 1002；
(4) 根据 salary 属性，使用@property 设置属性的 get 和 set 方法。set 方法要求输入：1000-50000 范围的数字。

答：

class Employee:
    id = 1001

    def __init__(self, name, salary):
        self.name = name
        self.__salary = salary
        self.id = Employee.id
        Employee.id += 1

    def __add__(self, other):
        if isinstance(other, Employee):
            return self.__salary + other.__salary

    @property
    def salary(self):
        return self.__salary

    @salary.setter
    def salary(self, salary):
        if 1000 <= salary <= 50000:
            self.__salary = salary
        else:
            print('薪水输入有误，范围为1000-50000。')


e1 = Employee('乔布斯', 1)
e2 = Employee('库克', 48000)
print(e1.id, e2.id)
print(e1 + e2)
e1.salary = 42000
print(e1.salary)

运行结果：