Python基础（17）_面向对象程序设计（抽象类、继承原理、封装、多态，绑定方法）

import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        pass
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass

# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类没有定义抽象方法

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')
    def write(self):
        print('文本数据的读取方法')

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')
    def write(self):
        print('硬盘数据的读取方法')

wenbenwenjian=Txt()
yingpanwenjian=Sata()


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

#新式类：
class A(object):
    def test(self):
        print('from A')
    pass
class B(A):
    # def test(self):
    #     print('from B')
    pass
class C(A):
    # def test(self):
    #     print('from C')
    pass
class D(A):
    # def test(self):
    #     print('from D')
    pass
class E(B):
    # def test(self):
    #     print('from E')
    pass
class F(C):
    # def test(self):
    #     print('from F')
    pass
class G(D):
    # def test(self):
    #     print('from G')
    pass
class H(E,F,G):
    # def test(self):
    #     print('from H')
    pass
h=H()
# h.test=1
# print h.__dict__
#新式类的在这中继承结构下，属性的查找关系
# H->E->B->F->C-G-D-A 广度优先


#经典类的在这中继承结构下，属性的查找关系
# H-E-B-A-F-C-G-D 深度优先

class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def foo(self):
        print('from parent')

class Teacher(People):
    def __init__(self,name,age,sex,salary,level):
        # People.__init__(self,name,age,sex) #指名道姓地调用People类的__init__函数

        #在python3中
        super().__init__(name,age,sex) #调用父类的__init__的功能，实际上用的是绑定方法，super只查找一次
　　　　　　

        self.salary=salary
        self.level=level
    def foo(self):
        super().foo()
        print('from child')


t=Teacher('egon',18,'male',3000,10)
# print(t.name,t.age,t.sex,t.salary,t.level)
t.foo()

class A:
    __N=0 
#类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
#这种变形操作只在定义阶段发生

    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.，在类的外部，无法直接使用变形的属性

#在外部访问隐藏函数方式：
t=A()
t._A__foo()

class People:
    def __init__(self,name,age,sex,height,weight,permission=False):
        self.__name=name
        self.__age=age
        self.__sex=sex
        self.__height=height
        self.__weight=weight
        self.permission=permission

    @property           #只读
    def name(self):
        return self.__name

    @name.setter        #可写
    def name(self,val):
        if not isinstance(val,str):
            raise TypeError('名字必须为字符串')
        self.__name=val

    @name.deleter       #可删除
    def name(self):
        if not self.permission:
            raise PermissionError('权限不够')
        del self.__name

    @property
    def bmi(self):
        return self.__weight/(self.__height**2)

    def tell_info(self):
        print('''
        --------%s  info----------
        Name:%s
        Age:%s
        Sex:%s
        Height:%s
        Weight:%s
        --------------------------
        '''%(self.__name,self.__name,self.__age,self.__sex,self.__height,self.__weight))

egon=People('egon',18,'male',1.76,72)
egon.tell_info()
print(egon.name)
egon.name='alex'
print(egon.name)
# egon.permission=True
# del egon.name
print(egon.bmi)

import hashlib
import time
class MySQL:
    def __init__(self,host,port):
        self.id=self.create_id()
        self.host=host
        self.port=port
    @staticmethod
    def create_id(): #就是一个普通工具
        m=hashlib.md5(str(time.clock()).encode('utf-8'))
        return m.hexdigest()

print(MySQL.create_id) #<function MySQL.create_id at 0x0000000001E6B9D8> #查看结果为普通函数
conn=MySQL('127.0.0.1',3306)
print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8> #查看结果为普通函数