面向对象编程2

目录

• 封装
  • 一 引入
  • 二 隐藏属性
  • 三 开放接口
    • 3.1隐藏数据属性
  • 四 property
  • 绑定方法与非绑定方法
• 继承
  • 一 集成的介绍
  • 二 继承与抽象
  • 三 属性查找
  • 四 继承的实现原理
    • 4.1 菱形问题
    • 4.2 继承原理
    • 4.3 深度优先和广度优先
    • 4.4 python Mixins机制
  • 五 派生与方法重用
  • 六 组合
• 多态
  • 一 多态与多态性
  • 二 抽象基类
  • 三 鸭子类型
• 面向对象高级
  • 一 内置方法
  • 二 反射

封装

一 引入

面向对象编程有三大特性：封装、继承、多态，其中最重要的一个特性就是封装。封装指的是把数据与功能都整合到一起。除此之外，针对封装到对象或者类中的属性，我们还可以严格控制对它们的访问，分两步实现：隐藏与开放接口。

二 隐藏属性

Python的Class机制采用双下划线开头的方式将属性隐藏起来，但其实这仅仅只是一种变形操作，类中所有下划线开头的属性都会在定义阶段，检测语法时自动变成"_类名__属性名" 的形式：

class Foo:
    __N = 0 #变形为 _Foo__N
    
    def __init__(self): # 定义函数时，会检测函数语法，所以__开头的属性会变形 
        self.__x=10  # 变形为self._Foo__x
    def __f1(self):  # 变形为_Foo__f1
        print('__f1 run')
    def f2(self):  # 定义函数时，会检测函数语法，所以__开头的属性也会变形
        self.__f1()  # 变形为self.__Foo__f1()
      
print(Foo.__N)  # 报错AttributeError:类Foo没有属性__N

obj = Foo()
print(obj.__x)  # 报错AttributeError:对象obj没有属性__x

这种变形需要注意的问题时：

1、在类外部无法直接访问双下划线开头的属性，但知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如 Foo . _ A _ _ N,所以说这种操作并没有严格意义上地限制外部访问，仅仅只是一种语法意义上的变形。

Foo.__dict__

obj.__dict__    #？  这里为什么调用对象返回的是10？？？？？？
>>>{'_Foo__x': 10}

Foo._Foo__N
>>> 0
obj._Foo__x
>>> 10
obj._Foo__N
>>>0

2、在类内部是可以直接访问双下滑线开头的属性的，比如self.__f1()，因为在类定义阶段类内部双下滑线开头的属性统一发生了变形。

obj.f2()
>>> __f1 run

3、变形操作只在类定义阶段发生一次,在类定义之后的赋值操作，不会变形。

Foo.__M=100
Foo.__dict__

Foo.__M
>>> 100

obj.__y=20
obj.__dict__
>>> {'__y': 20, '_Foo__x': 10}
obj.__y
>>> 20

总结__开头属性的特点：

1、并没有针对属性藏起来，只是变形

2、该变形值在类定义阶段、扫描语法的时候执行，此后__开头的属性都不会变形

三 开放接口

为何要隐藏属性

1、隐藏数据属性为了严格控制类外部访问者对属性的操作

2、隐藏函数属性为了隔离复杂度

定义属性就是为了使用，所以隐藏并不是目的

3.1隐藏数据属性

将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，接口之上可以附加额外的逻辑来对数据的操作进行严格的控制

class People:
    def __init__(self, name, age):  # 将名字和年纪都隐藏起来
        self.__name = name
        self.__age = age

    def tell_info(self):  # 对外提供访问信息的接口
        print('<%s:%s>' % (self.__name, self.__age))

    def set_info(self, name, age):
        if type(name) is not str:
            print('名字必须是字符串')
            return
        if type(age) is not int:
            print('年龄必须是数字')
            return
        self.__name = name
        self.__age = age

obj1 = People('william',18)
obj1.tell_info()
obj1.set_info("矮跟",19)  # 调用类里面的功能来修改信息  满足
#接口上附加的逻辑  则完成修改信息
obj1.tell_info()

obj1.set_info(1111,'222')  #隐藏数据属性为了严格控制类外部访问者对属性的操作
# 如果不隐藏 那么外部访问者直接赋值之类的  在类内部赋值就会改变数据
obj1.tell_info()

3.2隐藏函数属性

目的是为了隔离复杂度，例如ATM程序的取款功能，该功能有很多其他功能组成，比如插卡、身份认证、输入金额、打印小票、取钱等，而对使用者来说，只需要开发取款这个功能接口即可，其余功能我们都可以隐藏起来

class ATM:
    def __card(self):  # 插卡
        print('插卡')

    def __auth(self):  # 身份认证
        print('用户认证')

    def __input(self):  # 输入金额
        print('输入取款金额')

    def __print_bill(self):  # 打印小票
        print('打印账单')

    def __take_money(self):  # 取钱
        print('取款')

    def withdraw(self):  # 取款功能
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()


obj = ATM()
obj.withdraw()

>>>
插卡
用户认证
输入取款金额
打印账单
取款

总结隐藏属性与开放接口，本质就是为了明确地区分内外，类内部可以修改封装内的东西而不影响外部调用者的代码；而类外部只需要拿到一个接口，只要接口名、参数不变，则无论设计者如何改变内部实现代码，使用者均无需改变代码。这就提供了一个良好的合作基础，只要接口这个基础约定不变，则代码的修改不足为虑。

四 property

# 成人的BMI数值：
# 过轻：低于18.5
# 正常：18.5-23.9
# 过重：24-27
# 肥胖：28-32
# 非常肥胖, 高于32
# 　　体质指数（BMI）=体重（kg）÷身高^2（m）
# 　　EX：70kg÷（1.75×1.75）=22.86

身高或者体重是不断变化的，因而每次想查看BMI值都需要通过计算机才能得到，但明显BMI听起来更像一个特征而非功能，为此python专门提供了一个装饰器property,可以将类中的函数‘伪装成’ 对象的数据属性，对象在访问该特殊属性时会触发功能的执行，然后将返回值作为本次访问的结果，例如

class People:
    def __init__(self,name,weight,height):
        self.name = name
        self.weight = weight
        self.height = height

    @property
    def bmi(self):
        return self.weight/(self.height ** 2)
    

p1 = People('william',73,1.8)
print(p1.bmi)

使用Property有效保证了属性访问的一致性。另外Property还提供设置和删除属性的功能，如下

class People:
    def __init__(self,name):

        self.__name = name
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self,x):
        if type(x) is not str:
            raise Exception('名字必须是字符串类型')
        self.__name = x
    @name.deleter
    def name(self):
        print('不允许删除')

p1 = People('egon')
print(p1.name)
p1.name = 'williams'
print(p1.name)
del p1.name

egon
williams
不允许删除

通过同一个对象的属性实现多个功能

优化整合后效果如下

class People:
    def __init__(self,name):
        self.__name = name
        
    def name(self):
        return self.__name
    def set_name(self,x):
        if type(x) is not str:
            raise Exception('名字必须是字符串类型')
        self.__name = x
    def del_name(self):
        print('不允许删除')
    name = property(name,set_name,del_name)  #将多行装饰器改为了一行来完成

p1 = People('egon')
print(p1.name)
p1.name = 'williams'
del p1.name
print(p1.name)

egon
不允许删除
williams

绑定方法与非绑定方法

绑定方法的

特点：绑定给谁就应该由谁来调用，谁来调用就会将自己作为第一个参数传入

非绑定方法

特点：不与类和对象绑定，意味着谁都可以调用，但无论谁来调用就是一个普通函数，没有自动传参的效果

class People:
    def __init__(self,name):
        self.name = name

    # 但凡在类中顶一个函数，默认就是绑定给对象的，应该由对象来调用
    # 会将对象当作第一个参数自动传入
    def tell(self):
        print(self.name)
    # 类中定义的函数被classmethod装饰过，就绑定给类，应该由类来调用，
    # 类来调用会将类本身当作第一个参数自动传入
    @classmethod
    def f1(cls):
        print(cls)
    # 类中定义的函数被staticmethod 装饰过，就成一个非绑定的方法即一个普通函数，谁可以调用
    # 但无论谁来调用就是一个普通函数，没有自动传参的效果
    @staticmethod
    def f2():
        pass

# p1 = People('egon')
# p1.tell()

People.f1()

class People:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def tell(self):



# 绑定给对象的函数  类可以调  但是是当做普通函数调用
# @classmethod绑定给类的函数  函数也可以调用  但是自动传入的参数是类

继承

一 集成的介绍

继承是创建新类的一种方式

新建的类称为子类

被继承的类称为父类、基类、超类

继承的特点是：子类可以遗传父类的属性

继承是来解决类与类之间冗余问题的

类是解决对象之间冗余问题的

class Parent1:  # 定义父类
    pass
class Parent2:  # 定义父类
    pass
class Sub1(Parent1):  # 单继承
    pass
class Sub2(Parent1,Parent2):  # 多继承
    pass

通过类的内置属性 __ bases __可以查看类继承的所有父类

print(Sub1.__bases__)
print(Sub2.__bases__)
(<class '__main__.Parent1'>,)
(<class '__main__.Parent1'>, <class '__main__.Parent2'>)

注意：

在python2中有新式类与经典类之分，在python3中全都是新式类

但凡是继承了object类的子类以及该子类的子子孙孙类都是新式类

反之就是经典类

>>> ParentClass1.__bases__
(<class ‘object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)

因而在Python3中统一都是新式类，关于经典类与新式类的区别，我们稍后讨论

提示：object类提供了一些常用内置方法的实现，如用来在打印对象时返回字符串的内置方法__str_

二 继承与抽象

要找出类与类之间的继承关系，需要先抽象，再继承。抽象即总结相似之处，总结对象之间的相似之处得到类，总结类与类之间的相似之处就可以得到父类，如图所示

基于上图我们可以看出类与类之间的继承指的是什么’是’什么的关系（比如人类，猪类，猴类都是动物类）。子类可以继承／遗传父类所有的属性，因而继承可以用来解决类与类之间的代码重用性问题。比如我们按照定义Student类的方式再定义一个Teacher类

class Teacher:
    school='清华大学'

    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age

    def teach(self):
        print('%s is teaching' %self.name)

类Teacher与Student之间存在重复的代码，老师与学生都是人类，所以我们可以得出如下继承关系，实现代码重用

class People:
    school='清华大学'

    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age

class Student(People):
    def choose(self):
        print('%s is choosing a course' %self.name)

class Teacher(People):
    def teach(self):
        print('%s is teaching' %self.name)

Teacher类内并没有定义__init__方法，但是会从父类中找到__init__,因而仍然可以正常实例化，如下

>>> teacher1=Teacher('lili','male',18)
>>> teacher1.school,teacher1.name,teacher1.sex,teacher1.age
('清华大学', 'lili', 'male', 18)

三 属性查找

#示例1
class Bar:
    def f1(self):
        print('Bar.f1')

    def f2(self):
        print('Bar.f2')
        self.f1()   # self.f1()  ←←  注意变形前后状态  变形在下面示例二↓
        # 属性查找先从对象  再当前类 然后再父类
        # 这一步相当于是 obj.f1()  要开始查找   但并不是就近查找是从头查找

class Foo(Bar):
    def f1(self):
        print('Foo.f1')

obj = Foo()
obj.f2()

#obj.f1()

逻辑解析1

#示例2
class Bar:
    def __f1(self):  # 变形 _Bar__f1
        print('Bar.f1')

    def f2(self):
        print('Bar.f2')
        self.__f1()   # self._Bar__f1()  这次变形 不单单是视觉上的__f1()而是变成了 _Bar__f1()这就是为什么明明应该从开始查  看起来开始的类Foo明明有__f1却走到了父类里面查
        千万不要误解成和示例一查找逻辑改变 这次变成了就近查找其实不是的 还是按照一开始的逻辑查找
        没查找到的原因是因为变形不单单是视觉上变形的那么简单

class Foo(Bar):
    def __f1(self):  # 变形  _Foo__f1
        print('Foo.f1')


obj = Foo()
obj.f2()


obj.__f1()
# 会报错 属性被隐藏后外部访问不到  能查找到形式只能是obj._Foo__f1  或者 obj._Bar__f1

obj._Bar__f1()
print(obj._Bar__f1) #bound method 绑定的函数内存地址加括号就会运行

逻辑解析2

四 继承的实现原理

4.1 菱形问题

菱形继承 /死亡钻石：一个子类继承的多条分支最终汇聚一个非object的类上

大多数面向对象语言都不支持多继承，而在Python中，一个子类是可以同时继承多个父类的，这固然可以带来一个子类可以对多个不同父类加以重用的好处，但也有可能引发著名的 Diamond problem菱形问题(或称钻石问题，有时候也被称为“死亡钻石”)，菱形其实就是对下面这种继承结构的形象比喻

A类在顶部，B类和C类分别位于其下方，D类在底部将两者连接在一起形成菱形。

这种继承结构下导致的问题称之为菱形问题：如果A中有一个方法，B和/或C都重写了该方法，而D没有重写它，那么D继承的是哪个版本的方法：B的还是C的？如下所示

class A(object):
    def test(self):
        print('from A')


class B(A):
    def test(self):
        print('from B')


class C(A):
    def test(self):
        print('from C')


class D(B,C):
    pass


obj = D()
obj.test() # 结果为：from B

要想搞明白obj.test()是如何找到方法test的，需要了解python的继承实现原理

4.2 继承原理

python到底是如何实现继承的呢？ 对于你定义的每一个类，Python都会计算出一个方法解析顺序(MRO)列表，该MRO列表就是一个简单的所有基类的线性顺序列表，如下

>>> D.mro() # 新式类内置了mro方法可以查看线性列表的内容，经典类没有该内置该方法
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。 而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类

所以obj.test()的查找顺序是，先从对象obj本身的属性里找方法test，没有找到，则参照属性查找的发起者(即obj)所处类D的MRO列表来依次检索，首先在类D中未找到，然后再B中找到方法test

ps：

1.由对象发起的属性查找，会从对象自身的属性里检索，没有则会按照对象的类.mro()规定的顺序依次找下去，
2.由类发起的属性查找，会按照当前类.mro()规定的顺序依次找下去，

4.3 深度优先和广度优先

参照下述代码，多继承结构为非菱形结构，此时，会按照先找B这一条分支，然后再找C这一条分支，最后找D这一条分支的顺序直到找到我们想要的属性

class E:
    def test(self):
        print('from E')


class F:
    def test(self):
        print('from F')


class B(E):
    def test(self):
        print('from B')


class C(F):
    def test(self):
        print('from C')


class D:
    def test(self):
        print('from D')


class A(B, C, D):
    # def test(self):
    #     print('from A')
    pass


print(A.mro())
'''
[<class '__main__.A'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.F'>, <class '__main__.D'>, <class 'object'>]
'''

obj = A()
obj.test() # 结果为：from B
# 可依次注释上述类中的方法test来进行验证

如果继承关系为菱形结构，那么经典类与新式类会有不同MRO，分别对应属性的两种查找方式：深度优先和广度优先

class G: # 在python2中，未继承object的类及其子类，都是经典类
    def test(self):
        print('from G')

class E(G):
    def test(self):
        print('from E')

class F(G):
    def test(self):
        print('from F')

class B(E):
    def test(self):
        print('from B')

class C(F):
    def test(self):
        print('from C')

class D(G):
    def test(self):
        print('from D')

class A(B,C,D):
    # def test(self):
    #     print('from A')
    pass

obj = A()
obj.test() # 如上图，查找顺序为:obj->A->B->E->G->C->F->D->object
# 可依次注释上述类中的方法test来进行验证,注意请在python2.x中进行测试

class G(object):
    def test(self):
        print('from G')

class E(G):
    def test(self):
        print('from E')

class F(G):
    def test(self):
        print('from F')

class B(E):
    def test(self):
        print('from B')

class C(F):
    def test(self):
        print('from C')

class D(G):
    def test(self):
        print('from D')

class A(B,C,D):
    # def test(self):
    #     print('from A')
    pass

obj = A()
obj.test() # 如上图，查找顺序为:obj->A->B->E->C->F->D->G->object
# 可依次注释上述类中的方法test来进行验证

4.4 python Mixins机制

一个子类可以同时继承多个父类，这样的设计常被人诟病，一来它有可能导致可恶的菱形问题，二来在人的世界观里继承应该是个”is-a”关系。 比如轿车类之所以可以继承交通工具类，是因为基于人的世界观，我们可以说：轿车是一个(“is-a”)交通工具，而在人的世界观里，一个物品不可能是多种不同的东西，因此多重继承在人的世界观里是说不通的，它仅仅只是代码层面的逻辑。不过有没有这种情况，一个类的确是需要继承多个类呢？

答案是有，我们还是拿交通工具来举例子:

民航飞机、直升飞机、轿车都是一个（is-a）交通工具，前两者都有一个功能是飞行fly，但是轿车没有，所以如下所示我们把飞行功能放到交通工具这个父类中是不合理的

class Vehicle:  # 交通工具
    def fly(self):
        '''
        飞行功能相应的代码        
        '''
        print("I am flying")


class CivilAircraft(Vehicle):  # 民航飞机
    pass


class Helicopter(Vehicle):  # 直升飞机
    pass


class Car(Vehicle):  # 汽车并不会飞，但按照上述继承关系，汽车也能飞了
    pass

但是如果民航飞机和直升机都各自写自己的飞行fly方法，又违背了代码尽可能重用的原则（如果以后飞行工具越来越多，那会重复代码将会越来越多）。

怎么办？？？为了尽可能地重用代码，那就只好在定义出一个飞行器的类，然后让民航飞机和直升飞机同时继承交通工具以及飞行器两个父类，这样就出现了多重继承。这时又违背了继承必须是”is-a”关系。这个难题该怎么解决？

不同的语言给出了不同的方法，让我们先来了解Java的处理方法。Java提供了接口interface功能，来实现多重继承：

// 抽象基类：交通工具类
public abstract class Vehicle {
}

// 接口：飞行器
public interface Flyable {
    public void fly();
}

// 类：实现了飞行器接口的类，在该类中实现具体的fly方法，这样下面民航飞机与直升飞机在实现fly时直接重用即可
public class FlyableImpl implements Flyable {
    public void fly() {
        System.out.println("I am flying");
    }
}



// 民航飞机，继承自交通工具类，并实现了飞行器接口
public class CivilAircraft extends Vehicle implements Flyable {
    private Flyable flyable;

    public CivilAircraft() {
        flyable = new FlyableImpl();
    }

    public void fly() {
        flyable.fly();
    }
}

// 直升飞机，继承自交通工具类，并实现了飞行器接口
public class Helicopter extends Vehicle implements Flyable {
    private Flyable flyable;

    public Helicopter() {
        flyable = new FlyableImpl();
    }

    public void fly() {
        flyable.fly();
    }
}

// 汽车，继承自交通工具类，
public class Car extends Vehicle {
}

现在我们的飞机同时具有了交通工具及飞行器两种属性，而且我们不需要重写飞行器中的飞行方法，同时我们没有破坏单一继承的原则。飞机就是一种交通工具，可飞行的能力是飞机的属性，通过继承接口来获取。

回到主题，Python语言可没有接口功能，但Python提供了Mixins机制，简单来说Mixins机制指的是子类混合(mixin)不同类的功能，而这些类采用统一的命名规范（例如Mixin后缀），以此标识这些类只是用来混合功能的，并不是用来标识子类的从属"is-a"关系的，所以Mixins机制本质仍是多继承，但同样遵守”is-a”关系，如下

class Vehicle:  # 交通工具
    pass


class FlyableMixin:
    def fly(self):
        '''
        飞行功能相应的代码        
        '''
        print("I am flying")


class CivilAircraft(FlyableMixin, Vehicle):  # 民航飞机
    pass


class Helicopter(FlyableMixin, Vehicle):  # 直升飞机
    pass


class Car(Vehicle):  # 汽车
    pass

# ps: 采用某种规范（如命名规范）来解决具体的问题是python惯用的套路

可以看到，上面的CivilAircraft、Helicopter类实现了多继承，不过它继承的第一个类我们起名为FlyableMixin，而不是Flyable，这个并不影响功能，但是会告诉后来读代码的人，这个类是一个Mixin类，表示混入(mix-in)，这种命名方式就是用来明确地告诉别人（python语言惯用的手法），这个类是作为功能添加到子类中，而不是作为父类，它的作用同Java中的接口。所以从含义上理解，CivilAircraft、Helicopter类都只是一个Vehicle，而不是一个飞行器。

使用Mixin类实现多重继承要非常小心

• 首先它必须表示某一种功能，而不是某个物品，python 对于mixin类的命名方式一般以 Mixin, able, ible 为后缀
• 其次它必须责任单一，如果有多个功能，那就写多个Mixin类，一个类可以继承多个Mixin，为了保证遵循继承的“is-a”原则，只能继承一个标识其归属含义的父类
• 然后，它不依赖于子类的实现
• 最后，子类即便没有继承这个Mixin类，也照样可以工作，就是缺少了某个功能。（比如飞机照样可以载客，就是不能飞了）

Mixins是从多个类中重用代码的好方法，但是需要付出相应的代价，我们定义的Minx类越多，子类的代码可读性就会越差，并且更恶心的是，在继承的层级变多时，代码阅读者在定位某一个方法到底在何处调用时会晕头转向，如下

class Displayer:
    def display(self, message):
        print(message)


class LoggerMixin:
    def log(self, message, filename='logfile.txt'):
        with open(filename, 'a') as fh:
            fh.write(message)

    def display(self, message):
        super().display(message) # super的用法请参考下一小节
        self.log(message)


class MySubClass(LoggerMixin, Displayer):
    def log(self, message):
        super().log(message, filename='subclasslog.txt') 


obj = MySubClass()
obj.display("This string will be shown and logged in subclasslog.txt")


# 属性查找的发起者是obj,所以会参照类MySubClass的MRO来检索属性
#[<class '__main__.MySubClass'>, <class '__main__.LoggerMixin'>, <class '__main__.Displayer'>, <class 'object'>]

# 1、首先会去对象obj的类MySubClass找方法display，没有则去类LoggerMixin中找，找到开始执行代码
# 2、执行LoggerMixin的第一行代码：执行super().display(message)，参照MySubClass.mro(),super会去下一个类即类Displayer中找，找到display，开始执行代码，打印消息"This string will be shown and logged in subclasslog.txt"
# 3、执行LoggerMixin的第二行代码：self.log(message)，self是对象obj，即obj.log(message)，属性查找的发起者为obj，所以会按照其类MySubClass.mro(),即MySubClass->LoggerMixin->Displayer->object的顺序查找，在MySubClass中找到方法log，开始执行super().log(message, filename='subclasslog.txt')，super会按照MySubClass.mro()查找下一个类，在类LoggerMixin中找到log方法开始执行，最终将日志写入文件subclasslog.txt

五 派生与方法重用

class Feather:
    school = '虹桥校区'
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

    def chak(self):
        print(self.school,self.__dict__)


class Student(Feather):
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def choice(self):
        print('%s 选课成功' %self.name)

stu1 = Student('william',19,'male')
stu1.chak()

class Teacher(Feather):  # 老师的信息有和学生共同的  但是也有不同的
    def __init__(self,name,age,gender,level):
        self.name = name
        self.age = age
        self.gender = gender
        self.level =level

    def score(self):
        print('%s正在打分' %self.name)

tea1 = Teacher('egon',19,'male',10)
tea1.chak()

在子类派生的新方法中如何重用父类的功能--------方式1

方式一：指名道姓地运行某一个类的函数 与继承无关

class Feather:
    school = '虹桥校区'
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

    def chak(self):
        print(self.school,self.__dict__)

class Student(Feather):
    def choice(self):
        print('%s 选课成功' %self.name)

stu1 = Student('william',19,'male')
stu1.chak()

class Teacher(Feather):
    def __init__(self,name,age,gender,level):  #将共同的从父类中引用过来
        Feather.__init__(self,name,age,gender)
        self.level = level

    def score(self):
        print('%s正在打分' %self.name)

tea1 = Teacher('egon',19,'male',10)
tea1.chak()

方式二：super()

super返回一个特殊的对象，该对象会参考发起属性查找的那一个类的Mro列表，去当前类的父类找属性，严格依赖继承。其中这里的广度优先和深度优先会体现在mro列表

class Feather:
    school = '虹桥校区'
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

    def chak(self):
        print(self.school,self.__dict__)

class Teacher(Feather):
    def __init__(self,name,age,gender,level):
        # Feather.__init__(self,name,age,gender)
        super(Teacher, self).__init__(name,age,gender) 
        self.level = level

    def score(self):
        print('%s正在打分' %self.name)

tea1 = Teacher('egon',19,'male',10)
tea1.chak()

# super() 返回一个特殊的对象，该对象会参考发起属性查找的那一个类的Mro里诶表，去当前类的
# 类查找属性，严格依赖继承
class A :  # [A,object]
    def test1(self):
        print('from A')
        super().test()  # 发起者这一步父类按mro顺序是到B了

class B:  # [B,object]
    def test(self):
        print('from B')

class C(A,B): #[C,A,B,object]
    pass
obj = C()
obj.test()



print(A.__mro__)

这两种方式的区别是：方式一跟继承没有关系，而方式二的super()是依赖于继承的，并且即使没有直接继承关系，super()仍然会按照mro继续往后查找

六 组合

在一个类中以另外一个类的对象作为数据属性，称为类的组合。组合与继承都是用来解决代码重用性问题。不同的是：继承是一种'是'的关系，比如老师是人、学生是人，当类之间有很多相同的之处，应该使用继承；而组合则是一种'有'的关系，比如老师有生日，学生有课程，当类之间有显著不同，并且较小的类是较大的类所需要的组件时，应该使用组合，如下示例

# 组合： 一个对象的属性值是指向另外一个类的对象

class People:
    school = '虹桥校区'

    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

class Student(People):
    def choice(self):
        print('%s选课成功'%self.name)

class Teacher(People):
    def __init__(self,name,age,gender,level):
        super(Teacher, self).__init__(name,age,gender)
        self.level = level

    def score(self):
        print('%s正在为学生打分' %self.name)

class Course:
    def __init__(self,name,price,period):
        self.name = name
        self.price = price
        self.period = period

    def tell(self):
        print('课程信息<%s:%s:%s>'%(self.name,self.price,self.period))

python = Course('python全栈开发',19800,'6mons')
linux = Course('linux',19000,'5mons')

tea1 = Teacher('egon',18,'male',10)

stu1 = Student('william',19,'male')

# stu1.course =[]
# stu1.course.append(python,linux)
stu1.course=python


#
# for course_obj in stu1.course:
#     course_obj.tell()

class Course:
    def __init__(self,name,period,price):
        self.name=name
        self.period=period
        self.price=price
    def tell_info(self):
        print('<%s %s %s>' %(self.name,self.period,self.price))

class Date:
    def __init__(self,year,mon,day):
        self.year=year
        self.mon=mon
        self.day=day
    def tell_birth(self):
       print('<%s-%s-%s>' %(self.year,self.mon,self.day))

class People:
    school='清华大学'
    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age

#Teacher类基于继承来重用People的代码，基于组合来重用Date类和Course类的代码
class Teacher(People): #老师是人
    def __init__(self,name,sex,age,title,year,mon,day):
        super().__init__(name,age,sex)
        self.birth=Date(year,mon,day) #老师有生日
        self.courses=[] #老师有课程，可以在实例化后，往该列表中添加Course类的对象
    def teach(self):
        print('%s is teaching' %self.name)


python=Course('python','3mons',3000.0)
linux=Course('linux','5mons',5000.0)
teacher1=Teacher('lili','female',28,'博士生导师',1990,3,23)

# teacher1有两门课程
teacher1.courses.append(python)
teacher1.courses.append(linux)

# 重用Date类的功能
teacher1.birth.tell_birth()

# 重用Course类的功能
for obj in teacher1.courses: 
    obj.tell_info()

此时对象teacher1集对象独有的属性、Teacher类中的内容、Course类中的内容于一身（都可以访问到），是一个高度整合的产物

多态

一 多态与多态性

多态：同一种实物有多种形态

class Animal:
    def talk(self):
        pass

class Dog(Animal):
    def talk(self):
        print('汪汪汪')


class Cat(Animal):
    def talk(self):
        print('喵喵喵！')

class Pig(Animal):
    def talk(self):
        print('哼哼哼哼')

#实例化得到三个对象
obj1 =Dog()
obj2 =Cat()
obj3 =Pig()

obj1.talk()
obj2.talk()
obj3.talk()

​ 也可以定义一个统一的接口来使用

def Talk(animal):
    animal.talk()
Talk(obj1)

Python中一切皆对象，本身就支持多态性

从例子可以看出，只要有叫的这个特征 不用考虑三者类型情况下 直接从多形态 推理出某同一事物

s.__len__（）
l.__len__()
t.__len__()
python内置一个统一的接口
len(s)
len(l)
len(t)

多态性的好处在于增强了程序的灵活性和可扩展性，比如通过继承Animal类创建了一个新的类，实例化得到的对象obj,可以使用相同的方式使用obj.talk()

>>> class Wolf(Animal): #动物的另外一种形态：狼
...     def talk(self):
...         print('嗷...')
... 
>>> wolf=Wolf() # 实例出一头狼
>>> wolf.talk() # 使用者根本无需关心wolf是什么类型而调用talk
嗷...

二 抽象基类

综上我们得知，多态性的本质在于不同的类中定义有相同的方法名，这样我们就可以不考虑类而统一一种方式去使用对象，可以通过父类引入抽象类的概念来硬性限制子类必须有某种方法名

import abc
# 制定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod  # 限制子类必须定义一个名为talk的方法
    def talk(self):
        pass

class Dog(Animal):
    def talk(self):
        print('汪汪汪')


class Cat(Animal):
    def talk(self):
        print('喵喵喵！')

class Pig(Animal):
    def talk(self):
        print('哼哼哼哼')
class wolf(Animal):
    def aoaoao(self):   #但凡继承了Animal的子类都必须遵循规定的标准
        print('aoaoaoao')  #如果不遵循那么在实例化阶段 将会报错  无法实例化

obj1 =Dog()
obj2 =Cat()
obj3 =Pig()
obj4 = wolf()  # 只要实例化就会报错

三 鸭子类型

但其实我们完全可以不依赖于继承，只需要纸草出外观和行为相同的对象，同样可以实现不考虑对象类型而使用对象，这正是python冲上的‘鸭子类型’(duck typing): 如果看起来像，叫声像，而且走起路来像鸭子，那么它就是鸭子 。 比起继承的方式，鸭子类型在某种程度上实现了程序的松耦合度，如下

class Dog():
    def talk(self):
        print('汪汪汪')


class Cat():
    def talk(self):
        print('喵喵喵！')

class Pig():
    def talk(self):
        print('哼哼哼哼')

dog = Dog()
cat = Cat()
pig = Pig()

dog.talk()
cat.talk()
pig.talk()

面向对象高级

引入--------------- 》关于面向对象有关的内置函数

isinstance 判断一个对象是否是一个类的实例

issubclass 判断一个类是否是一个类的子类

class Foo:
    pass
obj = Foo()

print(isinstance(obj,Foo))  #判断一个对象是否是一个类的实例
print(isinstance([1,2,3],list))  #判断这个列表是不是这个内置的类的实例

print(issubclass(Foo,object))  #判断一个类是否是一个类的子类

一 内置方法

什么内置方法？内置方法可以定制?

python的Class机制内置了很多特殊的方法来帮助使用者高度定制自己的类，这些内置方法都是以双下划线开头和结尾的，会在满足某种条件时自动触发，我们常用的--str--和--del--为例来简单介绍它们的使用

--str--方法会在对象被打印时自动触发，print功能打印的就是它的返回值，我们通常基于方法来定制对象的打印信息，该方法必须返回字符串类型

# __开头并且__结尾的属性会在满足某种条件下自动触发
class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self):
        return '%s:%s'%(self.name,self.age)  # 返回类型必须是字符串
obj = People('william',19)
print(obj)   #print(obj.__str__())拿到返回值后进行打印

--del--会在对象被删除时自动触发。由于python自带的垃圾回收机制会自动清理python程序的资源所以当一个对象只占用应用程序级资源时，完全没有必要为对象定制--del--方法，但在产生一个独享的同时涉及到申请系统资源（比如系统打开的文件、网络连接等）的情况下，关于系统资源的回收，python的垃圾回收机制便派不上用场了，需要我们为对象定制该方法，用来在对象被删除时自动触发回收系统资源的操作

# __del__,会在满足某种条件自动触发

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

    def __del__(self):
        print('+++++>')   #应用程序的资源  会自动清理
        #  操作系统的资源 也需要回收  所以就用这种方式清理

obj =People('egon',19)

# del obj
print('=============end============')  #如果不运行 del obj ,程序结束 清理内存  然后就触发__del__的运行又打印++++

举例--del--最主要的用法

class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.f = open(....)

    def __del__(self):
        self.f.close()   #删除对象时候做  应用程序资源删除后回自动清理应用程序的资源
        # 通过这种方式把相关联的操作系统资源回收掉
obj = People('egon',19)

二 反射

python是动态语言，而反射（reflection)机制被视为动态语言的关键。

什么是反射？

通过字符串来操作属性 .name

背后对应的是字典的操作

反射机制指的是在程序的运行状态中

对于任意一个类，都可以知道这个类的所有属性和方法；

对于任意一个独享，都能够调用他的任意方法和属性。

这种动态获取程序信息以及动态调用对象的功能称为反射机制。

在Pyhon中实现反射非常简单，在程序运行过程中，如果我们获取一个不知道存有何种属性的对象，若想操作其内部属性，可以先通过内置函数dir来获取任意一个类或者对象的属性列表，列表中全为字符串格式

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

obj = People('egon',19,'male')
print(dir(obj))
# >>>['__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', 'gender', 'name']

接下来就是想办法通过字符串来操作对象的属性了，这就涉及到内置函数hasattr、getattr、setattr、delattr 的使用了（python中一切皆对象，类和对象都可以被这四个函数操作，用法一样）

class Teacher:
    def __init__(self,full_name):
        self.full_name = full_name
t = Teacher('Egon Lin')

hasattr(t,'full_name')
print(hasattr(t,'full_name'))  #full_name 属性是否存在

getattr(t,'full_name')  # 本质就是t.age  get这个属性 不能存在该属性则返回默认值None
print(getattr(t,'full_name'))

setattr(t,'age',18)  # 将age=19  改为age= 18
print(t.age)
delattr(t,'age')  # 等同于del t.age

基于反射可以十分灵活的操作对象的属性，比如将用户交互的结果反射到具体的功能执行

class FtpServer:
    def serve_forever(self):
        while True:
            inp = input('input your cmd>>:').strip()
            cmd,file = inp.split()
            if hasattr(self,cmd):  # 判断属性是否存在
                func = getattr(self,cmd)
                print(func)
                func(file)
            else:
                print(hasattr(self,cmd))  # 属性不存在

    def get(self,file):
        print('Downloding %s...' %file)

    def put(self,file):
        print('Uploading %s...' %file)
server = FtpServer()
server.serve_forever()

面向对象end！！！！！！！！！！！！