一、面向对象三大特征介绍
Python是面向对象的语言,也支持面向对象编程的三大特性:继承、封装(隐藏)、多态。
- 封装(隐藏)
隐藏对象的属性和实现细节,只对外提供必要的方法。相当于将“细节封装起来”,只对外暴露“相关调用方法”。 - 继承
继承可以让子类具有父类的特性,提高了代码的重用性。从设计上是一种增量进化,原有父类设计不变的情况下,可以增加新的功能,或者改进已有的算法。 - 多态
多态是指同一个方法调用由于对象不同会产生不同的行为。
二、继承
1.已有的类,我们称为“父类或者基类”,新的类,我们称为“子类或者派生类”。
2.Python支持多重继承,一个子类可以继承多个父类。继承的语法格式如下:
class 子类类名(父类1,父类2,...):
类体
3.如果在类定义中没有指定父类,则默认父类是object类。也就是说,object是所有类的父类,里面定义了一些所有类共有的默认实现,比如:new()。
4.定义子类时,必须在其构造函数中调用父类的构造函数。调用格式如下:
父类名.__init__(self, 参数列表)
代码示例:
class Person:
def __init__(self,name,age):
self.name = name
self.__age = age
def say_age(self):
print('年龄,年龄,我也不知道')
class Student(Person):
def __init__(self,name,age,score):
# 子类必须显示的调用父类初始化方法,不然解释器不会去调用
Person.__init__(self,name,age)
self.score = score
print(Student.mro()) # 获得“类的层次结构”
s = Student('张三',18,60)
s.say_age()
print(s.name)
# print(s.age) # 子类不能直接访问父类私有的方法和属性
print(dir(s)) # 列出s所有的方法
print(s._Person__age) # 子类访问父类的私有属性
输出:
[<class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>]
年龄,年龄,我也不知道
张三
['_Person__age', '__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__', 'name', 'say_age', 'score']
18
三、类成员的继承和重写
- 成员继承:子类继承了父类除构造方法之外的所有成员。(包括私有方法私有属性)
- 方法重写:子类可以重新定义父类中的方法,这样就会覆盖父类的方法,也称为“重写”。
代码示例:
# 测试方法的重写
class Person:
def __init__(self,name,age):
self.name = name
self.__age = age
def say_age(self):
print('我的年龄:',self.__age)
def say_name(self):
print('我的名字是:{0}'.format(self.name))
class Student(Person):
def __init__(self,name,age,score):
# 子类必须显示的调用父类初始化方法,不然解释器不会去调用
Person.__init__(self,name,age)
self.score = score
# 重写父类方法
def say_name(self):
print('报告老师,我的名字是:{0}'.format(self.name))
s = Student('张三',18,60)
s.say_age()
s.say_name()
输出:
我的年龄: 18
报告老师,我的名字是:张三
四、查看类的继承层次结构
- 通过类的方法mro()或者类的属性__mro__可以输出这个类的继承层次结构。
代码示例:
class A: pass
class B(A): pass
class C(B): pass
print(C.mro())
输出:
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
五、object根类
- object类是所有类的父类,因此所有的类都有object类的属性和方法。
- dir()查看对象所有属性
代码示例:
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def say_age(self):
print(self.name, "的年龄是:", self.age)
obj = object()
print(dir(obj))
s2 = Person("张三", 18)
print(dir(s2))
输出:
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
['__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__', 'age', 'name', 'say_age']
上面代码示例说明:Person包含了object类的所有属性。
六、重写__str__()方法
- object有一个__str__()方法,用于返回一个对于“对象的描述”,对应于内置函数str()经常用于print()方法,帮助我们查看对象的信息。str()可以重写。
代码示例1:
# 重写__str__()方法
class Person:
def __init__(self,name):
self.name = name
p = Person('张三')
print(p)
输出:
<__main__.Person object at 0x0000027AA9FAE280>
代码示例2:
# 重写__str__()方法
class Person:
def __init__(self,name):
self.name = name
def __str__(self):
return '名字是:{0}'.format(self.name)
p = Person('张三')
print(p)
输出:
名字是:张三
七、多重继承
- Python支持多重继承,一个子类可以有多个“直接父类”。这样,就具备了“多个父类”的特点。但是由于,这样会被“类的整体层次”搞的异常复杂,尽量避免使用。
代码示例:
class A:
def aa(self):
print('aa')
class B:
def bb(self):
print('bb')
class C(B,A):
def cc(self):
print('cc')
c = C()
c.cc()
c.bb()
c.aa()
输出:
cc
bb
aa
八、MRO()
- Python支持多继承,如果父类中有相同名字的方法,在子类没有指定父类名时,解释器将“从左向右”按顺序搜索。
- MRO(Method Resolution Order):方法解析顺序。 我们可以通过mro()方法获得“类的层次结构”,方法解析顺序也是按照这个“类的层次结构”寻找的。
代码示例:
class A:
def aa(self):
print('aa')
def say(self):
print('say AAA!')
class B:
def bb(self):
print('bb')
def say(self):
print('say BBB!')
class C(A,B):
def cc(self):
print('cc')
c = C()
print(C.mro())
c.say()
输出:
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
say AAA!
九、super()获得父类定义
- 要获得父类的方法时,我们可以通过super()来做。
- super()代表父类的定义,不是父类对象。
代码示例:
class A:
def say(self):
print('A:',self)
print('say AAA')
class B(A):
def say(self):
A.say(self) # 调用父类的say方法
super().say() # 通过super()调用父类的方法
print('say BBB')
b = B()
b.say()
输出:
A: <__main__.B object at 0x0000028CC2582FA0>
say AAA
A: <__main__.B object at 0x0000028CC2582FA0>
say AAA
say BBB
十、多态
- 多态(polymorphism)是指同一个方法调用由于对象不同可能会产生不同的行为。
- 关于多态要注意以下2点:
- 多态是方法的多态,属性没有多态。
- 多态的存在有2个必要条件:继承、方法重写。
代码示例:
class Man:
def eat(self):
print('饿了,吃饭啦!')
class Chinese(Man):
def eat(self):
print('中国人用筷子吃饭')
class English(Man):
def eat(self):
print('英国人用叉子吃饭')
class Indian(Man):
def eat(self):
print('印度人用右手吃饭')
def manEat(m):
if isinstance(m,Man):
m.eat() # 多态,一个方法调用,根据传进来的对象不同调用不同的方法!
else:
print('不能吃饭')
manEat(Chinese())
manEat(English())
manEat(Indian())
manEat(1)
输出:
中国人用筷子吃饭
英国人用叉子吃饭
印度人用右手吃饭
不能吃饭
十一、特殊方法和运算符重载
- Python的运算符实际上是通过调用对象的特殊方法实现的。比如:
a = 20
b = 30
c = a+b
d = a.__add__(b) # 本质
print("c=",c)
print("d=",d)
输出:
c= 50
d= 50
- 每个运算符实际上都对应了相应的方法,统计如下:
- 常见的特殊方法统计如下:
代码示例:
# 运算符的重载
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 # 相当于 p1.add(p2),调用了__add__(self, other)
print(x)
print(p1*5) # 调用了 __mul__(self, other)
输出:
张三--李四
张三张三张三张三张三
十二、特殊属性
- Python对象中包含了很多双下划线开始和结束的属性,这些是特殊属性,有特殊用法。这里我们列出常见的特殊属性:
代码示例:
# 测试特殊属性
class A:
pass
class B:
pass
class C(A,B):
def __init__(self,name):
self.name = name
def cc(self):
print('cc')
c = C('张三')
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', 'name']
{'name': '张三'}
<class '__main__.C'>
(<class '__main__.A'>, <class '__main__.B'>)
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
[<class '__main__.C'>]
十三、对象的浅拷贝和深拷贝
- 变量的赋值操作
只是形成两个变量,实际还是指向同一个对象。 - 浅拷贝
Python拷贝一般都是浅拷贝。拷贝时,对象包含的子对象内容不拷贝。因此,源对象和拷贝对象会引用同一个子对象。 - 深拷贝
使用copy模块的deepcopy函数,递归拷贝对象中包含的子对象。源对象和拷贝对象所有的子对象也不同。
代码示例:
import copy
class MobilePhone:
def __init__(self,cpu,screen):
self.cpu = cpu
self.screen = screen
class CPU:
def caculate(self):
print('算你个12345')
print('cpu对象:',self)
class Screen:
def show(self):
print('显示画面')
print('screen对象:', self)
# 测试变量赋值
print('测试变量赋值')
c1 = CPU()
c2 = c1 # 变量赋值,实际还是指向同一个对象
print(c1)
print(c2)
# 测试浅复制
print('测试浅复制...')
s1 = Screen()
m1 = MobilePhone(c1,s1)
m2 = copy.copy(m1) # 浅复制
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 0x00000196CC636FD0>
<__main__.CPU object at 0x00000196CC636FD0>
测试浅复制...
<__main__.MobilePhone object at 0x00000196CC636F70> <__main__.CPU object at 0x00000196CC636FD0> <__main__.Screen object at 0x00000196CC636FA0>
<__main__.MobilePhone object at 0x00000196CC636C70> <__main__.CPU object at 0x00000196CC636FD0> <__main__.Screen object at 0x00000196CC636FA0>
测试深复制...
<__main__.MobilePhone object at 0x00000196CC636F70> <__main__.CPU object at 0x00000196CC636FD0> <__main__.Screen object at 0x00000196CC636FA0>
<__main__.MobilePhone object at 0x00000196CC636610> <__main__.CPU object at 0x00000196CC64EF40> <__main__.Screen object at 0x00000196CC64EF70>
十四、组合
- “is-a”关系,我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a”关系指的是类似这样的关系:狗是动物,dog is animal。狗类就应该继承动物类。
- “has-a”关系,我们可以使用“组合”,也能实现一个类拥有另一个类的方法和属性。”has-a”关系指的是这样的关系:手机拥有CPU。 MobilePhone has a CPU。
- 都可以起到代码复用的作用
代码示例1:
# 测试组合
# 继承实现代码复用
print('继承...')
class A1:
def say_a1(self):
print('a1 a1 a1')
class B1(A1): # 继承
pass
b1 = B1()
b1.say_a1()
# 组合实现代码复用
print('组合...')
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
代码示例2:
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('screen对象:', self)
m = MobilePhone(CPU(),Screen())
m.cpu.calculate()
m.screen.show()
输出:
算你个12345
cpu对象: <__main__.CPU object at 0x0000022EF7212FD0>
显示画面
screen对象: <__main__.Screen object at 0x0000022EF7212FA0>
十五、设计模式_工厂模式实现
- 工厂模式实现了创建者和调用者的分离,使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。
代码示例:
# 测试工厂模式
# 定义工厂类
class CarFactory:
def create_car(self,bread):
if bread == '奔驰':
return Benz()
elif bread == '宝马':
return BMV()
elif bread == '比亚迪':
return BYD()
else:
print('未知品牌,无法创建!')
class Benz:
pass
class BMV:
pass
class BYD:
pass
factory = CarFactory()
c1 = factory.create_car('奔驰')
c2 = factory.create_car('比亚迪')
print(c1)
print(c2)
输出:
<__main__.Benz object at 0x000001F1A8A22FA0>
<__main__.BYD object at 0x000001F1A8A22F70>
十六、设计模式_单例模式实现(这个需要多练习)
- 单例模式(Singleton Pattern)的核心作用是确保一个类只有一个实例,并且提供一个访问该实例的全局访问点。
- 单例模式只生成一个实例对象,减少了对系统资源的开销。当一个对象的产生需要比较多的资源,如读取配置文件、产生其他依赖对象时,可以产生一个“单例对象”,然后永久驻留内存中,从而极大的降低开销。
- 单例模式有多种实现的方式,这里推荐重写__new__()的方法。
代码示例1:
# 测试单例模式
# 通常需要重写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 == True: # 确保单例对象只初始化一次
print('init...')
self.name = name
MySingleton.__init_flag = False
a = MySingleton('aa')
b = MySingleton('bb')
print(a)
print(b)
c = MySingleton('cc')
print(c)
输出:
init...
<__main__.MySingleton object at 0x000001CC180A6FA0>
<__main__.MySingleton object at 0x000001CC180A6FA0>
<__main__.MySingleton object at 0x000001CC180A6FA0>
代码示例2:
# 测试工厂模式和单例模式的复合使用
class CarFactory:
__obj = None
__init_flag = True
def create_car(self,bread):
if bread == '奔驰':
return Benz()
elif bread == '宝马':
return BMV()
elif bread == '比亚迪':
return BYD()
else:
print('未知品牌,无法创建!')
def __new__(cls, *args, **kwargs):
if cls.__obj == None: # 完成创建单例对象
cls.__obj = object.__new__(cls)
return cls.__obj
def __init__(self):
if CarFactory.__init_flag == True: # 确保单例对象只初始化一次
print('init CarFactory...')
CarFactory.__init_flag = False
class Benz:
pass
class BMV:
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 0x00000222D23667F0>
<__main__.BYD object at 0x00000222D23667C0>
<__main__.CarFactory object at 0x00000222D2366880>
<__main__.CarFactory object at 0x00000222D2366880>