Python基础知识总结3-面向对象进阶知识

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 = name
        self.age = age

    def 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 = age
        self.score = score

# 调用
s1 = Student("张三",15,85)
#s1.say_age()
print(dir(s1))

类成员的继承和重写

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

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def 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 = score

    def 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 = 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’]

从上面我们可以发现这样几个要点：
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 = 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)

特殊属性

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

#测试特殊属性
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(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 = 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的方法”

_ 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
    @property
    def 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 = name
        self.__salary = salary

    @property               #相当于salary属性的getter方法
    def salary(self):
        print("月薪为{0},年薪为{1}".format(self.__salary,*self.__salary)))
        return self.__salary;

    @salary.setter
    def salary(self,salary):    #相当于salary属性的setter方法
        if(0<salary<1000000):
            self.__salary = salary
        else:
            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不存在严格意义的私有成员）