Python內省：方法的自動換行

Question

類型A的對象和是否有編程方式包裝類對象的方法？

鑑於

class A(object): 
    def __init__(self): 
     ## .. 

    def f0(self, a): 
     ## ... 

    def f1(self, a, b): 
     ## .. 

我想另一個類封裝了一個A，如

class B(object): 
    def __init__(self): 
     self.a = A() 

    def f0(self,a): 
     try: 
      a.f0(a) 
     except (Exception),ex: 
      ## ... 

    def f1(self, a, b): 
     try: 
      a.f1(a,b) 
     except (Exception),ex: 
      ## ... 

有沒有辦法做到創建A類B.f0 & B.f1通過反射/檢查？

Answer 1

如果你想通過調用預定義類A一個函數來創建B類，你可以簡單地做B = wrap_class(A)與功能wrap_class看起來像這樣：

import copy 

def wrap_class(cls): 
    'Wraps a class so that exceptions in its methods are caught.' 
    # The copy is necessary so that mutable class attributes are not 
    # shared between the old class cls and the new class: 
    new_cls = copy.deepcopy(cls) 
    # vars() is used instead of dir() so that the attributes of base classes 
    # are not modified, but one might want to use dir() instead: 
    for (attr_name, value) in vars(cls).items(): 
     if isinstance(value, types.FunctionType): 
      setattr(new_cls, attr_name, func_wrapper(value)) 
    return new_cls 

B = wrap_class(A) 

正如於爾根指出，這將創建一個班級副本;這只是需要的，但是，如果你真的想保持你的原始類A左右（如原始問題中提出的）。如果你不關心A，你可以簡單地與不進行任何複製，像這樣的包裝裝飾它：

def wrap_class(cls): 
    'Wraps a class so that exceptions in its methods are caught.' 
    # vars() is used instead of dir() so that the attributes of base classes 
    # are not modified, but one might want to use dir() instead: 
    for (attr_name, value) in vars(cls).items(): 
     if isinstance(value, types.FunctionType): 
      setattr(cls, attr_name, func_wrapper(value)) 
    return cls 

@wrap_class 
class A(object): 
    … # Original A class, with methods that are not wrapped with exception catching 

裝飾類A捕獲異常。

元類的版本是較重的，但其原理是相似的：

import types 

def func_wrapper(f): 

    'Returns a version of function f that prints an error message if an exception is raised.' 

    def wrapped_f(*args, **kwargs): 
     try: 
      return f(*args, **kwargs) 
     except Exception, ex: 
      print "Function", f, "raised", ex 

    return wrapped_f 

class ExceptionCatcher(type): 

    'Metaclass that wraps methods with func_wrapper().' 

    def __new__(meta, cname, bases, cdict): 
     # cdict contains the attributes of class cname: 
     for (attr_name, value) in cdict.items(): 
      if isinstance(value, types.FunctionType): # Various attribute types can be wrapped differently 
       cdict[attr_name] = func_wrapper(value) 
     return super(meta, ExceptionCatcher).__new__(meta, cname, bases, cdict) 

class B(object): 

    __metaclass__ = ExceptionCatcher # ExceptionCatcher will be used for creating class A 

    class_attr = 42 # Will not be wrapped 

    def __init__(self): 
     pass 

    def f0(self, a): 
     return a*10 

    def f1(self, a, b): 
     1/0 # Raises a division by zero exception! 

# Test: 
b = B() 
print b.f0(3.14) 
print b.class_attr 
print b.f1(2, 3) 

此打印：

31.4 
42 
Function <function f1 at 0x107812d70> raised integer division or modulo by zero 
None 

你想要做什麼，其實通常由元類完成，這是一個類的實例是一個類：這是一種基於其解析的Python代碼動態構建B類的方法（類A，代碼在問題中）。關於這方面的更多信息可以在Chris的Wiki中給出的關於元類的簡短描述中找到（在part 1和parts 2-4中）。

Answer 2

你可以試試老派與__getattr__：

class B(object): 
    def __init__(self): 
    self.a = A() 
    def __getattr__(self, name): 
    a_method = getattr(a, name, None) 
    if not callable(a_method): 
     raise AttributeError("Unknown attribute %r" % name) 
    def wrapper(*args, **kwargs): 
     try: 
     return a_method(*args, **kwargs) 
     except Exception, ex: 
     # ... 
    return wrapper 

或用更新B的字典：

class B(object): 
    def __init__(self): 
    a = A() 
    for attr_name in dir(a): 
     attr = getattr(a, attr_name) 
     if callable(attr): 
     def wrapper(*args, **kwargs): 
      try: 
      return attr(*args, **kwargs) 
      except Exception, ex: 
      # ... 
     setattr(self, attr_name, wrapper) # or try self.__dict__[x] = y 

Answer 3

元類是一種選擇，但一般很難理解。如果在簡單情況下不需要，則反映太多 ，因爲很容易捕獲太多（內部）功能。如果包裹的功能是穩定組已知和B可能獲得其他的功能，你可以委派明確功能作用，同時確保自己的錯誤處理代碼在一個地方：

class B(object): 

    def __init__(self): 
     a = A() 
     self.f0 = errorHandler(a.f0) 
     self.f1 = errorHandler(a.f1) 

你可能做的任務在一個循環如果它們很多，則使用getattr/setattr。

errorhandler函數將需要返回一個函數，該函數用 錯誤處理代碼包裝其參數。

def errorHandler(f): 
    def wrapped(*args, **kw): 
     try: 
      return f(*args, **kw) 
     except: 
      # log or something 
    return wrapped 

您還可以使用的ErrorHandler作爲不委託給一個實例新功能的裝飾。

def B(A): 
    ... 
    @errorHandler 
    def f_new(self): 
     ... 

該解決方案保持乙簡單，它是非常明確發生了什麼事情。