一 、isinstance(obj,cls)和issubclass(sub,super)
（1）isinstance(obj,cls)检查对象obj是否是类 cls 的对象，返回True和Flase
示例：
class People:
country="china"
def __init__(self,name):
self.name=name
def test(self):
print("test")
p=People("xuyaunyuan")
print(p.name)
print(isinstance(p,People))#判断对象P是不是类People的对象
执行结果是：
xuyaunyuan
True
（2）issubclass(sub, super)检查sub类是否是 super 类的派生类，返回True和Flase
示例：
class People:
country="china"
def __init__(self,name):
self.name=name
def test(self):
print("test")
class Student(People):
def __init__(self,name,id):
self.name=name
self.id=id
print(issubclass(Student,People))#检查Student类是否是 super 类(people类)的派生类
执行结果是：
True
二 、反射
（1）反射的概念：主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。
（2）四个可以实现自省的函数（下列方法适用于类和对象，一切皆对象，类本身也是一个对象）
a、hasattr(object,name)——判断object中有没有一个name字符串对应的方法或属性
b、getattr(object,name)——获取属性
c、setattr(x, y, v)——设置属性
d、delattr(x, y）—— 删除属性
分别示例：
a、hasattr(object,name)——判断object中有没有一个name字符串对应的方法或属性
class People:
country="china"
def __init__(self,name):
self.name=name
def test(self):
print("test")
p=People("xuyaunyuan")
#hasattr有没有
print(hasattr(p,"name"))#判断对象P有没有name属性
print("name" in p.__dict__)#等同于上面
执行结果是：
True
True
b、getattr(object, name, default=None)——获取属性
class People:
country="china"
def __init__(self,name):
self.name=name
def test(self):
print("test")
p=People("xuyaunyuan")
#getattr#获取
print(getattr(p,"country"))#获取数据属性country
print(getattr(p,"name"))
执行结果是：
china
xuyaunyuan
c、setattr(x, y, v)——设置属性
class People:
country="china"
def __init__(self,name):
self.name=name
def test(self):
print("test")
p=People("xuyaunyuan")
#setattr设置setatttr(x指对象，y指属性，v指value值)
setattr(p,"age",18)
setattr(p,"sex","woman")
print(p.__dict__)#查看是否设置成功
执行结果是：
{'name': 'xuyaunyuan', 'age': 18, 'sex': 'woman'}
d、delattr(x, y）—— 删除属性
class People:
country="china"
def __init__(self,name):
self.name=name
def test(self):
print("test")
p=People("xuyaunyuan")
#delattr#删除
delattr (p,"name")
print(p.__dict__)#查看是否删除成功
执行结果是：
{}
总结：
hasattr(obj,'属性') #obj.属性 是否存在
getattr(obj,'属性') #获取obj.属性 不存在则报错
getattr(obj,'属性'，'默认值') #获取obj.属性 不存在不会报错，返回那个默认值
setattr(obj，'属性'，'属性的值') #obj.属性=属性的值
delattr(obj，'属性') #del obj.属性
（3）反射当前模块的属性
关于文件的2种运行方式：把文件当脚本运行和把文件当做模块导入
a、关于导入其他模块，利用反射查找该模块是否存在某个方法
示例：
新建2个文件，分别取名为test.py和test1.py
import sys
##在test.py文件下定义一些名字
x=11#定义变量名x
class People:#定义类名People
def __init__(self):
pass
def s1():#定义函数名s1
print("s1")
def s2():#定义函数名s2
print("s2")
import test#在test1.py的文件下导入test模块
#在test1.py的文件下导入test模块
print(test)#打印导入的test模块
print(test.People)#打印类
test.s1()#运行函数s1
test.s2()#运行函数s2
print(test.x)#打印变量x
执行结果是：
<module 'test' from 'C:\Users\Administrator\PycharmProjects\py_fullstack_s4\day32-面向对象进阶\模块导入\test.py'>
<class 'test.People'>
s1
s2
11
b、在自己的文件内部查看自己的模块
this_module = sys.modules[__name__]#在自己的文件内查看自己的模块和绝对路径
print(this_module)
示例：
import sys
class Foo:
pass
def s1():
print('s1')
def s2():
print('s2')
this_module = sys.modules[__name__]#在自己的文件内查看自己的模块和绝对路径
print(this_module)
print(hasattr(this_module, 's1'))#也可进行判断在this_module里面有没有s1
print(getattr(this_module, 's2'))#也可获取this_module里面的s2
this_module.s2()#运行s2函数
this_module.s1()#运行s1函数
执行结果是：
<module '__main__' from 'E:/飞秋/徐圆圆课程视频/Python fullstack s4 基础篇-day31/day31/test.py'>
True
<function s2 at 0x000000000282A8C8>
s2
s1
（4）反射的好处（为什么要用反射）
好处一：实现可插拔机制
反射的好处就是，可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能
示例：
新建2个文件，分别为客户端和服务端
在客户端定义如下：
class FtpClient:
'ftp客户端,但是还有没有实现具体的功能'
def __init__(self,addr):
print('正在连接服务器[%s]' %addr)
self.addr=addr
def test(self):
print('test')
在服务端调用：
import ftpclient
print(ftpclient)
f1=ftpclient.FtpClient('192.168.1.1')
if hasattr(f1,'get'):#客户端并没有定义get函数，如果定义了的话，即可运行
func=getattr(f1,'get')#客户端并没有定义get函数
func()
else:
print('其他逻辑')
执行结果是：
<module 'ftpclient' from 'E:\飞秋\徐圆圆课程视频\Python fullstack s4 基础篇-day31\day31\反射实现可插拔机制\ftpclient.py'>
正在连接服务器[192.168.1.1]
其他逻辑
好处二：动态导入模块
示例：方法一 （利用内置函数）
#不推荐用法
m=input("请输入你要导入的模块：")
m1=__import__(m)#内置函数
print(m1)
print(m1.time())
执行结果是：
请输入你要导入的模块：time
<module 'time' (built-in)>
1493024366.8544436
示例：方法二（推荐用法）
#推荐使用方法
import importlib#调用模块
t=importlib.import_module('time')
print(t.time())
执行结果是：
1493024403.4785383
三、__setattr__,__delattr__,__getattr__
三个参数，给对象添加属性
__setattr__ 添加/修改属性会触发它的执行
__delattr__ 删除属性的时候会触发
__getattr__ 只有在使用点调用属性且属性不存在的时候才会触发
作用：系统内置函数属性（你定义了就用你定义的函数属性，不定义就用系统默认的函数属性）
整体使用情况示例：
class Foo:
def __init__(self,name):
self.name=name
def __setattr__(self, key, value):
print("——setattr——key:%s value:%s"%(key,value))
print(type(key))
print(type(value))
# self.key = value # 这就无限递归了,不能用
self.__dict__[key]=value#将值加入字典内
def __delattr__(self, item):
print("——delattr——item:%s"%item)
print(type(item))
# del self.item #无限递归了，不能用
self.__dict__.pop(item)#删除
def __getattr__(self, item):
print('----> from getattr:你找的属性不存在')
#__setattr__添加/修改属性会触发它的执行
f=Foo("xuyuanyuan")
print(f.__dict__)# 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
f.age="18"#增加age属性
print(f.__dict__)
#__delattr__删除属性的时候会触发
f.__dict__['age']=18#我们可以直接修改属性字典,来完成添加/修改属性的操作
del f.age
print(f.__dict__)
#__getattr__只有在使用点调用属性且属性不存在的时候才会触发
f.aaa
执行结果：
——setattr——key:name value:xuyuanyuan
<class 'str'>
<class 'str'>
{'name': 'xuyuanyuan'}
——setattr——key:age value:18
<class 'str'>
<class 'str'>
{'name': 'xuyuanyuan', 'age': '18'}
——delattr——item:age
<class 'str'>
{'name': 'xuyuanyuan'}
----> from getattr:你找的属性不存在
总结：
obj点的方式去操作属性时触发的方法
__getattr__:obj.属性 不存在时触发
__setattr__:obj.属性=属性的值 时触发
__delattr__:del obj.属性 时触发
四 、二次加工标准类型(包装)
示例，如果是用继承的方法实现二次加工
# #基于继承的原理，来定制自己的数据类型（继承标准类型）
# 定制自己的append：只能向列表加入字符串类型的值
class List(list):
def append(self,p_obiect):
if not isinstance(p_obiect,str):#判断加入的是否是字符串的，如果不是字符串的话，则会报错
raise TypeError("must be str")#报错，提示必须是字符串
else:
super().append(p_obiect)#将加入的字符串加入到超父类list内
l=List([1,2,3,4])
l.append("hello")
print(l)
执行结果是：
[1, 2, 3, 4, 'hello']
授权：授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有产品的功能。其它的则保持原样。授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性。
1、通过触发__getattr__方法
示例：
# 定制显示列表中间那个值的属性
class List:
def __init__(self,list=[1,2,3,4]):
self.list=list
def append(self, p_obiect):
if not isinstance(p_obiect, int): # 判断加入的是否是字符串的，如果不是字符串的话，则会报错
raise TypeError("must be int") # 报错，提示必须是字符串
else:
self.list.append(p_obiect) # 将加入的字符串加入到超父类list内
@property#装饰器功能，search=property（search）相当于调用了property函数
def search(self):
print(self.list[len(self.list)//2],type(self.list[len(self.list)//2]))
def __getattr__(self, item):#属性不存在时则会触发运行
print("你找的属性不存在")
l=List()
print(l.list)
l.append(5)
print(l.list)
# 没加@property的话，则需要c.search（）调用
# 加了@property装饰器的话，可直接当做属性调用c.search
l.search#可直接当做属性调用
# print(f.read())
l.pop#当调用没有的属性时，则会触发__getattr__的运行
执行结果是：
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
3 <class 'int'>
你找的属性不存在