Python面向对向编程(3)

一，封装

根据需求将属性和方法封装到一个抽象的类中
在使用的时候，只要按照自己的需求去调用，不必了解现实的细节

封装有两方面的含义：

1.将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。

2.在类对象的内部通过访问控制把某些属性和方法隐藏起来，不允许在类对象的外部直接访问，而是在类对象的内部对外提供公开的接口方法（例如getter和setter）以访问隐藏的信息。这样，就对隐藏的信息进行了保护。````

 class Student(object):
    def __init__(self):
        self.__score = 90
    def get_score(self):
        return self.__score
    def set_score(self,score):
        if 0 <= score <= 100:
            self.__score = score
        else:
            raise ValueError("成绩必在100内")

s = Student()
s.get_score()
   90

s = Student()
s.set_score(88)
print(s.get_score())
    88

二，继承

class Dog(object):                 class Bird(object):    
    def eat(self):                     def eat(self): 
        print("吃饭“）                      print("吃饭“）
    def drink(self):                   def drink(self):
        print("喝水“）                      print("喝水“）
    def swim(self):                    def swim(self):
        print("游泳”）                      print("游泳”）

单继承:子类只有一个直接父类时称为单继承

假设子类和父类分别为ChildCLass和ParentCLass,子类继承父类的语法格式为:

class ChildClass(ParentClass):
      pass

多继承:子类有多个直接父类时称为多继承

假设子类是ChildCLass,直接父类是Parentclass1, ParentClass2, … ParentClassn
子类继承父类的语法格式为:

class ChildClass(Parentclass1, ParentClass2, … ParentClassn):
    pass

子类会继承所有父类(包括所有直接父类和所有间接父类)的所有属性和方法。

class ParentClassA(object):
    ca=18 
    def im(self): 
        print("im()被调用了") 
class ParentClassB(object): 
    __pca = 23 
    def __pim(self): 
        print("__pim()被调用了")
class ParentClassC (ParentClassA, ParentClassB) : 
    @classmethod def cm(cls): 
        print("cm()被调用了") 
class ParentClassD(object): 
    @staticmethod def sm(): 
        print("sm()被调用了")

子类可以添加父类中没有的属性和方法

class BaseClass(object): 
    ca_base = 5 
    def im_base(self): 
        print("im_base()被调用了")
class SubClass(BaseClass): 
    ca_sub = 8 
    def im_sub(self): 
         print("im_sub()被调用了") 
print(dir(SubClass))

三，重写

如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其进行重写从而提供自定义的实现，重写的方式为:在子类中定义与父类中同名的属性或方法(包括装饰器)。
子类重写父类的属性后，通过子类或其实例对象只能访问子类中重写后的属性，而无法再访问父类中被重写的属性。
子类重写父类的方法后，通过子类或其实例对象只能调用子类中重写后的方法，而无法再调用父类中被重写的方法。

class ParentClass(object):                           class ChildClass(ParentClass):
   ca = "ca(父类)"                                       ca = "ca(子类)"
   def __init__(self):                                   def __init__(self):
        print("__init__()被调用了（父类）")                    print("__init__()被调用了（子类）")
    def im(self):                                        def im(self):
        print("im()被调用了（父类）")                          print("im()被调用了（子类）")
    @classmethod                                         @classmethod 
    def cm(cls):                                         def cm(cls):
        print("cm()被调用了(父类)")                            print("cm()被调用了(子类)")

cc = ChildClass()                        __init__()被调用了（子类）
print(ChildClass.ca                      ca(子类)
print(cc.ca)                             ca(子类)
cc.im()                                  im()被调用了（子类）
ChildClass.cm()                          cm()被调用了(子类)
cc.cm()                                  cm()被调用了(子类)

四，MRO

全称是Method ResoLution Order (方法解析顺序) ，它指的是对于一颗类继承树， 当调用底层类对象所对应实例对象的方法时， Python解释器在类继承树上搜索方法的顺序。
对于一 棵类继承树，可以调用最底层类对象的方法mro()或访问最底层类对象的特殊属性__mro__ ，获得这棵类继承树的MRO.

class A(object): 
    def f(self): 
        print("A.f") 
class B(A): 
     def f(self): 
        print("B.f") 
class C(A): 
     def f(self): 
        print("C.f") 
class D(B,C): 
     def f(self): 
        print("D.f")

对于一颗类继承树，可以调用最底层类对象的方法mro()或访问最底层类对象的特殊属性__mro__,获得这棵树类继承树的MRO
在子类重写后的方法中通过super()调用父类中被重写的方法时，在父类中搜索方法的顺序于以该子类为最底层类对象的类继承树的MRO。

如果想调用指定父类中被重写的方法， 可以给super()传入两个实参: super(a_type, obj), 其中，第一个实参a_type是个类对象，第二个实参obj是个实例对象，这样，被指定的父类是:obj所对应类对象的MRO中，a_type后面那个类对象。

五，多态

除了封装和继承，多态也是面向对象编程的三大特征之一
简单的说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态的决定调用哪个 对象中的方法。

Python是动态语言，在调用函数时不会检查参数的类型

动态语言的多态崇尚"鸭子类型”:当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。

在鸭子类型中，我们并不关心对象是什么类型，到底是不是鸭子，只关心对象的行为。

在上面的程序中，我们并不关心变量parent所引用的对象是什么类型，到底是不是ParentClass或其子类类型，只关心变量parent所引用的对象是否有do_sth()这个方法。

鸭子类型:
如果一只生物走起路来像鸭子，游起泳来像鸭子，叫起来也像鸭子，那么它就可以被当作鸭子。 也就是说，它不关注对象的类型，而是关注对象具有的行为。