day25、 静态属性、类方法、静态方法、组合、继承、

一、 静态属性、类方法、静态方法

1.1静态属性

class Room:
    def __init__(self,name,owner,width,length):
        self.name=name
        self.owner=owner
        self.width=width
        self.length=length

    @property
    def cal_area(self):
        return self.width * self.length

r1=Room('厕所','alex',1000,100)
print(r1.cal_area)

r1.cal_area=10 #无法设置,会报错

静态属性

静态属性

静态属性，实际上就是类的数据属性

#求居住面积，
class Room:
    def __init__(self,name,owner,width,length,heigt):
        self.name=name
        self.owner=owner
        self.width=width
        self.length=length
        self.heigh=heigt

r1=Room('厕所','alex',100,100,10000)
r2=Room('厕所','袁浩',1,1,10000)
print(r1.__dict__)
print('%s住的:【%s】的总面积是:%s' %(r1.owner,r1.name,r1.length*r1.width))
>>>
{'width': 100, 'owner': 'alex', 'name': '厕所', 'heigh': 10000, 'length': 100}
alex住的:【厕所】的总面积是:10000

问题：每次添加一个人的犯贱，面积都要重新算，可否把算面积的方法封装到类里面？

#二、可否把算面积的公式,封装类方法?

class Room:
    def __init__(self,name,owner,width,length,heigt):
        self.name=name
        self.owner=owner
        self.width=width
        self.length=length
        self.heigh=heigt

    @property
    def cal_area(self):
       # print('%s住的:【%s】的总面积是:%s' % (self.owner, self.name, self.length * self.width))
        return self.length * self.width

r1=Room('厕所','alex',100,100,10000)
r2=Room('厕所','袁浩',1,1,10000)
#print(r1.__dict__)
#print('%s住的:【%s】的总面积是:%s' %(r1.owner,r1.name,r1.length*r1.width))
#r1.cal_area()  加上装饰器后,就不能如此调用了
#r1.cal_area()#我们知道了调用的是函数,所以加上()进行运行。
#用.方式调用的是类的【属性】(函数属性或者数据属性)。
#我们通过@property把类的方法变成类似数据属性。可以直接运行,不用加()
print(r1.cal_area)
print(r2.cal_area)

#还有点不一致的是:真正的数据属性,需要print才可以显示。而方法直接运行了!
#解决方法:把方法内部的print改为:

10000
1

总结：

相当于做了一个封装操作，背后操作你无法发现，无法知道r1.cal_area背后的实现逻辑。把背后的逻辑隐藏起来！

名词解释：

　　封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

　　在面向对象编程中，封装（encapsulation）是将对象运行所需的资源封装在程序对象中——基本上，是方法和数据。对象是“公布其接口”。其他附加到这些接口上的对象不需要关心对象实现的方法即可使用这个对象。这个概念就是“不要告诉我你是怎么做的，只要做就可以了。”对象可以看作是一个自我包含的原子。对象接口包括了公共的方法和初始化数据。[1

1.2 、静态方法

'''
staticmethod静态方法只是名义上的归属类管理，不能使用类变量和实例变量,是类的工具包
'''

class Room:
    def __init__(self,name,owner,width,length):
        self.name=name
        self.owner=owner
        self.width=width
        self.length=length

    @property
    def cal_area(self):
        return self.width * self.length

    @staticmethod
    def wash_body():
        print('洗刷刷,洗刷刷')

    def test():
        print('这可不是静态方法,用类调用没问题,你用一个实例调用看看')

Room.wash_body()

r1=Room('厕所','alex',10,10)
r1.wash_body()

#------
Room.test()
r1.test() #会报错,因为如果test不是静态方法,那么r1会吧自己传给test的第一个参数self,test无参所以报错

静态方法

#静态方法
class Room:
    tag=1
    def __init__(self,name,owner,width,length,heigt):
        self.name=name
        self.owner=owner
        self.width=width
        self.length=length
        self.heigh=heigt
    @property
    def cal_area(self):
        return self.length * self.width

    def test(self):
        print('from test',self.name)

    @classmethod
    def tell_info(cls):
        print(cls) #打印的就是类,<class '__main__.Room'>   __main__就是当前文件cls.tag相当于:Room.tag
        print('from classmethod ',cls.tag)#用类来掉类方法,就实例区分开来了。

    @staticmethod
    def wash_body(a,b,c):  #ROOM的属性字典里面也是存在的!
        print('%s %s %s正在洗澡'%(a,b,c))

    def test(x,y):
        print(x,y)
Room.wash_body('alex','yuanhao','wupeiqi') #类也可以调用

r1=Room('厕所','alex',100,100,10000)
r1.wash_body('alex','yuanhao','wupeiqi')    #实例也可以调用

Room.test(1,2)
#r1.test(1,2)#会自动把self参数传进去。实际上只需要2个参数
#跟谁都不绑定。和类跟实例都是剥离开来的。-----类的工具包

1.3、类方法

　　可否直接用类.方法。去调用方呢？初步尝试是不行的。需要传递一个实例的参数进去，也就是说，类在调类的函数属性的时候和实例捆绑在一块了。解决办法？

#解决二:→类方法(@classmethod)

class Room:
    tag=1
    def __init__(self,name,owner,width,length,heigt):
        self.name=name
        self.owner=owner
        self.width=width
        self.length=length
        self.heigh=heigt
    @property
    def cal_area(self):
        return self.length * self.width

    def test(self):
        print('from test',self.name)

    @classmethod
    def tell_info(cls):
        print(cls) #打印的就是类,<class '__main__.Room'>   __main__就是当前文件cls.tag相当于:Room.tag
        print('from classmethod ',cls.tag)#用类来掉类方法,就实例区分开来了。

    #def tell_info(self)
        #print('rom test', self.name)

Room.tell_info()    

>>>
<class '__main__.Room'>
from classmethod  1
#

不足:如此定义之后，只能访问类的属性。无法调用实例（self）的属性！！！

二、 组合

定义一个人的类，人有头，驱赶，手，脚等数据属性，这几个属性又可以是通过一个类实例化的对象，这就是组合，拼接。

用途：

1：做关联

2：小的组成大的

class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
    def zhaosheng(self):
        print('%s 正在招生'%(self.name))

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

s1=School('oldboy','北京')
s2=School('oldboy','南京')
s3=School('oldboy','东京')
c1=Course('linux',10,'1h',s1) #课程和学校就行绑定
print(c1.__dict__)

#需求查找linux课程所在学校。
print(c1.school.addr)   #这就是一种组合,大的类,是由小的类产生
>>>>
{'period': '1h', 'price': 10, 'name': 'linux', 'school': <__main__.School object at 0x102180630>}
北京

#选课系统;分校和创建课程
class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
    def zhaosheng(self):
        print('%s 正在招生'%(self.name))

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

#实例出学校
s1=School('oldboy','北京校区')
s2=School('oldboy','南京校区')
s3=School('oldboy','东京校区')
msg='''
    1:老男孩 北京校区
    2:老男孩 南京校区
    3:老男孩 东京校区
'''
while True:
    print(msg)
    meun={

        '':s1,
        '':s2,
        '':s3
    }
    choice=input('选择学校>>:')
    sch_obj=meun[choice]#实例化出来的学校,根据用户的输入,实例化出不同的学校
    name=input('课程名》》:')
    price=input('课程价格》》:')
    period=input('课程周期》》:')
    new_course=Course(name,price,period,sch_obj)
    print('课程【%s】属于%s' %(new_course.name,new_course.school.addr))

>>>
    1:老男孩 北京校区
    2:老男孩 南京校区
    3:老男孩 东京校区

选择学校>>:2
课程名》》:python
课程价格》》:15800
课程周期》》:8各月
课程【python】属于南京校区

课程关联学校和老是，老师关联学校

对于两者之间没有共同点，但是出来关联的就可以通过组合来实现。

组合的作用;

　　　　关联类和类之间。

曾经的low的解决方式：

class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
        self.course_list=[]
    def zhao_sheng(self):
        print('%s 正在招生' %self.name)
class Course:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

s1=School('oldboy','北京')
s2=School('oldboy','南京')
s3=School('oldboy','东京')

c1=Course('linux',10,'1h')
c2=Course('python',10,'1h')

s1.course_list.append(c1)
s1.course_list.append(c2)
print(s1.__dict__)

for course_obj in s1.course_list:
    print(course_obj.name,course_obj.price)

选课学校

三、面向对象编程三大特性

3.1 继承

一 什么是类的继承？

类的继承跟现实生活中的父、子、孙子、重孙子、继承关系一样，父类又称为基类。

python中类的继承分为：单继承和多继承

class ParentClass1:
    pass

class ParentClass2:
    pass

class SubClass(ParentClass1): #单继承
    pass

class SubClass(ParentClass1,ParentClass2): #多继承
    pass

二 子继承到底继承了父类的什么属性？

正本清源五：有人说，子类继承了父类的所有属性，子类自定义的属性如果跟父类重名了，那就覆盖了父类的--->大大大傻逼

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

class Dad:
    '我是爸爸类啊'
    money=10000
    def __init__(self,name):
        print('爸爸类的初始化方法-->')
        self.name=name
    def hit_son(self):
        print('调用者是%s 我是爸爸吧的方法啊' %self.name)
class Son(Dad):
    '我是儿子类吭'
    pass
s1=Son('小白龙')
print('继承的爸爸的遗产',s1.money)
s1.hit_son() #继承了爸爸打儿子的方法

#上述表现貌似证明了儿子类,继承了父类所有的属性(类的数据属性和函数属性)
print(Dad.__dict__)
print(Son.__dict__)
#打印的结果发现,儿子类的属性字典中没有任何关于父类的属性
#注意了
#注意了
#继承的本质是父类把自己类的属性引用传递给了儿子,儿子类可以调用父类的属性,但其实它们是不属于儿子的

#因此,在子类中定义的任何数据属性和函数属性都存在于儿子类的属性字典中,调用时优先从自己的属性字典里面查
class Dad:
    '我是爸爸类啊'
    money=10000
    def __init__(self,name):
        print('爸爸类的初始化方法-->')
        self.name=name
    def hit_son(self):
        print('调用者是%s 我是爸爸吧的方法啊' %self.name)
class Son(Dad):
    '我是儿子类吭'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def hit_son(self):
        print('我们做儿子的,哪能忍心下手再打儿子')

s1=Son('小白龙',18)
print(s1.name,s1.age)
s1.hit_son()
print(Dad.__dict__)
print(Son.__dict__)

做儿子的哪能打儿子

小白龙 18
我们做儿子的,哪能忍心下手再打儿子
{'__module__': '__main__', 'money': 10000, 'hit_son': <function Dad.hit_son at 0x10217ca60>, '__doc__': '我是爸爸类啊', '__dict__': <attribute '__dict__' of 'Dad' objects>, '__weakref__': <attribute '__weakref__' of 'Dad' objects>, '__init__': <function Dad.__init__ at 0x10217c9d8>}
{'__module__': '__main__', '__doc__': '我是儿子类吭', 'hit_son': <function Son.hit_son at 0x10217cb70>, '__init__': <function Son.__init__ at 0x10217cae8>}

三 什么时候用继承？

1.当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好

例如：描述一个机器人类，机器人这个大类是由很多互不相关的小类组成，如机械胳膊类、腿类、身体类、电池类

2.当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好

例如

　　猫可以：喵喵叫、吃、喝、拉、撒

　　狗可以：汪汪叫、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，如下所示

class 猫：

    def 喵喵叫(self):
        print '喵喵叫'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

class 狗：

    def 汪汪叫(self):
        print '喵喵叫'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

伪代码

伪代码

上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：

　　动物：吃、喝、拉、撒

　　   猫：喵喵叫（猫继承动物的功能）

　　   狗：汪汪叫（狗继承动物的功能）

class 动物:

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 猫(动物)：

    def 喵喵叫(self):
        print '喵喵叫'

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 狗(动物)：

    def 汪汪叫(self):
        print '喵喵叫'

伪代码

class Animal:

    def eat(self):
        print("%s 吃 " %self.name)

    def drink(self):
        print ("%s 喝 " %self.name)

    def shit(self):
        print ("%s 拉 " %self.name)

    def pee(self):
        print ("%s 撒 " %self.name)

class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed = '猫'

    def cry(self):
        print('喵喵叫')

class Dog(Animal):

    def __init__(self, name):
        self.name = name
        self.breed='狗'

    def cry(self):
        print('汪汪叫')

# ######### 执行 #########

c1 = Cat('小白家的小黑猫')
c1.eat()

c2 = Cat('小黑的小白猫')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()

继承的实现

四 继承同时具有两种含义

含义一.继承基类的方法，并且做出自己的改变或者扩展（代码重用）

含义二.声明某个子类兼容于某基类，定义一个接口类，子类继承接口类，并且实现接口中定义的方法。

接口：一个方法，一个具体的函数

定义一个父类，规定所有的子类必须实现什么方法。但是父类不去实现。子类必须实现具体的方法。【比如一切皆文件，就会有一个限定，要求子类，必须继承文件的读和写方法。】

基类当中利用装饰器把自己的方法定义成为接口函数。这样，只要来一个子类，那么子类必须实现两个方法。不实现就无法实现实例化

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

#一切皆文件

import abc
class All_file(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def read(self):
        '子类必须实现读功能'
        pass

    @abc.abstractmethod
    def write(self):
        '子类必须实现写功能'
        pass

# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类必须实现父类的方法

class Txt(All_file):
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的读取方法')

class Sata(All_file):
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(All_file):
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

归一化式继承

实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。代码之间越独立越好，

继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。

归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。

import abc
class All_file(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def read(self):
        pass

    @abc.abstractmethod
    def write(self):
        pass
class Disk(All_file):
    def read(self):
        print('disk read')
    def write(self):
        print('disk write')
class Cdrom(All_file):
    def read(self):
        print('Cdrom read')
    def write(self):
        print('Cdrom wrote')
class Mem(All_file):
    def read(self):
        print('sds')
    def write(self):
        print('ds')

s1=Disk()
s2=Cdrom()
s3=Mem()

五 继承顺序



新式类：广度优先；第一次不找到基类，第二次才找到最深。

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

class A:
    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):
    def test(self):
        print('from D')

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

class F(D,E):
    # def test(self):
    #     print('from F')
    pass
f1=F()
f1.test()
print(F.__mro__) #python2中没有这个属性

#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类

继承顺序

继承顺序

class A:
    # def test(self):
    #     print('A')
    pass
class B(A):
    # def test(self):
    #     print('B')

    pass
class C(A):
    # def test(self):
    #     print('C')
    pass

class D(B):
    # def test(self):
    #     print('D')
    pass

class E(C):
    # def test(self):
    #     print('E')
    pass

class F(D,E):
    # def test(self):
    #     print('F')
    pass
f1=F()
f1.test()   #经典类：F->D->B->A-->E-->

# print(F.__mro__)

#F-->D->B-->E--->C--->A新式类

继承顺序

终极解密：

继承关系定义好之后，顺序就定义好了

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

为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类

查看顺序表：python3：默认继承（object）所以最后一步找的是object。

print(F.__mro__)
#(<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

六 子类中调用父类方法——派生新的方法，任然要沿用父类的逻辑

子类继承了父类的方法，然后想进行修改，注意了是基于原有的基础上修改，那么就需要在子类中调用父类的方法

会自动传递self参数：实例化调用方法、对象调用类方法。

方法一：父类名.父类方法()

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

class Vehicle: #定义交通工具类
     Country='China'
     def __init__(self,name,speed,load,power):
         self.name=name
         self.speed=speed
         self.load=load
         self.power=power

     def run(self):
         print('开动啦...')

class Subway(Vehicle): #地铁
    def __init__(self,name,speed,load,power,line):
        Vehicle.__init__(self,name,speed,load,power)
        self.line=line

    def run(self):
        print('地铁%s号线欢迎您' %self.line)
        Vehicle.run(self)

line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
line13.run()

新年愿望是买一辆地铁

新年愿望是买一辆地铁

方法二：super()

super().__init__(name,load,speed,.....)=super(Subway,self)__init__(name,load,speed,.....)

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

class Vehicle: #定义交通工具类
     Country='China'
     def __init__(self,name,speed,load,power):
         self.name=name
         self.speed=speed
         self.load=load
         self.power=power

     def run(self):
         print('开动啦...')

class Subway(Vehicle): #地铁
    def __init__(self,name,speed,load,power,line):
        #super(Subway,self) 就相当于实例本身
        super(Subway,self).__init__(name,speed,load,power)
        self.line=line

    def run(self):
        print('地铁%s号线欢迎您' %self.line)
        super(Subway,self).run()

class Mobike(Vehicle):#摩拜单车
    pass

line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
line13.run()

摩拜单车

line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
line13.run()
class  Vehcle:
    Country = 'China'
    def __init__(self,name,load,changdu):
        self.name=name
        self.load=load
        self.changsu=changdu
    def run(self):
        print('%s开动啦'%self.line)
class  Sunway(Vehcle):
    def __init__(self,name,load,changdu,line):
        #Vehcle.__init__(self,name,load,changdu)
        super().__init__(name,load,changdu)   #运行super()函数,调用父类的__init__ 不用写父类的属性名。
        self.line=line                        #相当于super(__class__,参数)__class__=Sunway
    def run(self):
        print('地铁%s号线欢迎您' % self.line)
        #Vehcle.run(self)
        super().run()  #uper() -> same as super(__class__, <first argument>)
line13=Sunway('中国地铁','1000人/箱','10m',13)
line13.run()

开动了

不用super引发的惨案

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

#每个类中都继承了且重写了父类的方法
class A:
    def __init__(self):
        print('A的构造方法')
class B(A):
    def __init__(self):
        print('B的构造方法')
        A.__init__(self)
class C(A):
    def __init__(self):
        print('C的构造方法')
        A.__init__(self)
class D(B,C):
    def __init__(self):
        print('D的构造方法')
        B.__init__(self)
        C.__init__(self)

    pass
f1=D()

print(D.__mro__) #python2中没有这个属性

不使用

使用super

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

#每个类中都继承了且重写了父类的方法
class A:
    def __init__(self):
        print('A的构造方法')
class B(A):
    def __init__(self):
        print('B的构造方法')
        super(B,self).__init__()

class C(A):
    def __init__(self):
        print('C的构造方法')
        super(C,self).__init__()

class D(B,C):
    def __init__(self):
        print('D的构造方法')
        super(D,self).__init__()

f1=D()

print(D.__mro__) #python2中没有这个属性

使用super

使用super