多态，封装，包装，授权！

多态：

class Mark:
    def __init__(self,name,point):
        self.name=name
        self.point=point
    def marks(self):
        if self.point>80:
            print('%s学习成绩：优异,太棒了' %self.name)
        elif self.point<80 and self.point>60:
            print('%s学习成绩：一般' % self.name)
        elif self.point < 60:
            print('%s学习成绩：太差,拖出去毙了....' % self.name)
class lee(Mark):
    pass
class XiaoZhou(Mark):
    pass
class XiaoWang(Mark):
    pass
def fun(obj):#统一接口,多种形式,反应的是一种执行时的状态,多态就是这两层的实现机制
    obj.marks()

a=lee('lee',100)
b=XiaoZhou('Zhou',61)
c=XiaoWang('Wang',55)

fun(a)
fun(b)
fun(c)

输出结果：

多态：统一接口,多种形式,反应的是一种执行时的状态,多态就是这两层的实现机制

封装：

class People:
    _star='earth'
    def __init__(self,name,id):
        self.name=name
        self.__id=id
    def get_id(self):#第三个层面的封装：最重要的目的是为了区分内外操作，在内部能直接调，外部不能直接调用
        print('这是我的私有方法，id是%s' %self.__id)
#p1=People('lee',15)
#p1.get_id()
#print(p1._People__id)   形式：_属性名,__属性名,__函数名,__函数名 p第二层单下划线封装和双下划线封装（只是在前面再加上_类名），第二个层面：只是约定上的封装，以免滥用封装，造成的问题就是不停的写接口函数来补救如：def get_id(self):

py的第一个层面：类就是麻袋，本身就是一种封装，类的调用者看到的就是一个麻袋(外部调用者)

py的第二个层面：只是约定上的封装，以免滥用封装，造成的问题就是不停的写接口函数来补救

py的第三个层面：最重要的目的是为了区分内外操作，在内部能直接调，外部不能直接调用

外部调用者标志着封装的本质：

from fz import People
p1=People('lzz',20)
p1.get_id()
#第一个层面的封装：类就是麻袋，本身就是一种封装，类的调用者看到的就是一个麻袋

反射：

class Black:
    user='黑狗'
    def __init__(self,name,id):
        self.name=name
        self.id=id
    def run(self):
        print('跑跑跑')
f1=Black('lee',15)
print(f1.user)
print(hasattr(f1,'user'))#在自己类中找是否存在该属性和方法，返回True或者False
print(getattr(f1,'user'))#在自己类中找到返回函数名或属性名，函数名加上括号即可调用，属性或方法不存在时，触发第三个参数 default
getattr(f1,'run')()
print(getattr(f1,'rewqrewrew','没有这个属性或方法'))
print(f1.__dict__)
setattr(f1,'id2',990)#重置
setattr(f1,'run',lambda x:print(x*10))#重置
f1.run(10)
print(f1.__dict__)
delattr(f1,'id2')#删除
print(f1.__dict__)
'''
#str\\sas\\sasa\\sas\\
module_t=__import__("str") #字符串方式导入模块，只会导入str这一层
import importlib
importlib.import_module("str")#也是字符串方式导入模块，会导入最终路径str\\sas\\sasa\\sas\\
'''


#双下划线开头的attr方法:
class Foo:
    x=1
    def __init__(self,y):
        self.y=y
    def __getattr__(self, item):#调用不存在时会触发此函数
        print('执行__getattr__')
f1=Foo(1)
print(f1.y)
print(getattr(f1,'y'))

class Foo:
    x=1
    def __init__(self,y):
        self.y=y
    def __delattr__(self, item):#删除时会触发此函数
        print('执行__dekattr__')
f1=Foo(1)
print(f1.y)
print(delattr(f1,'y'))

del f1.x


class Foo:
    x=1
    def __init__(self,y):
        self.y=y
    def __setattr__(self,key,value):
        #self.key=value#设置属性值会触发此函数，所以会无限递归死
        self.__dict__[key]=value#设置属性字典的属性内容不会触发__setattr__函数
        print('执行__setattr__')
f1=Foo(100)
setattr(f1,'ggg',10)
print(f1.__dict__)

hasattr:在自己类中找是否存在该属性和方法，返回True或者False

getattr:在自己类中找到返回函数名或属性名，函数名加上括号即可调用，属性或方法不存在时，触发第三个参数 default

setattr:重置

delattr:s删除

hasattr(obj,'name')-->obj.name #查到，返回True或False
getattr(obj,'name',default='xxx')-->obj.name #调用，不存在报错
setattr(obj,'name','lee')-->obj.name='lee'#重新设置或创建
delattr(obj,'name')-->del obj.name#删除

__getattr__为内置方法，当使用点号获取实例属性时，如果属性不存在就自动调用__getattr__方法

__setattr__为内置方法,当设置类实例属性时自动调用

__delattr__为内置方法,删除时会触发此函数

__getattribute__找没找到都会触发,找不到，内置函数__getattribute__会通过raise AttributeError抛出异常，触发__getattr__

class Fqq:
    d=10
    def __init__(self,num):
        self.num=num
    def __getattr__(self, item):
        print('找不到')

    def __getattribute__(self, item):#找没找到都会触发,找不到，内置函数__getattribute__会通过raise AttributeError触发__getattr__
        print('执行__getattribute__')
        raise AttributeError('抛出异常了')

c=Fqq(123)
c.s

包装:

class List(list):
    def append(self,strs):
        if type(strs) is str:
            super().append(strs)
        else:
            print('不是字符串不能添加')

l0=list('heewtewt')
l1=List('heewtewt')
print(l0,l1)
l1.append(11)
print(l0,l1)

包装：基于标准类来包装，通过继承和派生来实现的，根源是继承了一个标准类型，派生时调用标准类方法

授权：内置函数完成一个简单的权限控制，只读功能

class Gtx:
    def __init__(self,filename,mode,encoding='utf-8'):
        self.filename=open(filename,mode=mode,encoding=encoding)#接受实例化传入的参数
        self.mode=mode
        self.encoding=encoding
    def __getattr__(self, item):
        return getattr(self.filename,item)#找不到read触发__getattr__，对象a和read方法对应self和item，getattr负责吧字符串'read'找到read属性，完成调用，因为a对象的filename属性是open类的一个对象，即可调用read方法
    def write(self,num):
        print('光盘只能读取不能写入')
a=Gtx('aas.txt','r+')
a.write('111111\n')
print(a.read())