不一样的对象

isinstance(obj,cls)    判断实例在不在类里

class Foo:
    pass
f1=Foo()
print(isinstance(f1,Foo))
>>>True

issubclss(sub,super)     判断 第一个类 是不是 第二个类的 继承 派生

class Foo:
    pass
class bar(Foo):
    pass
print(issubclass(bar,Foo))
>>>True

反射

           hasattr(object,name)

           getaddr(object,name,default=None)

           setaddr(x,y,v)

           delattr(xy)

python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

hasattr(object,name): 判断object中有没有一个name字符串对应的方法或属性

class Foo:
    x=10
    def __init__(self,name):
        self.name=name
    def school(self):
        print("oldboy")
f1=Foo("szw")
print(hasattr(f1,"name"))
>>>True

getaddr(object,name,default=None):  存在就获取对应的值  ，不存在就报错，（默认值表示不在就返回）。

　　　　可以都类和函数使用

class Foo:
    x=10
    def __init__(self,name):
        self.name=name
    def school(self):
        print("oldboy")
f1=Foo("szw")
print(getattr(f1,"name"))
print(getattr(f1,"age",123))
>>>szw
>>>123

setaddr(x,y,v)    设置属性

class Foo:
    x=10
    def __init__(self,name):
        self.name=name
    def school(self):
        print("oldboy")
f1=Foo("szw")
setattr(f1,"name","alex")
print(f1.__dict__)
>>>{'name': 'alex'}

delattr(xy)  删除属性

class Foo:
    x=10
    def __init__(self,name):
        self.name=name
    def school(self):
        print("oldboy")
f1=Foo("szw")
delattr(f1,"name")
print(f1.__dict__)
>>>{}

对自己进行操作

import sys
def s1():
    print ('s1')
def s2():
    print ('s2')
this_module = sys.modules[__name__]
print(hasattr(this_module, 's1'))
print(getattr(this_module, 's2'))
>>>True
>>><function s2 at 0x0108D300>

 反射的机制

class FtpClient:
    def __init__(self,addr):
        print("正在连接服务器%s"%addr)
        self.addr=addr

from duixiang import FtpClient
f1=FtpClient("192.168.1.1")
if hasattr(f1,"get"):
    func_get=getattr(f1,"get")
    func_get()
else:
    print("处理其他逻辑")
>>>正在连接服务器192.168.1.1
>>>处理其他逻辑

             __setattr__

             __delattr__

             __getaddr__

class Foo:
    x=1
    def __init__(self,y):
        self.y=y
    def __getattr__(self, item):
        print("执行__getattr__")    #找不到找这里
    def __delattr__(self, item):
        print("执行__delattr__")
        self.__dict__.pop(item)  #在这里删除
    def __setattr__(self, key, value):
        print("执行__setattr__")
        self.__dict__[key]=value  #在这里赋值
f1=Foo(10)
f1.y
print(f1.__dict__)
del f1.y
print(f1.__dict__)
>>>执行__setattr__
>>>{'y': 10}
>>>执行__delattr__
>>>{}

 包装

二次加工=继承+派生     继承的方式完成授权

class List(list):
    def append(self,p_object):
        if type(p_object) is str:
            super().append(p_object)

obj=List("shizhengwen")
obj.append("123")
obj.append(456)
print(obj)
>['s', 'h', 'i', 'z', 'h', 'e', 'n', 'g', 'w', 'e', 'n', '123']

授权：授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有产品的功能。其它的则保持原样。授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性。

组合的方式完成授权

import time
class Open:
    def __init__(self,filename,mode="r+",encording="utf-8"):
        self.file=open(filename,mode,encoding="utf-8")
        self.mode=mode
        self.encording=encording
    def write(self,tiem):
        t=time.strftime("%Y-%m-%d-%X")
        self.file.write("%s %s"%(t,tiem))
    def __getattr__(self, item):
        print(item)
        return getattr(self.file,item)
r1=Open("a.txt","r+")
r1.write("741
")
r1.write("wen
")

六 描述符(__get__,__set__,__delete__)

  描述符是什么:描述符本质就是一个新式类,在这个新式类中,至少实现了__get__(),__set__(),__delete__()中的一个,这也被称为描述符协议
__get__():调用一个属性时,触发
__set__():为一个属性赋值时,触发
__delete__():采用del删除属性时,触发

 注意事项：

一 描述符本身应该定义成新式类,被代理的类也应该是新式类
二 必须把描述符定义成这个类的类属性，不能为定义到构造函数中
三 要严格遵循该优先级,优先级由高到底分别是
1.类属性
2.数据描述符
3.实例属性
4.非数据描述符
5.找不到的属性触发__getattr__()

 -------------------------------------------------------------------------------------------------------------------------

#自省
hasattr(obj,"属性")#obj.属性 是否存在
getattr(obj,"属性")#获取obj.属性  不存在则报错
getattr(obj,"属性","默认值")#获取obj.属性  不存在不会报错，返回那个默认值
setattr(obj,"属性","属性的值")#obj.属性=属性的值
delattr(obj,"属性")#del obj.属性

#__getattr__,__setattr__,__delattr__
#obj点的方式去操作属性时触发的方法
__getattr__:obj.属性 不存在时触发
__setattr__:obj.属性=属性的值 时触发
__delattr__:del obj.属性 时触发

#__getitem__,__setitem__,__delitem__
#obj[]的方式去操作属性时触发的方法
__getitem__:obj["属性"] 时触发
__setitem__:obj["属性"]=属性的值 时触发
__delitem__:del obj["属性"] 时触发

#_get__,__set__,delete__
#描述就是一个新式类，这个类至少要实现上述三个方法的一个
class 描述符:
    def __get__(self):
        pass
    def __set__(self, instance, value):
        pass
    def __delete__(self, instance):
        pass
class 类:
    name=描述符()
obj=类()
obj.name #get
obj.name="szw" #set
del obj.name #delete

#__del__:析构方法
#垃圾回收时触发