python基础----面向对象进阶，isinstance，issubclass，反射，内置attr，定制自己的数据类型

一，isinstance用法，issbuclass用法：

1，用法：isinstance(对象，类)  ，ininstance(object,class) 检测对象是不是class的对象，是返回结果True，不是返回结果False

#isinstance,检查对象是不是class对象，是的话返回True，不是返回False
class Foo:
    def __init__(self,name):
        self.name = name
    def s1(self):
        print("hello python")
a = Foo("egon")
print(isinstance(a,Foo))  #True

# a.s1 :a是对象，s1是对象的绑定方法，下面检测的是（对象的绑定方法）是不是class的对象，而不是对象，所以返回False
print(isinstance(a.s1,Foo))  #False

2，issubclass(sub,super) 检查sub这个类是否是super的派生类，也就是新建类是否继承了父类(超类)，

 

  继承了父类(超类)返回True，没有继承 返回False  

 

 用法 ：issubclass(类，父类)  ， issubclass（sub，super）

 

# issubclass(sub,super) 检查sub这个类是否是super的派生类，也就是新建类是否继承了父类(超类)，
# 继承了父类(超类)返回True，没有继承 返回False
class Foo(object):
    pass
class Msg(Foo):
    pass
class Go:
    pass
print(issubclass(Msg,Foo))  #True    Msg类，继承了Foo父类    返回True
print(issubclass(Go,Foo))   #False  Go类， 没有继承Foo父类  返回False

二，反射：

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

1.1 hasattr(object,"name") 判断对象中有没有一个字符串“name”对应的属性，有的话 返回 True， 没有的话返回False

class People:
     country = "China"
     def __init__(self,name):
         self.name = name

p = People("egon")
8 print(hasattr(p,"name")) #等同于这句，效果是一样的 print("name" in p.__dict__)
print(hasattr(p,"country"))  #True  先去p的名称空间找，没有，又去类里面找，找到了，返回True
print(hasattr(p,"walk"))   # False p的名称空间没有walk这个属性，又去类里面找，类里面也没有，所以返回False
print(p.__dict__)   #查看p的名称空间，以字典的形式返回结果
#  返回结果 ：{'name': 'egon'}

1.2，修改对象名称空间内字典的字符串key对应的value，找到字符串key才修改，对象名称空间的字典内没有的话

     新建一个字符串的key和value

      用法 ： setattr(object,"key",value)

class People:
    country = "China"
    def __init__(self,name,age):
        self.name = name
p = People("egon",20)
print(p.__dict__)  #原始p的名称空间是：{'name': 'egon'}
p.sex = "male"  # 新添加一个 "sex" = "male"

print(p.__dict__)  # 现在：{'name': 'egon', 'sex': 'male'}
setattr(p,"name","alex") #把“name”对象的“egon” 修改成了"alex"
print(p.__dict__)  # {'name': 'alex', 'sex': 'male'}
setattr(p,"ca",18)  # 新添加了一个字符串属性“ca”:18
print(p.__dict__)  # 变成这样：{'name': 'alex', 'sex': 'male', 'ca': 18}

1.3 getattr(object,"name") , 获取对象的属性，有这个属性，就执行，没有就报错
    getattr(object,"sex","提示信息") 加上“提示信息” 就不会报错了，没有“sex”这个属性，就会打印“提示信息”，也可以换成别的

class People:
    country = "China"
    def __init__(self,name,age):
        self.name = name
    def walk(self):
        print("%s is walking...."%(self.name))
p = People("egon",20)
print(getattr(p,"name"))  #  egon
print(getattr(p,"sex","这个属性不存在"))  # 结果：这个属性不存在， 因为__init__方法里没有sex属性，找不到，所以打印’这个属性不存在‘
print(getattr(p,"xxxx","这个属性不存在"))  #同上
f = getattr(p,"walk")  #把结果让变量f接收
f()  #执行  egon is walking....

# 通常 hasattr 和 getattr 是连用的
if hasattr(p,"walk"):   #查看“walk”在p名称空间里找，不在在去类里面找，找到了,判断成立，执行下面
    func= getattr(p,"walk")  #获取 字典里“walk”这个key ，func接收
    func()   #执行  egon is walking....
print(p.__dict__)  
print(People.__dict__)

1.4 delattr(object,"name")  删除属性  跟del 差不多，只是转换成字符串形式的删除

#4 deleteattr(object,"name")  删除属性
class People:
    country = "China"
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def walk(self):
        print("%s is walking...."%(self.name))
p = People("egon",20)
print(p.__dict__)   # {'name': 'egon', 'age': 20}
delattr(p,"name") #跟这个是一样的 del p.name
print(p.__dict__)   # {'age': 20}

2，反射模块，通过字符串方式导入模块

#反射当前模块的属性
import sys  # 先导入sys

class Foo:
    pass
def s1():
    print("111111")

def s2():
    print("222222")

this1 = sys.modules[__name__]  #语法
print(this1)
print(hasattr(this1,"s1"))
print(hasattr(this1,"s3"))

#用输入字符串的的方式导入time模块 
m = input(">>>>")
m1 = __import__(m)
print(m1.time())


#推荐使用方法
import importlib
t = importlib.import_module("time")
print(t.time())

3，反射的好处

1，实现可插拔机制
2，可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，
   什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能

class FtpClient:
    '''ftp服务端，没有实现具体的功能'''
    def __init__(self,addr):

        print("正在连接服务器[%s]"%addr)
        self.addr = addr
    def get(self):
        pass
    

from client import FtpClient  #导入client 模块 下的FtpClient类， 上面只定义，没有具体功能实现的

f = FtpClient(" 192.168.1.1 ")  # 在这里 实例化

if hasattr(f,"get"):     # 需要用到他的get功能，有的话就执行， 没有，就走下面的逻辑，
    func = getattr(f,"get")
    func()

#好处体现出来了 因为他没有写get功能，我就能开始写我后面的逻辑
print("执行下一个逻辑")#走下面的代码
11 ....
12 ....

三，内置attr：

    1，__getattr__  ： 只有属性不存在的情况，才会触发__getattr__,执行下面的代码，存在的属性，不会触发

class Foo:
    def __init__(self,name):
        self.name = name
    #属性不存在的情况下才会触发
    def __getattr__(self, item):
        print("----->")
f = Foo("egon")
print(f.name)
print(f.age)  #没有age这个属性，触发__getattr__
print(f.ort)  #没有ort这个属性，才触发__getattr__

    2，__setattr__ ：  添加属性和修改属性会触发__setattr__运行

class Foo:
    def __init__(self,name):
        self.name = name  # 等于 self.name = "egon"  自动触发下面的__setattr__
    def __setattr__(self, key, value):  #把 上面的值接收过来，一一对应，self=self，key=name，value=name
        if not isinstance(value,str):
            raise TypeError("must be str")
        print("key:%s , value:%s"%(key,value))  #key："name",value:"egon"
        self.__dict__[key] = value   # 把获取过来的key和value 加入类的名称空间的字典里

f= Foo("egon") #实例化
f.name = "alex"  #添加和修改会触发__setattr__运行  ，这是修改
f.sex = "male"    #添加和修改会触发__setattr__运行 , 这是添加
print(f.__dict__)   # {'name': 'alex', 'sex': 'male'}

    3，__delattr__  ：只有del删除的时候，才会触发__delattr__运行，执行__delattr__下面的删除操作，
                      当然你也可以不让删除，加上限制就可以了

class Foo:
    def __init__(self,name):
        self.name = name
    def __delattr__(self, item):
        # del self.item   #无限递归了 ，错误的
        self.__dict__.pop(item)   #正确的  去类的名称空间内字典中删除key

f= Foo("egon") #实例化
f.name = "alex"  #修改属性
f.sex = "male"   # 添加属性
print(f.__dict__)   #{'name': 'alex', 'sex': 'male'}
del f.sex   #只有del的时候才会触发__delattr__的运行  ，
print(f.__dict__) # {'name': 'alex'}
 #已经把'sex': 'male' 删除了
del f.name  
print(f.__dict__) # 变成空字典了{}

四：定制自己的数据类型：

1,包装：python为大家提供了标准数据类型，以及丰富的内置方法，其实在很多场景下我们都需要基于标准数据类型来定制我们自己的数据类型，新增/改写方法，这就用到了我们刚学的继承/派生知识（其他的标准类型均可以通过下面的方式进行二次加工）

1.1继承方式实现，定制自己的数据类型

#使基于继承的原理定制自己的数据类型，继承标准类型
#只实现append，还有一个insert,其他的还需要自己设置
class List(list): #继承内置list
    def append(self, object):
        if not isinstance(object,int):  #不是int类型抛出错误
            raise TypeError("muth be int")
        super().append(object)  #继承父类的append追加方法

    def insert(self, index: int, object: int):  #提示index是int型，object也是int型的
        if not isinstance(object,int):   # 加上不是int数据类型抛出错误的限制
            raise TypeError("muth be int")
        super().insert(index,object)   # 继承父类的安索引值，添加元素的insert方法
l = List([1,2,3,4])
l.append(100)
print(l)   #现在列表内的是这样：[1, 2, 3, 4, 100]
l.insert(0,12)
print(l)  #现在列表内是这样：[12, 1, 2, 3, 4, 100]

l.append("1")  #添加字符串出错了：TypeError: muth be int

 

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

实现授权的关键点就是覆盖__getattr__方法

2.1，授权的方式实现，定制自己的数据类型：

 

#不能用继承的方式没来实现open函数的功能
#用授权的方式实现，定制自己的数据类型
import time

class Open:
    def __init__(self,filepath,m="r",endcode="utf8"):
        self.x = open(filepath,mode=m,encoding = endcode)

        self.filepath = filepath
        self.m = m
        self.encoding = endcode

    def write(self,line):
        t = time.strftime("%Y-%m-%d %X")  #年月日格式，当前时间
        self.x.write("%s %s "%(t,line))  #把字符串和时间 写入self.x中

    def __getattr__(self, item):  #
        return getattr(self.x,item)

#写
f = Open("a.txt","w")
f.write("11111111\n")
f.write("22222222\n")
#读
f1 = Open("a.txt","r")
#基于授权，获得read()方法
print(f.read())

 

五，作业：

   1，基于授权定制自己的列表类型，要求定制的自己的__init__方法，
   2，定制自己的append：只能向列表加入字符串类型的值
   3，定制显示列表中间那个值的属性（提示：property）
   4，其余方法都使用list默认的（提示：__getattr__加反射）

# 作业：
#     基于授权定制自己的列表类型，要求定制的自己的__init__方法，
#     定制自己的append：只能向列表加入字符串类型的值
#     定制显示列表中间那个值的属性（提示：property）
#     其余方法都使用list默认的（提示：__getattr__加反射）
class List:
    def __init__(self,msg):
        self.msg = msg  #初始化msg,定制自己的__init__方法

    def append(self,object): # 定制append方法
        '''派生出自己的append方法，覆盖list的append方法'''
        if not isinstance(object,str): #追加的不是str类型的，抛出错误
            raise TypeError("math be str")
        self.msg.append(object)    # 把srt类型的值追加进自己的self.msg中

    @property  #
    def call_index(self): #定义查看属性
        l = len(self.msg)//2  #取列表长度，在取列表中间值
        return l
    def __getattr__(self, item):
        return getattr(self.msg,item)

    def __str__(self):
        return str(self.msg)

f = List([1,2,3])
print(f)  # [1, 2, 3]
f.append("hello")
print(f)  # [1, 2, 3, 'hello']
f.insert(2,'python') #基于授权，获得insert方法
print(f)  # [1, 2, 'python', 3, 'hello']
print(f.call_index)  #2