一、反射
最近接触到python的反射机制，遂记录下来已巩固。但是，笔者也是粗略的使用了__import__, getattr()函数而已。目前，笔者的理解是，反射可以使用户通过自定义输入来导入响应的module、class等。下面以一个例子说明。
文件目录如下，
reflection文件夹下有Car module，现在main.py下通过反射机制导入Car module.
Car.py源码如下：
class Car(object):
def __init__(self, name, color, tire, engine):
self.name = name
self.color = color
self.tire = tire
self.__engine = engine
def run(self):
print '{} runs at the street.'.format(self.name)
def stop(self):
print '{} stops running.'.format(self.name) class Audi(Car):
def __init__(self, name, color, tire, engine):
super(Audi, self).__init__(name, color, tire, engine)
main.py源码如下：
#from reflection import Car
#from reflection.Car import * string = raw_input('Please input import module(xxx/xxx):')
path = string.split('/')
namespace = __import__('reflection.'+path[0])
module = getattr(namespace, path[1])
Audi = getattr(module, 'Audi')
print namespace
print module
print Audi my_audi = Audi('A7', 'red', 4, 'wolun')
my_audi.run()
首先，main中1,2行是一般的导入模式。然后，让用户输入需导入的模块(字符串)，通过__import__函数导入module，通过getattr()函数得到module的class，方法等。运行main.py，输入Car/Car，意在导入module Car。运行结果如下，
Please input import module(xxx/xxx):Car/Car
<module 'reflection' from 'f:\Python\Wing\reflection\reflection\__init__.pyc'> #print namespace
<module 'reflection.Car' from 'f:\Python\Wing\reflection\reflection\Car.py'> #print module
<class 'reflection.Car.Audi'> #print Audi
A7 runs at the street.
输出结果很清楚的显示了__import__,getattr()的功能。对于反射机制，笔者也是简单的了解到这些。
二、super
关于super,首先要注意的是，super并非是一个函数，而是一个类（PySuper_Type）。在bltinmodule.c中有这么一条语句：
SETBUILTIN("super", &PySuper_Type);
然后，在python documention中有这样一段描述：
Return a proxy object that delegates method calls to a parent or sibling class of type. This is useful for accessing inherited methods that have been overridden in a class. The search order is same as that used by getattr() except that the type itself is skipped. The __mro__ attribute of the type lists the method resolution search order used by both getattr() and super(). The attribute is dynamic and can c hange whenever the inheritance hierarchy is updated. If the second argument is omitted, the super object returned is unbound. If the second argument is an object, isinstance(obj, type) must be true. If the second argument is a type, issubclass(type2, type) must be true (this is useful for classmethods).
下面，以一个例子来简单说明super是如何实现多继承的。
class A(object):
def __init__(self):
print "enter A"
super(A, self).__init__() # new
print "leave A" class B(object):
def __init__(self):
print "enter B"
super(B, self).__init__() # new
print "leave B" class C(A):
def __init__(self):
print "enter C"
super(C, self).__init__()
print "leave C" class D(A):
def __init__(self):
print "enter D"
super(D, self).__init__()
print "leave D"
class E(B, C):
def __init__(self):
print "enter E"
super(E, self).__init__() # change
print "leave E" class F(E, D):
def __init__(self):
print "enter F"
super(F, self).__init__() # change
print "leave F" >>> f = F() enter F
enter E
enter B
enter C
enter D
enter A
leave A
leave D
leave C
leave B
leave E
leave F
可以清楚的看到，F的初始化不仅完成了所有的父类的调用，而且保证了每一个父类的初始化函数只调用一次。关于深度探索super的用法，下面两篇文章值得推荐。
http://www.jb51.net/article/66912.htm
https://rhettinger.wordpress.com/2011/05/26/super-considered-super/
三、装饰器
1、对带参数的函数进行装饰
def deco(func):
def _deco(a, b):
print("before myfunc() called.")
ret = func(a, b)
print(" after myfunc() called. result: %s" % ret)
return ret
return _deco @deco
def myfunc(a, b):
print(" myfunc(%s,%s) called." % (a, b))
return a + b myfunc(1, 2)
myfunc(3, 4)
2、对参数数量不确定的函数进行装饰
def deco(func):
def _deco(*args, **kwargs):
print("before %s called." % func.__name__)
ret = func(*args, **kwargs)
print(" after %s called. result: %s" % (func.__name__, ret))
return ret
return _deco @deco
def myfunc(a, b):
print(" myfunc(%s,%s) called." % (a, b))
return a+b @deco
def myfunc2(a, b, c):
print(" myfunc2(%s,%s,%s) called." % (a, b, c))
return a+b+c myfunc(1, 2)
myfunc(3, 4)
myfunc2(1, 2, 3)
myfunc2(3, 4, 5)
3、装饰器带参数
def deco(arg):
def _deco(func):
def __deco():
print "before {} called [{}]." .format(func.__name__, arg)
func()
print " after {} called [{}].".format(func.__name__, arg)
return __deco
return _deco @deco("module1")
def myfunc():
print " myfunc() called." @deco("module2")
def myfunc2():
print " myfunc2() called." myfunc()
myfunc2()
4、装饰器带 类 参数
#! coding = utf-8
class locker:
def __init__(self):
print "locker.__init__() should be not called." @staticmethod
def acquire():
print "locker.acquire() called.（这是静态方法）" @staticmethod
def release():
print " locker.release() called.（不需要对象实例）" def deco(cls):
'''''cls 必须实现acquire和release静态方法'''
def _deco(func):
def __deco():
print "before {} called [{}].".format(func.__name__, cls)
cls.acquire()
try:
return func()
finally:
cls.release()
return __deco
return _deco @deco(locker)
def myfunc():
print " myfunc() called." myfunc()
值得注意的是，类虽然作为了装饰器的参数，但是没有instance，那么__init__()方法不会被执行。
5、装饰器带类参数，并分拆公共类到其他py文件中，同时演示了对一个函数应用多个装饰器
'''
mylocker.py ,prepare for the deco.py
'''
class mylocker:
def __init__(self):
print "mylocker.__init__() called." @staticmethod
def acquire():
print "mylocker.acquire() called." @staticmethod
def unlock():
print " mylocker.unlock() called." class lockerex(mylocker):
@staticmethod
def acquire():
print "lockerex.acquire() called." @staticmethod
def unlock():
print " lockerex.unlock() called." def lockhelper(cls):
'''cls must instance 'acquire' and 'release' static methods'''
def _deco(func):
def __deco2(*args, **kwargs):
print "before {} called." .format(func.__name__)
cls.acquire()
try:
return func(*args, **kwargs)
finally:
cls.unlock()
return __deco2
return _deco
'''
deco.py
装饰器带类参数，并分拆公共类到其他py文件(mylocker.py)中
同时演示了对一个函数应用多个装饰器
''' from mylocker import * class example:
@lockhelper(mylocker)
def myfunc(self):
print " myfunc() called." @lockhelper(mylocker)
@lockhelper(lockerex)
def myfunc2(self, a, b):
print " myfunc2() called."
return a + b if __name__=="__main__":
a = example()
#a.myfunc()
#print '---------------------------------------------------------'
#print a.myfunc()
#print '---------------------------------------------------------'
#print a.myfunc2(1, 2)
#print '---------------------------------------------------------'
print a.myfunc2(3, 4)
不过，注意到这段程序的输出：
before __deco2 called.
mylocker.acquire() called.
before myfunc2 called.
lockerex.acquire() called.
myfunc2() called.
lockerex.unlock() called.
mylocker.unlock() called.
7
为什么有“before __deco2__ called”??这段输出给我的感觉就是，mylocker装饰了__deco2(),而lockerex装饰了myfunc2().是这样理解的么？？
四、pickle & json
pickle & json 都可以存储数据到硬盘，供程序交互。不过，pickle是python特有的，json可以为不同语言所共有。所以，json用得更普遍。下面这个例子分别用pickle，json 来dump，load & dumps，loads 数据。
import pickle
import json mydict = {'name': 'python', 'age': 27, 'height': 178, 'weight': 140}
#pickle dumps, loads
res = pickle.dumps(mydict)
print res
loadres = pickle.loads(res)
print loadres
print '----------------------------------------------------------'
#pickle dump,load
pickle.dump(mydict, open('C:\Users\Administrator\Desktop\jason.txt', mode='w'))
loadres = pickle.load(open('C:\Users\Administrator\Desktop\jason.txt', mode='r'))
print loadres
print '----------------------------------------------------------'
#json dumps,loads
jsonres = json.dumps(mydict, skipkeys=False, ensure_ascii=True,
check_circular=True, allow_nan=True,
cls=None, indent=None,
separators=None, encoding='utf-8',
default=None)
print jsonres
load_json_res = json.loads(jsonres, encoding=None, cls=None, object_hook=None,
parse_float=None,
parse_int=None,
parse_constant=None,
object_pairs_hook=None)
print load_json_res
print '----------------------------------------------------------'
#json dump,load
json.dump(mydict, open('C:\Users\Administrator\Desktop\jason.txt', mode='w'), skipkeys=False, ensure_ascii=True, check_circular=True,
allow_nan=True, cls=None, indent=None, separators=None,
encoding='utf-8', default=None)
fileres = json.load(open('C:\Users\Administrator\Desktop\jason.txt', 'r'), encoding=None, cls=None, object_hook=None,
parse_float=None, parse_int=None,
parse_constant=None,
object_pairs_hook=None)
print fileres
五、接口
在类的定义中用abc.ABCMeta作为metaclass写自己的抽象基类。示例代码如下：
from abc import ABCMeta, abstractmethod
class interface(object): #这里填不填object????
__metaclass__ = ABCMeta @abstractmethod
def show(self):
pass class Fighting(interface):
def __init__(self, message):
self.message = message def show(self):
Fighting.mystatic()
print 'overwrite the function of show in interface'
def __str__(self):
return self.message
@staticmethod
def mystatic():
print 'call static method in class' class MyException(Exception):
def __init__(self, message):
self.message = message
def __str__(self):
return self.message try:
input_message = raw_input('Please input the fighting message:')
f = Fighting(input_message)
print f
f.show()
string = f.__str__()
if 'Any questions?' == string:
raise MyException("No thanks!")
else:
print 'You are a good man.'
except MyException, e :
print e
finally:
print 'finally must be called.'
更多关于abc module，在python documention中讲解的很清楚。abc.ABCMeta，abc.abstractmethod，abc.abstractproperty等...
六、property
property，笔者理解为class的一个特性吧。先以一段示例程序，看看property是如何工作的。
class Car(object):
company = 'aodi'
__engine = 'wolunzengya'
def __init__(self, name, color, style):
self.name = name
self.color = color
self.__style = style
def start(self):
print self.name + ' run the road.'
def stop(self):
print self.name + ' stop the engine.'
@staticmethod
def engine():
print 'we all have engines.'
@property
def Car_company(self):
print 'Our company is {},engine is {} '.format(Car.company, Car.__engine)
def __changeEngine():
Car.__engine = 'shuangwolunzengya'
@property
def style(self):
return self.__style
@style.setter
def style(self, value):
self.__style = value
@property
def haha(self):
return self.color
def __call__(self):
print '{}\'s call method is called.'.format(self.name)
aodi_a6 = Car('a6', 'white', 'tesila')
print aodi_a6.style
aodi_a6.style = 'bujiadi'
print aodi_a6.style
print
print aodi_a6.haha #notian that the function 'haha' has no parathinese'()'
aodi_a6.haha = 'red' #tips: 新式类不可以在这里赋值，旧式类可以
print aodi_a6.haha
aodi_a6()
在上述程序中，如果Car(object)为新式类，将会产生AttributeError: can't set attribute.产生这个错误的语句在：aodi_a6.haha = 'red'。。如果使用新式类，就要使用@XXX.setter 标记函数，达到赋值效果。如程序中的style方法：
@property
def style(self):
return self.__style
@style.setter
def style(self, value):
self.__style = value
再提一下，调用@property修饰的方法，不加()。
静下心来博客，也理清了自己的思路，坚持~