首先，我们来看两个内置函数，isinstance和issubclass，前者是判断一个对象是不是相应的类型，比如：
|
1
2
|
obj = 'python'
print(isinstance(obj,str))
|
判断obj是否为字符串类型，结果返回True
后者issubclass则判断一个类是否为另一个的子类，比如：
|
1
2
3
4
5
|
class A:
pass
class B(A):
pass
print(issubclass(B,A))
|
判断B是否为A的子类，结果返回True
反射：其实它的核心本质其实就是利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动！
python的四个重要内置函数：getattr、hasattr、delattr和setattr较为全面的实现了基于字符串的反射机制。他们都是对内存内的模块进行操作，并不会对源文件进行修改。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
import sys
class Commons:
@staticmethod
def login():
print("登录页面")
@staticmethod
def logout():
print("退出页面")
@staticmethod
def home():
print("这是网站主页")
this_moudle = sys.modules[__name__]
def run():
inp = input("请输入想访问页面的URl：").strip()
if hasattr(Commons,inp):
func = getattr(Commons,inp,'没有这个页面')
func()
else:
print("404!")
run() |
从上面的例子可以看到hasattr及getattr的用法，另外还有delattr和setattr方法类似
那么我们为什么要用反射机制呢？
其好处有：
1、实现可插拔机制（对于代码来说），可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能
2、动态导入模块（基于反射当前模块成员）
|
1
2
3
4
5
6
7
8
9
10
11
|
def run():
inp = input("请输入您想访问页面的url： ").strip()
modules, func = inp.split("/")
obj = __import__(modules)
if hasattr(obj, func):
func = getattr(obj, func)
func()
else:
print("404")
run()
|
输入形如：请输入您想访问页面的url： commons/home
执行结果为：这是网站主页
在这，顺便说一下，官方建议用下述的方式进行模块的导入
|
1
2
|
import importlib
importlib.import_module('需要导入的库')
|
接下来我们看看其他几个python内置的函数__getattr__、__setattr__、__delattr__
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
class Foo:
def __init__(self,name):
self.name = name
def __setattr__(self, key, value):
#添加/修改属性会触发它的执行 if isinstance(value,str):
self.__dict__[key] = value
print("__setattr__")
else:
raise TypeError("必须为字符串")
def __getattr__(self, item):
#只有在使用点调用属性且属性不存在的时候才会触发 print("getattr--->%s %s"%(item,type(item)))
def __delattr__(self, item):
#删除属性的时候会触发 self.__dict__.pop(item)
print("__delattr__")
f = Foo('zds')
print(f.name)
f.age = '18'
print(f.age)
del f.age
print(f.__dict__)
print(f.xxxxx)
|
包装与授权
包装：python为大家提供了标准数据类型，以及丰富的内置方法，其实在很多场景下我们都需要基于标准数据类型来定制我们自己的数据类型，新增/改写方法，这就用到了我们刚学的继承/派生知识（其他的标准类型均可以通过下面的方式进行二次加工）
授权：授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有产品的功能。其它的则保持原样。授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性。
实现授权的关键点就是覆盖__getattr__方法
以下示例作为练习：
基于授权定制自己的列表类型，要求定制的自己的__init__方法，
定制自己的append：只能向列表加入字符串类型的值
定制显示列表中间那个值的属性
其余方法都使用list默认的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
class List(list):
def __init__(self,obj):
super().__init__(obj)
def append(self, p_object):
if not isinstance(p_object,str):
raise TypeError("must be str type")
super().append(p_object)
@property
def mid_value(self):
return self[(self.__len__())//2]
def __getattr__(self, item):
if hasattr(List,item):
func = getattr(List,item)
return self.func()
else:
print("没有这个方法")
l = List([1,2,3,4,5,6])
l.append('7')
print(l)
print(l.mid_value)
l.insert(0,9)
print(l)
|
运行结果为：
[1, 2, 3, 4, 5, 6, '7']
4
[9, 1, 2, 3, 4, 5, 6, '7']
本文转自 AltBoy 51CTO博客，原文链接:http://blog.51cto.com/altboy/1918921