python学习（十五）——静态、组合、继承

一、静态

1、静态属性-就是数据属性

# 跟实例绑定，可以访问实例属性也可以访问类属性
class Room:
    def __init__(self,name,owner,width,length,heigh):
        tag = 1
        self.name=name
        self.owner=owner
        self.width=width
        self.length=length
        self.heigh=heigh
    
    # @property让方法看起来像属性，封装操作
    @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)
r1.cal_area # 运行

2、类方法

# 跟实例没有关系，只需要调用类方法下使用，能访问类的属性，不能访问实例的属性
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):
        print(cls)
        print('--》',cls.tag)  # print('--》',Room.tag)

Room.tell_info()

3、静态方法 - 名义上归属类管理，不能使用类变量和实例变量

# 类和实例都不能访问
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')

二、组合

# 大类包含小类
class Hand:
    pass

class Foot:
    pass

class Trunk:
    pass

class Head:
    pass

class Person:
    def __init__(self,id_num,name):
        self.id_num=id_num
        self.name=name
        self.hand=Hand()
        self.foot=Foot()
        self.trunk=Trunk()
        self.head=Head()

p1=Person('111111','alex')

#-----------------------------课程---------------------------------
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 北京')
# c1=Course('linux',10,'1h',s1)

msg='''
1 老男孩 北京校区
2 老男孩 南京校区
3 老男孩 东京校区
'''
while True:
    print(msg)
    menu={
        '1':s1,
        '2':s2,
        '3':s3
    }
    choice=input('选择学校>>: ')
    school_obj=menu[choice]
    name=input('课程名>>： ')
    price=input('课程费用>>： ')
    period=input('课程周期>>： ')
    new_course=Course(name,price,period,school_obj)
    print('课程【%s】属于【%s】学校' %(new_course.name,new_course.school.name))

三、继承

#-------------------------------继承-------------------------------
# 子类继承了父类的所有属性
# 1、当类之间有显著的不同，并且较小的类是较大的类所需要的组件时，用组合比较好
# 2、当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好
class Dad:
    pass
class Mum:
    pass
class Son1(Dad):   # 单继承
    def PaiSheng():
        print('派生')    # 派生的新功能
class Son2(Dad, Mum):    # 多继承
    pass

#----------------------------- 两种继承：--------------------------
# 1、继承基类的方法，再做扩展（意义不大，经常有害）
# 2、声明某个子类兼容于某基类，定义一个接口类，子类继承接口类，并在实现接口中定义方法

（1）接口继承 -父类规定子类要实现的方法，但是不实现

# 导入abc库可以实现接口集成
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()

（2）继承顺序

#--------------------------继承顺序---------------------------
# 1、深度优先 -经典类（python2）
# 2、广度优先 -新式类（python3）-不找到最上层

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

（3）子类中调用父类的方法

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

line13.show_info()

line13.run()


#----------------------------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)
           super(Subway,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__)

（4）作业

import pickle
import hashlib
import time
def create_md5():
    m = hashlib.md5()
    m.update(str(time.time()).encode('utf-8'))
    return  m.hexdigest()
id=create_md5()
time.sleep(1)
id1=create_md5()
time.sleep(1)
id2=create_md5()

print(id)
print(id1)
print(id2)

class Base:
    def save(self):
        with open('school.db','wb') as f:
            pickle.dump(self,f)

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

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

school_obj = pickle.load(open('school.db', 'rb'))
print(school_obj.name,school_obj.addr)
# s1=School('oldboy','北京')
# s1.save()