本文共 12712 字，大约阅读时间需要 42 分钟。
@(python)[笔记]
一、isinstance()和issubclass() 1. isinstance() 2. issubclass()二、反射 1. hasattr() 2. getattr() 3. setattr() 4. delattr() 5. 扩展用法三、__setattr__、__delattr__、__getattr__四、二次加工标准类型（包装） 授权五、__next__和__iter__实现迭代器协议六、__doc__七、__module__和__class__八、__str__九、__del__析构方法十、__setitem__,__getitem__,__delitem__十一、__enter__和__exit__十二、__call__十三、元类metaclass 先来看看exec 未完
语法：isinstance(obj,cls)
class foo: passobj = foo()print(isinstance(obj,foo)) #True
语法：issubclass(sub, super)
class foo: passobj = foo()print(isinstance(obj,foo)) #Trueclass bar(foo): passprint(issubclass(bar,foo)) #True
反射主要是指程序可以访问、检测和修改它本身状态或行为的一种能力，也可以称为自省。
python面向对象中的反射是指通过字符串的形式操作对象相关的属性。python中的一切事物都是对象，都可以使用反射。
python中可以实现自省的四个函数：
下列方法适用于类和对象（一切皆对象，类本身也是一个对象）
语法：hasattr(object,"name")
class foo: name = "egon" passobj = foo()print(hasattr(obj,"name")) #Trueprint(hasattr(obj,"func")) #Trueprint(hasattr(foo,"name")) #Trueprint(hasattr(foo,"func")) #True
语法：getattr(object, "name"[, default=None])
getattr(object,"name")等价于object.name class foo: name = "egon" def func(self): print("Hello world")obj = foo()print(getattr(obj,"func")) # > #可以看出，输出结果是一个绑定方法f1 = getattr(obj,"func")f2 = getattr(obj,"bar","不存在")f1() #Hello worldprint(f2) #不存在 语法：setattr(x, y, v)
setattr（x，'y'，v）等价于“x.y = v” 用法： class foo: name = "egon" def func(self): print("Hello world")obj = foo()setattr(obj,"age",20)setattr(obj,"show_name",lambda self:self.name+"_NB")print(obj.__dict__) #查看属性字典print(obj.show_name(obj))'''输出：{'age': 20, 'show_name': at 0x000000000115E2F0>}egon_NB''' 语法：delattr(x, y)
功能：删除属性,delattr（x，'y'）相当于```del x.y`'' 用法： delattr(obj,"show_name")# delattr(obj,"sex") #不存在，则报错print(obj.__dict__) #{'age': 20} 反射当前模块
import sysdef s1(): print("s1")def s2(): print("s2")this_module = sys.modules[__name__]print(hasattr(this_module,"s1")) #Trueprint(getattr(this_module,"s2")) # ,加括号可执行 导入其他模块，利用反射查找该模块是否存在某个方法
程序目录：# module_test.pydef test(): print("from the module_test.test") #current.pyimport module_test as mtprint(hasattr(mt,"test")) #Truef = getattr(mt,"test","不存在")f() #from the module_test.test
__setattr__、__delattr__、__getattr__ __setattr__ ：添加/修改属性会触发它的执行；
__delattr__ ：删除属性的时候会触发；__getattr__ ：只有在使用点调用属性且属性不存在的时候才会触发。 class Foo: x = 1 def __init__(self,y): self.y = y def __getattr__(self, item): print("---> 你找的属性不存在") def __setattr__(self, key, value): print("---> from __setattr__") # self.key = value #这样会陷入无限递归，只能通过__dict__字典进行赋值 self.__dict__[key] = value #这样才可以正确赋值 def __delattr__(self, item): print("---> from __delattr__")f1 = Foo(10) #相当于设值，触发__setattr__执行，---> from __setattr__print(f1.__dict__) #{}，直接打印为空，是因为你自己重写了__setattr__方法， # 而你在__setattr__方法中没有真正赋值f1.z #触发__getattr__执行，---> 你找的属性不存在del f1.x #触发__delattr__执行，---> from __delattr__ 包装：python为用户提供了标准数据类型，以及丰富的内置方法，其在很多场景下，我们需要基于标准数据类型来定制我们自己的数据类型，新增 / 改写方法，这就用到继承和派生的知识，其他标准类型均可以通过下面的方式进行二次加工。
示例1：对list进行二次加工，限制append只能增加int整型数据；并且增加mid方法，得到列表的中间值；其余方法都继承list的。
class List(list): def append(self,p_object): #派生出自己的append方法，会覆盖父类list中的append方法 if not isinstance(p_object,int): raise TypeError("%s must be int"%p_object) super(List, self).append(p_object) @property #中间值听起来更像一个属性，而非方法，所以使用property def mid(self): mid_num = len(self) // 2 return self[mid_num]l = List([1,2,3,4])print(l) #[1, 2, 3, 4]l.append(5)print(l) #[1, 2, 3, 4, 5]print(l.mid) #中间值3 示例二：为list的clear方法增加权限
class List(list): def __init__(self,item,perm=False): super(List, self).__init__(item) self.perm = perm #先设定一个默认的权限 def clear(self): if not self.perm: raise PermissionError("权限拒绝") super(List, self).clear()l = List([1,2,3])print(l) #[1, 2, 3]# l.clear() #抛出“权限拒绝”的异常l = List([1,2,3],True) #给一个授权参数为Truel.clear()print(l) #[]，可以正常清空列表 授权是包装的一个特性，包装一个类型通常是对已存在的类型的一些定制，这种做法可以新建、修改或删除原有产品的功能，其它的则保持原样。授权的过程就是所有更新的功能都是由新类的某部分来处理，但已存在的功能就授权给对象的默认属性。
实现授权的关键点就是覆盖__getattr__方法
示例三：利用open()函数重新定制一个文件处理器，增加写内容添加时间的功能；
import timeclass FileHandler: def __init__(self,filename,mode='r',encoding="utf-8"): self.file = open(filename,mode,encoding=encoding) #self.file获取到一个文件句柄 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) #当对象调用FileHandler类不存在的方法时，会返回open()函数的item字符串对应的方法； f1 = FileHandler("a.txt","r+")f1.write("你好吗\n")f1.seek(0)print(f1.tell()) #0 示例四：
#我们来加上b模式支持import timeclass FileHandle: def __init__(self,filename,mode='r',encoding='utf-8'): if 'b' in mode: self.file=open(filename,mode) else: self.file=open(filename,mode,encoding=encoding) self.filename=filename self.mode=mode self.encoding=encoding def write(self,line): if 'b' in self.mode: if not isinstance(line,bytes): raise TypeError('must be bytes') self.file.write(line) def __getattr__(self, item): return getattr(self.file,item) def __str__(self): if 'b' in self.mode: res="<_io.BufferedReader name='%s'>" %self.filename else: res="<_io.TextIOWrapper name='%s' mode='%s' encoding='%s'>" %(self.filename,self.mode,self.encoding) return resf1=FileHandle('b.txt','wb')# f1.write('你好啊啊啊啊啊') #自定制的write,不用在进行encode转成二进制去写了,简单,大气f1.write('你好啊'.encode('utf-8'))print(f1)f1.close() 示例五：利用授权的方式重新定制list的append方法，只能往列表中添加int整型数据；与示例一作对比，看一下两者的区别。
#授权，定制listclass List: def __init__(self,seq): self.seq = list(seq) def append(self,p_object): if not isinstance(p_object,int): raise TypeError("'%s' must be int"%p_object) self.seq.append(p_object) def __getattr__(self, item): return getattr(self.seq,item) def __str__(self): return str(self.seq)l = List([1,2,3])l.append("4") #TypeError: '4' must be intprint(l) 总结：授权这种方式用在定制源不是类的情况下。例如示例三中，定制
open()函数
__next__和__iter__实现迭代器协议迭代器必须要有__next__和__iter__方法；
class Foo: def __init__(self,x): self.x=x def __iter__(self): return self def __next__(self): n=self.x self.x+=1 return self.xf=Foo(3)for i in f: print(i)
模拟实现range()函数：
class foo: def __init__(self,start,stop=None,step=1): self.start = start self.stop = stop self.step = step if isinstance(self.start,str) \ or isinstance(self.stop,str) \ or isinstance(self.step,str): raise InterruptedError("Must be Numeric") def __next__(self): if self.stop: res = self.compute() else: self.stop = self.start # 如果只传了一个数字,则将其设为迭代停止数字 self.start = 0 # 如果只传了一个数字，则默认从0开始迭代 res = self.compute() return res def __iter__(self): return self #迭代器执行__iter__方法，返回的是它本身 def compute(self): if self.start >= self.stop: #判断是否超出迭代停止数字 raise StopIteration # 这是超出迭代器范围后迭代器协议规定的抛出异常 iter_val = self.start #迭代后的值 self.start += self.step return iter_valfor i in foo('a',20,3.5): print(i)for i in foo(5,15,3): print(i) __doc__ 查看对象的描述信息
def func(): '''我是函数的描述信息''' passprint(func.__doc__)class Foo: '''我是类的描述信息''' passclass bar(Foo): passobj = Foo()print(obj.__doc__)print(Foo.__doc__)print(bar.__doc__) #该属性不会继承给子类'''输出：我是函数的描述信息我是类的描述信息我是类的描述信息None'''
__module__和__class__ __module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
以下两个文件在同一级目录下：
#current.pyclass C: def __init__(self): self.name = "alex"
#test.pyimport currentdef test(): print("from the test.test")obj = current.C()print(obj.name)print(obj.__class__) #输出是哪个类实例化得到的对象print(obj.__module__) #输出属性哪个模块'''输出：alex current''' __str__ l = list([1,2,3])print(l) #打印的是[1, 2, 3]
class mysql: def __init__(self,host,port): self.host = host self.port = portconn = mysql("127.0.0.1","3306")print(conn) #打印的是<__main__.mysql object at 0x0000000000701898> 从以上两段代码可以看到，我们自己定义的类，生成的对象直接被打印时，打印的是对象的内存地址，而这并不是我们想要的，我们实际想要的也是像第一段代码那样返回一个有用的信息，这时就要用到__str__这个内置方法了，它定义在类的内部，只要类被实例化，就会自动触发__str__的执行，并返回一个值给实例化后的对象。如下示例：
class mysql: def __init__(self,host,port): self.host = host self.port = port def __str__(self): return "Host:%s,Port:%s"%(self.host,self.port)conn = mysql("127.0.0.1","3306")#会将`__str__`方法的返回值赋值给对象connprint(conn) '''输出：Host:127.0.0.1,Port:3306''' __del__析构方法析构方法，当对象在内存中被释放时，会自动触发__del__执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
简单示例：
class Foo: def __del__(self): print("执行__del__")f1 = Foo()del f1 #释放f1，会触发__del__执行print("------->")'''输出：执行__del__------->''' 再看看下面这种情况：
class Foo: def __del__(self): print("执行__del__")f1 = Foo()# del f1 #注释掉print("------->")'''输出：------->执行__del__'''#可以看出__del__仍然会在程序执行完毕后，被触发执行 __setitem__,__getitem__,__delitem__ 类中有这三个方法，那就意味着类中的属性可以像字典一样进行操作；
class Foo: def __init__(self,name): self.name = name def __getitem__(self, item): print("from __getitem__") def __setitem__(self, key, value): print("from __setitem__") self.__dict__[key] = value #加入此代码，才会真正设值 def __delitem__(self, key): print("from __delitem__") self.__dict__.pop(key)f1 = Foo("egon")# f1.age = 18 #不会触发__setitem__的执行f1["age_2"] = 20 #会触发__setitem__的执行，并不会真正设值；print(f1.__dict__)del f1["age_2"]print(f1.__dict__)print(f1["name"]) #会触发__getitem__执行，如果__getitem__没有设定返回值，则会返回一个None'''输出结果：from __setitem__{'name': 'egon', 'age_2': 20}from __delitem__{'name': 'egon'}from __getitem__None'''#从结果可以看出，age_2 = 20并没有真正设值成功 __enter__和__exit__ 通过__enter__和__exit__这两个方法可以实现上下文件管理协议，即with语句。为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法。
class Open: def __init__(self,name): self.name = name def __enter__(self): #出现with语句，对象的__enter__方法就会被触发，有返回值则赋值给as声明的变量 print("from __enter__") return 3 #会返回给as语句后面的变量 def __exit__(self, exc_type, exc_val, exc_tb): print("from __exit__, with代码块执行完毕时触发")with Open("egon") as f: print("from with 代码块") print("f:",f)'''输出：from __enter__from with 代码块f: 3from __exit__, with代码块执行完毕时触发''' __exit__(self, exc_type, exc_val, exc_tb)中的三个参数的含义：
exc_type 代表异常类型exc_val 代表异常值exc_tb 代表异常的追溯信息class Open: def __init__(self,name): self.name = name def __enter__(self): #出现with语句，对象的__enter__方法就会被触发，有返回值则赋值给as声明的变量 # print("from __enter__") return self #会返回给as语句后面的变量 def __exit__(self, exc_type, exc_val, exc_tb): print("from __exit__, with代码块执行完毕时触发") print("exc_type:",exc_type) print("exc_val:",exc_val) print("exc_tb:",exc_tb) return True #返回True,则表示不抛出异常，with代码之后的代码可正常执行，但with子代码raise后的代码不会执行。with Open("egon") as f: print("from with 代码块") raise AttributeError("属性错误") # print("=====> 在异常之后") #不会执行print("=====> 在异常之后，with之外") #__exit__返回True才会执行'''输出：from with 代码块from __exit__, with代码块执行完毕时触发exc_type: exc_val: 属性错误exc_tb: =====> 在异常之后''' 示例：模拟open()，并实现上下文管理
#模拟open()功能class Open: def __init__(self,filename,mode='r',encoding="utf-8"): self.filename = filename self.mode = mode self.encoding = encoding def __enter__(self): self.file = open(self.filename,self.mode,encoding =self.encoding) return self.file def __exit__(self, exc_type, exc_val, exc_tb): self.file.close() return True #遇到异常不抛出，with之外的代码继续执行with Open("a.txt","w+") as f: f.write("11111\n") f.write("22222\n") f.seek(0) print(f.tell()) f.abc #抛出异常，交给__exit__处理 __call__ 对象后面加括号，就会触发__call__方法的执行；反之类中有了__call__方法，通过这个类生成的对象，才能加括号执行。
class foo: def __init__(self): print("from __init__") def __call__(self, *args, **kwargs): print("from __call__")obj = foo() #执行__init__obj() #执行__call__'''输出：from __init__from __call__''' metaclass exec 转载地址：http://inxqa.baihongyu.com/