Title

一、静态属性

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

    @property
    def cal_area(self):
        # print('%s 住的 %s 总面积是%s' % (self.owner,self.name, self.width * self.length))
        return  self.width * self.length
r1=Room('厕所','alex',100,100,100000)
print(r1.cal_area)

　　要点：@property + return 把公共函数变成数据属性，实例调用的调用的时候去掉小括号，像调用普通属性一样调用它。

二、类方法

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

    @classmethod
    def tell_info(cls,x):
        print(cls)
        print('-->',cls.tag,x)

r1=Room('厕所','alex',100,100,100000)
Room.tell_info(10)

#输出:
<class '__main__.Room'>
--> 1 10

 　　要点：@classmethod 和 cls  专门供类使用的方法，类调用的时候不用传实例，也可以被实例调用（不建议这么做，本来就是划给类的方法，你还去调用它，四不是四傻） 

三、静态方法

　　是一种普通函数，位于类定义的命名空间中，不会对任何实例类型进行操作，python为我们内置了函数staticmethod来把类中的函数定义成静态方法。

　 应用场景:编写类时需要采用很多不同的方式来创建实例，而我们只有一个__init__函数，此时静态方法就派上用场了。

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

    @staticmethod
    def wash_body(a,b,c):
        print('%s %s %s正在洗澡' %(a,b,c))

Room.wash_body('alex','yuanhao','wupeiqi')
print(Room.__dict__)
r1=Room('厕所','alex',100,100,100000)
print(r1.__dict__)
r1.wash_body('alex','yuanhao','wupeiqi')

#输出:
alex yuanhao wupeiqi正在洗澡
{ 'wash_body': <staticmethod object at 0x000000000261B438>, ..... }
{'name': '厕所', 'owner': 'alex', 'width': 100, 'length': 100, 'heigh': 100000}
alex yuanhao wupeiqi正在洗澡

　

class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now(): #用Date.now()的形式去产生实例,该实例用的是当前时间
        t=time.localtime() #获取结构化的时间格式
        return Date(t.tm_year,t.tm_mon,t.tm_mday) #新建实例并且返回
    @staticmethod
    def tomorrow():#用Date.tomorrow()的形式去产生实例,该实例用的是明天的时间
        t=time.localtime(time.time()+86400)
        return Date(t.tm_year,t.tm_mon,t.tm_mday)

a=Date('1987',11,27) #自己定义时间
b=Date.now() #采用当前时间
c=Date.tomorrow() #采用明天的时间

print(a.year,a.month,a.day)
print(b.year,b.month,b.day)
print(c.year,c.month,c.day)

　要点：@staticmethod  只是名义上归属类管理，不能调用类变量、实例变量，只是类的工具包。

四、组合

　　组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合。

　 用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系。

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

class Trunk:
    pass

class Head:
    pass

class Person:
    def __init__(self,id_num,name):
        self.id_num=id_num
        self.name=name
        self.trunk=Trunk()
        self.head=Head()
p1=Person('111111','alex')
print(p1.name)
print(p1.id_num)
print(p1.__dict__)

#输出:
alex
111111
{'id_num': '111111', 'name': 'alex', 'trunk': <__main__.Trunk object at 0x000000000290B358>, 'head': <__main__.Head object at 0x000000000290B390>}

　　

class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr

    def zhao_sheng(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','oldboy 北京')
c2=Course('linux',10,'1h',s1)

　　要点：把s1当做参数传进去，可以不写死。

五、继承

　　继承是一种创建新的类的方式，在python中，新建的类可以继承自一个或者多个父类，原始类称为基类或超类，新建的类称为派生类或子类。

class Grandfather:
    pass

class Father(Grandfather): #单继承 Father是派生类，grandfather 是基类
    pass

class son(Father,Grandfather): #多继承
    pass

　　继承使用产生的场景：如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时我们不可能从头开始写一个类B，这就用到了类的继承的概念。通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用。

      除了继承与派生的概念还有一个概念是需要提出的那就是：组合。组合就是指在一个类中以另外一个类的对象作为数据属性，成为类的组合。

      组合与继承两者到底什么的关系？1.继承的方式：通过继承建立了派生类与基类的关系，两者之间是“是”的关系。当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如教授是老师    2.组合的方式：用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python课程（当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好）

class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr

    def zhao_sheng(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('北大','北京') 

c1=Course('linux',10,'1h',s1)
print(c1.name) #linux
print(c1.school) # <__main__.School object at 0x02182330>
print(c1.school.name) # 北大
print(c1.school.addr) # 北京

　　在这个例子中呢，创建了两个类，一个是学校类一个是课程类。需要将课程类与学校类进行相关联的时候，继承在这里是不合适的，那我们采用组合的方式来对这两个类进行关联，这样就在实例化一门课程的时候把学校的信息进行关联。

　　子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。

class Dad:
    '这个是爸爸类'
    money=10
    def __init__(self,name):
        print('爸爸')
        self.name=name
    def hit_son(self):
        print('%s 正在打儿子' %self.name)

class Son(Dad):
    money = 1000000000009
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def hit_son(self):
        print('来自儿子类')

　　

　　接口继承（抽象类）：

　 从实现角度来看，抽象类与普通类的不同之处在于：抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，且子类必须实现抽象方法。

　 抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。

 　抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计 。

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 write')


class Mem(All_file):
    def read(self):
        print('mem read')

    def write(self):
        print('mem write')

m1=Mem()
m1.read()
m1.write()

　　父类规定子类中必须实现的方法，但父类不实现（基类接口进行规范化子类）。

　　

　　顺序继承：

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新式类

#输出:
E
(<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

　　继承的顺序：A为父类

　　新式类找的顺序：

 　　在子类中调用父类的方法super（）：

class Vehicle1:
    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('开动啦')
        print('开动啦')
class Subway(Vehicle1):
        def __init__(self,name,speed,load,power,line):
           # Vehicle.__init__(self,name,speed,load,power)
           super().__init__(name,speed,load,power)  #super(__class__,self).__init__(name,speed,load,power)
           self.line=line
        def show_info(self):
            print(self.name,self.speed,self.load,self.power,self.line)
        def run(self):
            # Vehicle.run(self)
            super().run()
            print('%s %s 线，开动啦' %(self.name,self.line))
line13=Subway('北京地铁','10km/s',1000000000,'电',13)
line13.show_info()
line13.run()
print(line13.__class__)

　　当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。只要每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次（注意注意注意：使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要看MRO列表）。

学习资料来源：海峰老师