Python基础知识学习记录 2021——1202(对象的浅拷贝和深拷贝，组合，设计模式（工厂模式实现），设计模式（单例模式实现）)

对象的浅拷贝和深拷贝

·变量的赋值操作
只是形成两个变量，实际还是指向同一个对象。
·浅拷贝
Python 拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝。因此，源对象和拷贝对象会引用同一个子对象。
·深拷贝
使用 copy 模块的 deepcopy 函数，递归拷贝对象中包含的子对象。源对象和拷贝对象所有的子对象也不同。

#测试对象的引用赋值、浅拷贝、深拷贝
import copy
class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen

class CPU:
    def calculate(self):
        print("计算，算个 12345")
        print("CPU 对象:",self)

class Screen:
    def show(self):
        print("显示一个好看的画面，亮瞎你的钛合金大眼")
        print("屏幕对象：",self)

#测试变量赋值
c1 = CPU()
c2 = c1 #两个变量，但是指向了同一个对象
print(c1)
print(c2)
print("测试浅复制。。。")
#测试浅复制
s1 = Screen()
m1 = MobilePhone(c1,s1)
m2 = copy.copy(m1)  #m2 是新拷贝的另一个手机对象
print(m1,m1.cpu,m1.screen)
print(m2,m2.cpu,m2.screen)

#测试深复制
print("测试深复制。。。")
m3 = copy.deepcopy(m1)
print(m1,m1.cpu,m1.screen)
print(m3,m3.cpu,m3.screen)

执行结果：

<__main__.CPU object at 0x000002591D400FD0>
<__main__.CPU object at 0x000002591D400FD0>
测试浅复制。。。
<__main__.MobilePhone object at 0x000002591D400F70> <__main__.CPU object at 0x000002591D400FD0> <__main__.Screen object at 0x000002591D400FA0>
<__main__.MobilePhone object at 0x000002591D400940> <__main__.CPU object at 0x000002591D400FD0> <__main__.Screen object at 0x000002591D400FA0>
测试深复制。。。
<__main__.MobilePhone object at 0x000002591D400F70> <__main__.CPU object at 0x000002591D400FD0> <__main__.Screen object at 0x000002591D400FA0>
<__main__.MobilePhone object at 0x000002591D4005B0> <__main__.CPU object at 0x000002591D402E20> <__main__.Screen object at 0x000002591D402E50>

组合

“is-a”关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a”
关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。
“has-a”关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。”
has-a”关系指的是这样的关系：手机拥有 CPU。 MobilePhone has a CPU。

#测试组合
# 使用继承实现代码的复用
class A1():
    def say_a1(self):
        print("a1,a1,a1")

class B1(A1):
    pass
b1 = B1()
b1.say_a1()

# 使用组合实现代码的复用
class A2:
    def say_a2(self):
        print("a2,a2,a2")

class B2:
    def __init__(self,a):
        self.a = a

a2 = A2()
b2 = B2(a2)
b2.a.say_a2()

执行结果：

a1,a1,a1
a2,a2,a2

设计模式

设计模式是面向对象语言特有的内容，是我们在面临某一类问题时候固定的做法，设计模式有很多种，比较流行的是：GOF（Goup Of Four）23 种设计模式。

工厂模式实现

工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。

#工厂模式
class CarFactory:
    def createCar(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()
c1 = factory.createCar("奔驰")
c2 = factory.createCar("宝马")
print(c1)
print(c2)

执行结果：

<__main__.Benz object at 0x021C5770>
<__main__.BMW object at 0x021C5790>

单例模式实现

单例模式（Singleton Pattern）的核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。
单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较多的资源，如读取配置文件、产生其他依赖对象时，可以产生一个“单例对象”，然后永久驻留内存中，从而极大的降低开销。
单例模式有多种实现的方式，我们这里推荐重写__new__()的方法。

#单例模式
class MySingleton:
    __obj = None
    __init_flag = True

    def __new__(cls, *args, **kwargs):
        if cls.__obj == 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)

执行结果：

<__main__.MySingleton object at 0x000001A434CEFFA0>
<__main__.MySingleton object at 0x000001A434CEFFA0>