Python对象的深浅拷贝+设计模式 (6)

Python对象的深浅拷贝+设计模式

对象的浅拷贝和深拷贝

·变量的赋值操作只是形成两个变量，实际还是指向同一个对象。

·浅拷贝

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)

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

对象

运算结果：

计算，算个 12345

CPU 对象: <__main__.CPU object at 0x00685690>

<__main__.MobilePhone object at 0x00685B50> <__main__.MobilePhone object at 0x00685B50>

<__main__.MobilePhone object at 0x00685B50> <__main__.MobilePhone object at

0x0069B490>

计算，算个 12345

CPU 对象: <__main__.CPU object at 0x00685690> 计算，算个 12345

CPU 对象: <__main__.CPU object at 0x00685690> 计算，算个 12345

CPU 对象: <__main__.CPU object at 0x006A5DB0>

组合

"is-a"关系，我们可以使用"继承"。从而实现子类拥有的父类的方法和属性。"is-a" 关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。

"has-a"关系，我们可以使用"组合"，也能实现一个类拥有另一个类的方法和属性。" has-a"关系指的是这样的关系：手机拥有 CPU。 MobilePhone has a CPU。

#组合测试

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

class CPU:

def calculate(self):

print("计算，算个 12345")

class Screen:

def show(self):

print("显示一个好看的画面，亮瞎你的钛合金大眼")

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

m.cpu.calculate()    #通过组合，我们也能调用cpu对象的方法。相

当于手机对象间接拥有了"cpu的方法"

m.screen.show()

运算结果：

计算，算个 12345

显示一个好看的画面，亮瞎你的钛合金大眼

设计模式_工厂模式实现

设计模式是面向对象语言特有的内容，是我们在面临某一类问题时候固定的做法，设计模式有很多种，比较流行的是：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

1. = MySingleton("aa")

   print(a)

2. = MySingleton("bb") print(b)

运算结果：

init....

<__main__.MySingleton object at 0x01E15610>

<__main__.MySingleton object at 0x01E15610>

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

#测试工厂模式和单例模式的整合使用 class CarFactory:

    __obj = None    #类属性

__init_flag = True

def create_car(self,brand): if brand =="奔驰": return Benz()

elif brand =="宝马": return BMW()

elif brand == "比亚迪":

return BYD()

else:

return "未知品牌，无法创建"

def __new__(cls, *args, **kwargs):

if cls.__obj ==None: cls.__obj = object.__new__(cls) return cls.__obj

def __init__(self):

if CarFactory.__init_flag:

print("init CarFactory....")

CarFactory.__init_flag = False

class Benz: pass

class BMW: pass

class BYD:

pass

factory = CarFactory() c1 = factory.create_car("奔驰")

c2 = factory.create_car("比亚迪") print(c1) print(c2)

factory2 = CarFactory()

print(factory) print(factory2)

运算结果： init CarFactory....

<__main__.Benz object at 0x01E36E90> <__main__.BYD object at 0x01E36C30>

<__main__.CarFactory object at 0x01E36730>

<__main__.CarFactory object at 0x01E36730>