Python基础知识（十）

1. 特殊方法和运算符重载

Python 的运算符实际上是通过调用对象的特殊方法实现的。

a = 20
b = 30
c = a+b
d = a.__add__(b)
print("c=",c)
print("d=",d)

运行结果：

c= 50
d= 50

常见的特殊方法统计如下：

方法	说明	例子
__ init__	构造方法	对象创建：p = Person()
__ del__	析构方法	对象回收
__ repr__,__ str__	打印，转换	print(a)
__ call__	函数调用	a()
__ getattr__	点号运算	a.xxx
__ setattr__	属性赋值	a.xxx = value
__ getitem__	索引运算	a[key]
__ setitem__	索引赋值	a[key]=value
__ len__	长度	len(a)

每个运算符实际上都对应了相应的方法，统计如下：

运算符	特殊方法	说明
运算符+	__ add__	加法
运算符-	__ sub__	减法
<,<=,==	__ lt__,__ le__，__ eq__	比较运算符
>,>=,!=	__ gt__,__ ge__,__ ne__	比较运算符
,^,&	__ or__,__ xor__,__ and__	或、异或、与
<<,>>	__ lshift__,__ rshift__	左移、右移
*,/,%,//	__ mul__,__ truediv__,__ mod__,__ floordiv__	乘、浮点除、模运算、（取余）、整数除
**	__ pow__	指数运算

我们可以重写上面的特殊方法，即实现了“运算符的重载”。

#测试运算符的重载
class Person:
def __init__(self,name):
self.name = name
def __add__(self, other):
if isinstance(other,Person):
return "{0}--{1}".format(self.name,other.name)
else:
return "不是同类对象，不能相加"
def __mul__(self, other):
if isinstance(other,int):
return self.name*other
else:
return "不是同类对象，不能相乘"
p1 = Person("高淇")
p2 = Person("高希希")
x = p1 + p2
print(x)
print(p1*3)

运行结果：

高淇--高希希
高淇高淇高淇

2. 特殊属性

Python 对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法。这里我们列出常见的特殊属性：

特殊方法	含义
obj.__ dict__	对象的属性字典
obj.__ class__	对象所属的类
class.__ bases__	类的基类元组（多继承）
class.__ base__	类的基类
class.__ mro__	类层次结构
class.__ subclasses__()	子类列表

#测试特殊属性
class A:
	pass
class B:
	pass
class C(B,A):
	def __init__(self,nn):
		self.nn = nn
	def cc(self):
		print("cc")
c = C(3)
print(dir(c))
print(c.__dict__)
print(c.__class__)
print(C.__bases__)
print(C.mro())
print(A.__subclasses__())

运行结果：

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'cc', 'nn']
{'nn': 3}
<class '__main__.C'>
(<class '__main__.B'>, <class '__main__.A'>)
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
[<class '__main__.C'>]

3. 对象的浅拷贝和深拷贝

• 变量的赋值操作
  只是形成两个变量，实际还是指向同一个对象。
• 浅拷贝
  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>

4. 组合

• “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
显示一个好看的画面，亮瞎你的钛合金大眼

5. 设计模式_工厂模式实现

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

6. 设计模式_单例模式实现

单例模式（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)

运行结果：

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