一、isinstance(obj,cls)和issubclass(sub,super)
1、isinstance(obj,cls)检查obj是否是类 cls 的对象
class A:
pass
obj = A() #实例化对象obj
isinstance(对象名，类名）#语法
print(isinstance(obj,A)) #isinstance函数返回的是布尔值，True，则obj，是A产生的对象
print(isinstance(object,A)) #同上，反之，为不是。
---------------输出结果-------------------
True
False
2、issubclass(sub, super)检查sub类是否是 super 类的派生类或子类
class A: #定义父类
pass
class B(A): #定义子类，继承A
pass
issubclass(子类名，父类名) #语法
print(issubclass(B,A)) #返回的也是布尔值，True为真，则B,是A的子类，反之，不是
-------------输出结果------------------
True
二、反射
1、什么是反射：
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自
省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp
和面向对象方面取得了成绩。
2、反射的简单含义：
1、通过类名获得类的实例对象
2、通过方法名得到方法，实现调用
3、python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用
反射）。
反射即想到4个内置函数分别为:hasattr、getattr、setattr、delattr 获取成员、检查成员、设置成员、删除成员下面
逐一介绍先看例子：
class motorcycle: #仅限二轮摩托
feature = "两个轱辘" #相对而言
def __init__(self,brand,price):
self.brand = brand
self.price = price
def advance(self): #都有前进的技能
print("%s,出发了！"%self.brand)
def stop(self): #都有减速，停车功能
print("%s,减速了！"%self.brand)
m1 = motorcycle("春风",28800) #实例化对象m1
3.1、hasattr(obj,"name")：检测obj里是否含有"name"属性
#检测是否含有某属性 print(hasattr(m1,"feature")) #检测对象m1是否有类的数据属性 print(hasattr(m1,"brand")) #检测m1里是否有"brand"这个数据属性 print(hasattr(m1,"advance")) #检测m1里是否有"advance"这个绑定方法 print(hasattr(motorcycle,"feature")) #一切皆对象，加测类里面是否有"feature"这个数据属性 print(hasattr(motorcycle,"stop")) #一切皆对象，检测类里面是否有"stop"这个函数属性 print(hasattr(m1,"abcd")) #检测到没有这个"abcd"的时候，此时，会返回False ----------------------输出结果------------------- True True True True True False
3.2、getattr(obj,"name")：获取obj里的"name"的属性
#获取某属性 n = getattr(m1,"brand") #获取m1的品牌属性，并赋值给n print(n) #打印n n1 = getattr(motorcycle,"feature") #一切皆对象，获取类的数据属性，并赋值给n1 print(n1) #打印n1 n2 = getattr(m1,"feature") #获取对象m1的类的特征，并赋值给n2 print(n2) #打印n2 n3 = getattr(m1,"advance") #获取m1的绑定方法，并赋值给n3 n3() #现在n3就是m1的绑定方法，加括号就能调用 n4 = getattr(motorcycle,"stop") #获取类的函数属性，并赋值给n4 n4(m1) #因为n4是类的函数属性，so，调用的时候要传参 #getattr(m1,"abcd") #没有abcd"会报错 print(getattr(m1,"abcd","不存在啊！")) #没有"abcd"会打印后面的字符串 -----------------输出结果-------------------- 春风 两个轱辘 两个轱辘 春风,出发了！ 春风,减速了！ 不存在啊！
3.3、setattr(obj,"name",content)：设置obj里的"name"的属性
#设置某属性
setattr(m1,"displacement",650) #新增m1的"displacement"数据属性
setattr(m1,"show_brand",lambda self: self.brand+"666") #新增m1的函数属性
setattr(m1,"price",26800) #春风做活动，回馈车友，减价2000，修改m1的价格
setattr(motorcycle,"show_brand",lambda self:self.brand+"666") #新增类的函数属性
setattr(motorcycle,"feature","两个轱辘,还有三个轱辘的") #修改类的特征
print(m1.show_brand(m1)) #注意，此时"show_brand"就是一个普通函数，需要传一个参数进去
print(motorcycle.show_brand(m1)) #类名.新增的函数名加括号调用，因为是函数属性，so，要传参
print(m1.__dict__) #打印对象m1的所有的属性
print(motorcycle.__dict__) #打印类motorcycle的所有的属性
-------------------输出结果--------------------------
春风666
春风666
{'brand': '春风', 'price': 26800, 'displacement': 650, 'show_brand':
<function <lambda> at 0x0000000002113E18>}
{'__module__': '__main__', 'feature': '两个轱辘,还有三个轱辘的',
'__init__': <function motorcycle.__init__ at 0x00000000025FA950>,
'advance': <function motorcycle.advance at 0x00000000025FA9D8>,
'stop': <function motorcycle.stop at 0x00000000025FAA60>, '__dict__':
<attribute '__dict__' of 'motorcycle' objects>, '__weakref__': <attribute
'__weakref__' of 'motorcycle' objects>, '__doc__': None, 'show_brand':
<function <lambda> at 0x00000000025FAAE8>}
3.4、delattr(obj,"name")：删除obj里的"name"的属性
#删除某属性
delattr(m1,"displacement") #删除m1的"displacement"数据属性
delattr(m1,"show_brand") #删除m1的"show_brand"的函数属性
delattr(motorcycle,"show_brand") #删除类的函数属性
print(m1.__dict__) #打印对象m1的所有的属性
print(motorcycle.__dict__) #打印类motorcycle的所有的属性
--------------------输出结果-------------------------
{'brand': '春风', 'price': 28800}
{'__module__': '__main__', 'feature': '两个轱辘', '__init__':
<function motorcycle.__init__ at 0x000000000291A950>,
'advance': <function motorcycle.advance at 0x000000000291A9D8>,
'stop': <function motorcycle.stop at 0x000000000291AA60>,
'__dict__': <attribute '__dict__' of 'motorcycle' objects>,
'__weakref__': <attribute '__weakref__' of 'motorcycle' objects>,
'__doc__': None}
4、为什么用反射之反射的好处
好处一：实现可插拔机制
可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思
？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能。
#类代码同上
if hasattr(m1,"advance"): #判断m1里是否含有"advance"属性，有就执行里面的代码
func = getattr(m1,"advance") #有就实现此行代码，这样就不会出现异常，将获取到的内存地址给func
func() #调用次方法
print("继续其他逻辑") #就算没有也不会影响下面代码的执行，实现了可插拔机制
--------------------输出结果---------------------
春风,出发了！
继续其他逻辑
好处二：动态导入模块（基于反射当前模块成员）
#模块（mokuai）的内容：
x = 123 #变量x
class A: #定义一个类
def aaa(self): #类A的函数属性aaa
print("from aaa")
def bbb(): #定义一个函数bbb
print("from bbb")
动态导入模块：
import importlib
this_module = importlib.import_module("mokuai")
#语法就是this_module.属性名
print(this_module.x) #打印模块里变量x的值，
a = this_module.A() #类A实例化对象a
a.aaa() #对象a调用绑定方法
this_module.bbb() #调用函数bbb
----------------输出结果--------------------
123
from aaa
from bbb
三、__setattr__,__getattr__,__delattr__
class foo:
def __init__(self,name):
self.name = name
def __setattr__(self, key, value): #添加/修改属性时，会触发它的执行
if not isinstance(value,str):
raise TypeError("must be str")
#self.key = value #注意：这样就无限递归了
self.__dict__[key] = value
def __getattr__(self, item): #当属性不存在的时候，会触发它的执行
print("不存在----->%s"%item)
def __delattr__(self, item): #删除属性时，会触发它的执行
# print("不能被删除！") #强制不让删除
#del self.item #注意：这样就无限递归了
self.__dict__.pop(item) #真正删除的方法
f1 = foo("michael") # 实例化对象f1
#调用__setattr__
print(f1.__dict__) #打印f1的属性字典
f1.age = "18" #"18"必须是str，赋值就会触发__setattr__的执行
print(f1.__dict__) #打印f1的属性字典
#调用__getattr__
print(f1.abcd) #此时abcd是不存在的，没有这个属性，会返回None
#调用__delattr__
del f1.age #删除属性
print(f1.__dict__) #打印f1的属性字典
-------------------输出结果-----------------------
{'name': 'michael'}
{'name': 'michael', 'age': '18'}
不存在----->abcd
None
{'name': 'michael'}
四、二次加工标准类型（包装）
包装：python为大家提供了标准数据类型，以及丰富的内置方法，其实在很多场景下我们都需要基于标准数据类型
来定制我们自己的数据类型，新增/改写方法，这就用到了我们刚学的继承/派生知识（其他的标准类型均可以通过下面的
方式进行二次加工）。
#基于继承的原理，来定制自己的数据类型（继承标准类型）
class List(list): #继承list所有的属性，也可以派生出自己新的，比如append和insert
def append(self, p_object): #自己加工追加的方法
if not isinstance(p_object,int): #加上条件，不是int就抛出异常
raise TypeError("must be int") #返回提示输入类型
#self.append(p_object) #注意：这样就无限递归了
super().append(p_object) #此时才会完成追加
def insert(self, index, p_object): #自己加工指定位置插入的方法
if not isinstance(p_object,int): #加上条件，不是int就抛出异常
raise TypeError("must be int") #返回提示输入类型
super().insert(index,p_object) #此时才会完成插入
l1 = List([0,1,2]) #实例化对象l1
print(l1) #打印列表l1
l1.append(3) #对象l1追加元素3，注意必须是int
print(l1) #打印列表l1
# l1.append("5") #此时会抛出异常，"5"不是int
l1.insert(0,-1) #在下标0的位置，插入元素-1，注意元素的类型
l1.insert(5,4) #在下标5的位置，插入元素4，注意元素的类型
print(l1) #打印列表l1
print(l1.index(4)) #获取元素的下标，没有派生出自己的方法的时候，会继承父类的方法
--------------------输出结果------------------------
[0, 1, 2]
[0, 1, 2, 3]
[-1, 0, 1, 2, 3, 4]
5
授权：授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有
产品的功能。其它的则保持原样。授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给
对象的默认属性。
实现授权的关键点就是覆盖__getattr__方法。
import time
class Open: #open是一个函数，不是类，不能用继承，so，用另一种方式：授权
def __init__(self,file_path,m="r",endoce="utf8"):
self.file = open(file_path,mode=m,encoding=endoce) #获取文件句柄
self.file_path = file_path #文件路径
self.mode = m #文件打开模式
self.encoding = endoce #文件的编码方式
def write(self,line): #写入文件
t = time.strftime("%Y-%m-%d %X") #获取时间格式
self.file.write("%s ---> %s"%(t,line)) #前面加上时间，按格式写入
def __getattr__(self, item): #当方法不存在的时候，会触发它的执行
return getattr(self.file,item) #获取文件其他的方法，并返回给对象
f1 = Open("a.txt","w") #实例化对象f1，创建文件a.txt,以w模式
f1.write("1、你好，我摩旅去了!
") #按自己加工的方法写入内容
f1.write("2、你好，我摩旅去了!
") #按自己加工的方法写入内容
f1.write("3、你好，我摩旅去了!
") #按自己加工的方法写入内容
f1.close() #关闭文件
f2 = Open("a.txt","r") #实例化对象f2，查看文件a.txt，以r模式
print(f2.read()) #打印输出a.txt的文件内容
f2.seek(0) #刚看完，光标走到最后位置了。要想再看，就得把光标调到最开始位置
print("-->：",f2.read()) #加上标识，再看一遍
f2.close() #关闭文件
-----------------输出结果------------------
2017-04-24 18:30:57 ---> 1、你好，我摩旅去了!
2017-04-24 18:30:57 ---> 2、你好，我摩旅去了!
2017-04-24 18:30:57 ---> 3、你好，我摩旅去了!
-->： 2017-04-24 18:30:57 ---> 1、你好，我摩旅去了!
2017-04-24 18:30:57 ---> 2、你好，我摩旅去了!
2017-04-24 18:30:57 ---> 3、你好，我摩旅去了!
授权小练习：
#要求：
# 基于授权定制自己的列表类型，要求定制的自己的__init__方法，
# 定制自己的append：只能向列表加入字符串类型的值
# 定制显示列表中间那个值的属性（提示：property）
# 其余方法都使用list默认的（提示：__getattr__加反射）
class list: #定义一个类list
def __init__(self,li):
self.li = li
def append(self,value): #自己加工追加的方法
if not isinstance(value,str): #加上条件，不是str就抛出异常
raise TypeError("must be str") #返回提示输入类型
self.li.append(value) #追加到列表中
@property
def pro(self): #加上装饰器的pro，获取属性
index = len(self.li)//2 #获取列表中间的索引
return self.li[index] #返回中间的元素
def __getattr__(self, item): #当方法不存在的时候，会触发它的执行
return getattr(self.li,item) #获取列表其他的方法，并返回给对象
l1 = list([1,2,3]) #实例化对象l1，新建列表
print(l1.li) #查看列表的内容
# l1.append(4) #此时会抛出异常，因为不是str类型
l1.append("4") #往l1列表追加内容
print(l1.li) #打印追加后的列表
print(l1.pro) #pro加property后，调用不用加括号了，跟获取数据属性一样
print(l1.index(2)) #自己没有定义的方法，会触发__getattr__,使用list其
他的方法，这里查看元素2的索引是多少
---------------------输出结果---------------------
[1, 2, 3]
[1, 2, 3, '4']
3
1