python学习笔记_第15天（面向对象进阶）

面向对象三大特征介绍

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

• 封装（隐藏）
  隐藏对象的属性和实现细节，只对外提供必要的方法。Python通过“私有属性、私有方法”的方式，实现“封装”。
  因为Python追求简洁的语法，所以没有严格的语法级别的“访问控制符”。私有属性、私有方法也可以通过【_类名__私有属性(方法)名】来外部调用，封装更多的是依靠程序员自觉实现。
• 继承
  继承可以让子类具有父类的特性，提高了代码的重用性。
  从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。
• 多态
  多态是指同一个方法调用由于对象不同会产生不同的行为。拿生活举例，多种休息方法，不同人选择的休息方法不同。

继承

继承是面向对象程序设计的重要特征，其两大好处–1.明确构建设计体系；2.代码复用的重要手段

如果一个新类继承自一个设计好的类，就直接具备了已有类的特征，就大大降低了工作难度。已有的类，我们称为“父类或者基类”，新的类，我们称为“子类或者派生类”，类.mro()可以展示类的层级结构。

Python 支持多重继承，一个子类可以继承多个直接的父类。继承的语法格式如下：
class 子类类名(父类1[，父类2，…])：
类体

如果在类定义中没有指定父类，则默认父类是object 类。即在Python中object 是所有类的父类，里面定义了所有类共有的默认方法，如：new()等。
定义子类时，必须在其构造函数中调用父类的构造函数。调用格式如下：
父类名.init(self, 参数列表)

class Person:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # 对于私有的方法与属性，子类也继承了，但不能直接用

    def say_age(self):
        print( "{0}的年龄是：{1}".format(self.name, self.__age))


class Student(Person):  # 子类继承父类除构造器外的所有，构造器需要在自身构造器中调用父类的
    def __init__(self, name, age, score):
        self.score = score
        Person.__init__(self, name, age)  # 子类不会自动调用父类构造函数，需要在子类构造函数中[类.父类构造函数]调用。


s1 = Student("张三", 15, 85)
s1.say_age()  # 继承了父类的方法
print(Student.mro())  # 展示类的层级结构,Object为Python中所有类的父集
print(dir(s1))  # 子类继承父类的私有属性(方法)，调用时也要用[_父类__私有属性(方法)]
print(s1._Person__age)

运行结果：
张三的年龄是：15
[<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’]
15

方法的重写

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):
        self.score = score
        Person.__init__(self, name, age)  # 构造函数中包含调用父类构造函数

    def say_score(self):
        print(self.name, "的分数是：", self.score)

    def say_name(self):  # 重写继承的父类的方法，不影响父类本身

        print("报告老师，我是", self.name)


s1 = Student("张三", 15, 85)
p1 = Person("张三", 15)
s1.say_score()
s1.say_name()
s1.say_age()
p1.say_name()

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

object 根类

通过类的方法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 类的属性和方法。

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))  # 展示Object类的属性与方法
s2 = Person("张三", 18)
print(dir(s2))  # 展示字类Person的属性与方法

运行结果：
[’__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__、 __weakref__、 age、 name、 say_age
2. object 的所有属性，Person 类作为object 的子类，继承了所有的属性。
3. 我们打印age、name、say_age，发现say_age 虽然是方法，实际上也是属性。只不过，这个属性的类型是“method”而已。
   age – <class ‘int’>
   name – <class ‘str’>
   say_age – <class ‘method’>

多重继承

Python 支持多重继承，一个子类可以有多个“直接父类”。多重结构允许子类具备了“多个父类”的特点，对单个类来说提供了便利，但这样会将“类的整体层次”搞的异常复杂，尽量避免使用。

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()
c.cc()
c.bb()
c.aa()
print(C.mro())  # 打印类的层次结构
c.say()  # 解释器寻找方法是“从左到右”的方式寻找，此时会执行B类中的say()

运行结果：
cc
bb
aa
[<class ‘__main__.C’>, <class ‘__main__.B’>, <class ‘__main__.A’>, <class ‘object’>]
say BBB!

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 0x000001F6F9517608>
say AAA
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):
    if isinstance(a, Animal):
        a.shout()  # 传入的对象不同，shout 方法对应的实际行为也不同。


animalShout(Dog())
animalShout(Cat())

执行结果：
小狗，汪汪汪
小猫，喵喵喵