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（对象,类型） 判断“对象”是不是“指定类型”