Python是面向对象的语言，支持面向对象编程的三大特性：继承、
封装（隐藏）、多态。

封装（隐藏）

隐藏对象的属性和实现细节，只对外提供必要的方法。相当于 将“细节封装起来”，只对外暴露“相关调用方法”。
通过前面学习的“私有属性、私有方法”的方式，实现“封装”。 Python追求简洁的语法，没有严格的语法级别的“访问控制
符”，更多的是依靠程序员自觉实现。

继承

继承可以让子类具有父类的特性，提高了代码的重用性。 从设计上是一种增量进化，原有父类设计不变的情况下，可以 增加新的功能，或者改进已有的算法。

多态

多态是指同一个方法调用由于对象不同会产生不同的行为。生 活中这样的例子比比皆是：同样是休息方法，人不同休息方法
不同。张三休息是睡觉，李四休息是玩游戏，程序员休息是“敲 几行代码”。

继承

子类扩展父类

继承是面向对象编程的三大特征之一。继承让我们更加容易实现类
的扩展。实现代码的重用，不用再重新发明轮子(don’t reinvent
wheels)。
如果一个新类继承自一个设计好的类，就直接具备了已有类的特
征，就大大降低了工作难度。已有的类，我们称为“父类或者基
类”，新的类，我们称为“子类或者派生类”。

语法格式

Python支持多重继承，一个子类可以继承多个父类。继承的语法格
式如下：

class  子类类名(父类1[，父类2，...])：类体

如果在类定义中没有指定父类，则默认父类是 object类 。也就是 说， object 是所有类的父类，里面定义了一些所有类共有的默认
实现，比如： new()

关于构造函数：

1 子类不重写 init ，实例化子类时，会自动调用父类定义的 init 。
2 子类重写了 init 时，实例化子类，就不会调用父类已经定义的 init
3 如果重写了 init 时，要使用父类的构造方法，可以使用 super 关键字，也可以使用如下格式调用：
父类名.init(self, 参数列表)

class Person:def __init__(self,name,age):print("Person的构造方法")self.name = nameself.age = agedef say_age(self):print(self.name,"的年龄是：",self.age)class Student(Person):def __init__(self,name,age,score):# 子类并不会自动调用父类的__init__()，我们必须显式的调用它。# Person.__init__(self, name, age)#super(Student,self).__init__(name,age)print("Student的构造方法")# self.name = name# self.age = ageself.score = score# 调用
s1 = Student("张三",15,85)
#s1.say_age()
print(dir(s1))

类成员的继承和重写

1 成员继承：子类继承了父类除构造方法之外的所有成员。
⚠️(私有属性、私有方法也被继承)
2 方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类
的方法，也称为“重写”

class Person:def __init__(self,name,age):self.name = nameself.age = agedef say_age(self):print(self.name,"的年龄是：",self.age)def say_name(self):print("我是",self.name)class Student(Person):def __init__(self,name,age,score):Person.__init__(self,name,age)  self.score = scoredef say_score(self):print(self.name,"的分数是：",self.score)def say_name(self):      #重写父类的方法print("报告老师，我是",self.name)s1 = Student("张三",15,85)s1.say_score()s1.say_name()s1.say_age()

张三 的分数是： 85
报告老师，我是 张三
张三 的年龄是： 15

查看类的继承层次结构

通过类的方法 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 = nameself.age = agedef 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’]

从上面我们可以发现这样几个要点：
1 Person 对象增加了六个属性：
__dict_ _\ __module__ __eakref__ age name say_age
2 object 的所有属性， Person 类作为 object 的子类，显然包含了所有的
属性
3 我们打印 age 、 name 、 say_age ，发现 say_age 虽然是方法，实际上也
是属性。只不过，这个属性的类型是 method 而已。

重写 str() 方法

object 有一个 _ _str_\ _() 方法，用于返回一个对于“对象的描述”。内置函数 str(对象) ,调用的就是
_ _str_\ _()

_ _str_\ _() 经常用于 print() 方法，帮助我们查看对象的信息。_ _str_\ _() 可以重写

多重继承

Python支持多重继承，一个子类可以有多个“直接父类”。这样，就
具备了“多个父类”的特点。但是由于，这样会被“类的整体层次”搞的
异常复杂，尽量避免使用。

1 class A:
2    def aa(self):
3        print("aa")
4
5 class B:
6    def bb(self):
7        print("bb")
8
9 class C(B,A):
10    def cc(self):
11        print("cc")
12
13 c = C()
14 c.cc()
15 c.bb()
16 c.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(B,A):def cc(self):print("cc")c = C()
print(C.mro())          #打印类的层次结构
c.say()      #解释器寻找方法是“从左到右”的方式寻找，此时会执行B类中的say()

执行结果：

[<class ‘main.C’>, <class ‘main.B’>, <class ‘main.A’>, <class
‘object’>] say BBB!

super()获得父类定义

在子类中，如果想要获得父类的方法时，我们可以通过 super() 来做。
super() 代表父类的定义，不是父类对象。

❤️想调用父类的构造方法：
super(子类名称,self).init(参数列表)

class A:def __init__(self):print("A的构造方法")def say(self):print("A: ",self)print("say AAA")class B(A):def __init__(self):super(B,self).__init__() #调用父类的构造方法# super().__init__(self) print("B的构造方法")def say(self):#A.say(self)   调用父类的say方法super().say()   #通过super()调用父类的方法print("say BBB")b = B()b.say()

1 A: <main.B object at 0x007A5690>
2 say AAA
3 say BBB

多态

多态（polymorphism）是指同一个方法调用由于对象不同可能会
产生不同的行为。

关于多态要注意以下2点：
1 多态是方法的多态，属性没有多态。
2 多态的存在有2个必要条件：继承、方法重写

#多态
class Animal:def shout(self):print("动物叫了一声")class Dog(Animal):def shout(self):print("小狗，汪汪汪")class Cat(Animal):def shout(self):print("小猫，喵喵喵")def animalShout(a):a.shout()   #传入的对象不同，shout方法对应的实际行为也不同。animalShout(Dog())animalShout(Cat())

特殊方法和运算符重载

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 = namedef __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*otherelse:return "不是同类对象，不能相乘"
p1 = Person("高淇")
p2 = Person("高希希")
x = p1 + p2
print(x)
print(p1*3)

特殊属性

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

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

1 [‘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’]
2 {‘nn’: 3}
3 <class’main.C’>
4 (<class ‘main.B’>, <class ‘main.A’>)
5 [<class’main.C’>, <class ‘main.B’>, <class ‘main.A’>, <class
‘object’>]
6 [<class ‘main.C’>]

对象的浅拷贝和深拷贝

• 浅拷贝

Python拷贝一般都是浅拷贝。
浅拷贝：拷贝时，拷贝源对象，但对象包含的子对象内容不拷
贝。

• 深拷贝

使用 copy 模块的 deepcopy 函数，递归拷贝对象中包含的子对象。
深拷贝：拷贝时，拷贝源对象，也递归拷贝对象中包含的子对象。

#测试对象的引用赋值、浅拷贝、深拷贝
import copy
class MobilePhone:def __init__(self,cpu):self.cpu = cpu
class CPU:pass
c = CPU()
m = MobilePhone(c)print("----浅拷贝-------")
m2 = copy.copy(m)   #m2是新拷贝的另一个手机对象
print("m：",id(m))
print("m2：",id(m2))
print("m的cpu：",id(m.cpu))
print("m2的cpu：",id(m2.cpu))   #m2和m拥有了一样的cpu对象
print("----深拷贝--------")
m3 = copy.deepcopy(m)
print("m：",id(m))
print("m3：",id(m3))
print("m的cpu：",id(m.cpu))
print("m3的cpu：",id(m3.cpu))   #m3和m拥有不一样的cpu对象

----浅拷贝-------
m： 1879267229360
m2： 1879267228592
m的cpu： 1879267229648
m2的cpu： 1879267229648
----深拷贝--------
m： 1879267229360
m3： 1879267222256
m的cpu： 1879267229648
m3的cpu： 1879267221968

组合

两人组合后，可以复用对方的属性和方法！

#组合测试
class MobilePhone:def __init__(self,cpu,screen):self.cpu = cpuself.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的方法”

_ init _ 构造方法和 _ new _ 方法

初始化对象，我们需要定 义构造函数 init() 方法。构造方法用于执
行“实例对象的初始化工作”，即对象创建后，初始化当前对象的相
关属性，无返回值。

__init__ 的要点如下：
名称固定，必须为： __init__
第一个参数固定，必须为： self 。 self 指的就是刚刚创建好的实
例对象
构造函数通常用来初始化实例对象的实例属性，如下代码就是初
始化实例属性： name 和 score
通过“类名(参数列表)”来调用构造函数。调用后，将创建好的对
象返回给相应的变量。 比如： s1 = Student(‘张三’, 80)

__init__ 方法：初始化创建好的对象，初始化指的是：“给实例属
性赋值”

__new__ 方法: 用于创建对象，但我们一般无需重定义该方法
如果我们不定义 init 方法，系统会提供一个默认的 init 方法。
如果我们定义了带参的 init 方法，系统不创建默认的 init 方法

实例属性和实例方法

实例属性

实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用
有如下几个要点：

1 实例属性一般在 init() 方法中通过如下代码定义： self.实例属性名 = 初始值

2 在本类的其他实例方法中，也是通过 self 进行访问： self.实例属性名

3 创建实例对象后，通过实例对象访问： obj01 = 类名() #创建和初始化对象，调用 init() 初始化属性
obj01.实例属性名 = 值 #可以给已有属性赋值，也可以新加属性

class Student:def __init__(self,name,score):self.name = name #增加name属性self.score = score #增加score属性def say_score(self):self.age = 18     #增加age属性print("{0}的分数是{1}".format(self.name,self.score))s1 = Student("张三",80)
s1.say_score()
print(s1.age)
s1.salary = 3000 #s1对象增加salary属性
s2 = Student("李四",90)
s2.say_score()
print(s2.age)

实例方法

实例方法是从属于实例对象的方法。实例方法的定义格式如下：

def  方法名(self [, 形参列表])：函数体

方法的调用格式如下：
对象.方法名([实参列表])

要点：
1 定义实例方法时，第一个参数必须为 self 。和前面一样， self 指当前的实例对象。
2 调用实例方法时，不需要也不能给self 传参。 self 由解释器自动传参

函数和方法的区别

1 都是用来完成一个功能的语句块，本质一样。
2 方法调用时，通过对象来调用。方法从属于特定实例对象，普通函数没有这个特点
3 直观上看，方法定义时需要传递self，函数不需要

实例对象的方法调用本质

其他操作

dir(obj) 可以获得对象的所有属性、方法
obj._ _dict_ _ 对象的属性字典
pass 空语句
isinstance（对象,类型） 判断“对象”是不是“指定类型”

类对象、类属性、类方法、静态方法

类对象

我们在前面讲的类定义格式中， class 类名： 。实际上，当解释器执行
class 语句时，就会创建一个类对象。

类属性

类属性是从属于“类对象”的属性，也称为“类变量”。由于，类属性从
属于类对象，可以被所有实例对象共享。
类属性的定义方式：

class  类名：类变量名= 初始值

__del__方法 (析构函数)和垃圾回收机制

_ del _() 称为“析构方法”，用于实现对象被销毁时所需的操作。比如：
释放对象占用的资源，例如：打开的文件资源、网络连接等。
Python实现自动的垃圾回收，当对象没有被引用时（引用计数为
0），由垃圾回收器调用 _ del _() 。
我们也可以通过 del语句 删除对象，从而保证调用 _ del _() 。
系统会自动提供 _ del _方法 ，一般不需要自定义析构方法。

1 #析构函数
2 class Person:
3
4    def __del__(self):
5        print("销毁对象：{0}".format(self))
6
7 p1 = Person()
8 p2 = Person()
9 del p2
10 print("程序结束")

call 方法和可调用对象

1 Python 中，凡是可以将 () 直接应用到自身并执行，都称为可调
用对象。
2 可调用对象包括自定义的函数、Python 内置函数、以及本节所
讲的实例对象。
3 定义了 call() 的对象，称为“可调用对象”，即该对象可以像函数
一样被调用。
4 该方法使得实例对象可以像调用普通函数那样，以“对象名()”的
形式使用。

1 def f1():
2    print("f1")
3
4 f1()   #本质也是调用了__call__()方法
5
6 class Car:
7    def __call__(self, age,money):
8        print("__call__方法")
9        print("车龄：{0},金额：{1}".format(age,money))
10
11 f2 = Car()
12 f2(3,200000)    #像调用函数那样调用，本质也是调用了__call__()

f1
车龄：3,金额：200000

方法没有重载

如果我们在类体中定义了多个重名的方法，只有最后一个方法有效。
建议：不要使用重名的方法！Python中方法没有重载。

在其他一些语言(比如：Java)中，可以定义多个重名的方法，只要保证方法签名唯一即可。方
法签名包含3个部分：方法名、参数数量、参数类型。
Python中，方法的的参数没有声明类型（调用时确定参数的类型），参数的数量也可以由可
变参数控制。因此，Python中是没有方法的重载的。

方法的动态性

Python是动态语言，我们可以动态的为类添加新的方法，或者动态
的修改类的已有的方法

#测试方法的动态性
#测试方法的动态性
class Person:def work(self):print("努力上班！")
def play_game(self):print("玩游戏")
def work2(s):print("好好工作，努力上班！")
Person.play = play_game
Person.work = work2
p = Person()
p.play()
p.work()

我们可以看到， Person 动态的新增了 play_game 方法，以及用 work2 替换
了 work 方法

私有属性和私有方法(实现封装)

Python对于类的成员没有严格的访问控制限制，这与其他面向对象
语言有区别。关于私有属性和私有方法，有如下要点：
1 通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
2 类内部可以访问私有属性(方法)
3 类外部不能直接访问私有属性(方法)
4 类外部可以通过 _类名__私有属性(方法)名 ”访问私有属性(方法)

@property 装饰器

@property 可以将一个方法的调用方式变成“属性调用”。
@property 主要用于帮助我们处理属性的读操作、写操作。对于某一个
属性，我们可以直接通过：
emp1.salary = 30000
如上的操作读操作、写操作。但是，这种做法不安全。比如，我需
要限制薪水必须为 1-10000 的数字。这时候，我们就需要通过使用装
饰器 @property 来处理。

@property
def 方法名(self)代码块

class Rect:def __init__(self,area):self.__area = area@propertydef area(self):return self.__area
rect = Rect(30)
#直接通过方法名来访问 area 方法
print("矩形的面积是：",rect.area)

而要想实现修改 area 属性的值，还需要为 area 属性添加 setter 方法，就需要用到 setter 装饰器，它的语法格式如下：

@方法名.setter
def 方法名(self, value):代码块

#测试@property
class Employee:def __init__(self,name,salary):self.name = nameself.__salary = salary@property               #相当于salary属性的getter方法def salary(self):print("月薪为{0},年薪为{1}".format(self.__salary,*self.__salary)))return self.__salary;@salary.setterdef salary(self,salary):    #相当于salary属性的setter方法if(0<salary<1000000):self.__salary = salaryelse:print("薪水录入错误！只能在0-1000000之间")emp1 = Employee("高淇",100)print(emp1.salary)emp1.salary = -200

这样，area 属性就有了 getter 和 setter 方法，该属性就变成了具有读写功能的属性。

除此之外，还可以使用 deleter 装饰器来删除指定属性，其语法格式为：

@方法名.deleter
def 方法名(self):代码块

@area.deleter
def area(self):self.__area = 0

del rect.area
print("删除后的area值为：",rect.area)

属性和方法命名总结

_xxx ：保护成员，不能用 from module import * 导入，只有类对象和子类对象能访问这些成员。

_ _xxx_ _ ：系统定义的特殊成员
_ _xxx ： 类中的私有成员，只有类对象自己能访问，子类对象也不能访问。（但，在类外部可以通
过 对象名. _类名__xxx 这种特殊方式访问。Python不存在严格意义的私有成员）