一、靜態

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()