相當於Java內部類的代理的Python

Question

我想弄清楚最傳統的Pythonic方法來進行有限的回調，以便與複雜對象的方法進行交互。我有一個通過通信渠道接收數據的程序，該數據分爲幾個不同的類別。我需要去耦哪個類別的數據是在確定，從數據的進一步處理：

class Categorizer(object): 
    '''Determines which category data is in. 
     There may be multiple variants of this class''' 
    def handleData(self, data, callback): 
     if self.somethingReallySpecial(data): 
      callback.onSomethingReallySpecial(data) 
     elif self.somethingSpecial(data): 
      callback.onSomethingSpecial(data) 
     else: 
      callback.onSomethingMundane(data) 
    # ... other methods ... 

class IAmAReallyComplicatedBeast(object): 
    def __init__(self, categorizer, other_stuff): 
     self.categorizer = categorizer 
     # ... 
    # ... lots of other methods ... 
    def something(self, other_stuff): 
     data = self.obtain_data() 
     # this is probably wrong, but here's what I want to do: 
     beast = self 
     class Dispatcher(object): 
      def onSomethingMundane(data): 
       beast.doFoo(data) 
      def onSomethingSpecial(data): 
       beast.doBar(data) 
      def onSomethingReallySpecial(data): 
       beast.doBaz(data) 
     self.categorizer.handleData(data, Dispatcher()) 
    def doFoo(self, data): 
     # for mundane data 
    def doBar(self, data): 
     # for special data 
    def doBaz(self, data): 
     # for really special data 

在Java中我會用一個內部類（喜歡這裏的調度程序）...有一個Python化處理這個方法？

---

我不想直接把onSomethingXXX方法對我IAmAReallyComplicatedBeast類，有兩個原因：

• 這意味着我不得不爲是
• 我不使用這些名稱不希望Categorizer類可以任意訪問IAmAReallyComplicatedBeast對象。也許這來自通常的Java偏執狂思維，但它對我來說似乎是一個很好的設計。

Answer 1

使調度員的Python的方式是使用字典。請記住，在Python函數中是一流的對象，因此可以是字典中的值。

class IAmAReallyComplicatedBeast(object): 
    def something(self, other_stuff): 
     data = self.obtain_data() 
     dispatcher = { 
      'something_mundane': self.do_foo, 
      'something_special': self.do_bar, 
      'something_really_special': self.do_baz 
     } 
     self.categorizer.handleData(data, dispatcher) 

class Categorizer(object): 
    '''Determines which category data is in. 
     There may be multiple variants of this class''' 
    def handleData(self, data, callback): 
     if self.somethingReallySpecial(data): 
      dispatcher['something_really_special'](data) 

注：我知道你並沒有提出這一點，但內部類是真正的非Python化：內部類漲幅沒有特殊訪問外部類，以及諸如此類的事情，不推薦。

Answer 2

您可以使IAmAReallyComplicatedBeast也是一個Dispatcher通過別名必要的方法：

class IAmAReallyComplicatedBeast(object): 
    # ... snip ... 

    # In something we can just pass ourself because we are a dispatcher 
    self.categorizer.handleData(data, self) 
    # ... snip ... 
    def doFoo(self, data): 
     # Do mundane things here 

    onSomethingMundane = doFoo 

    # ... etc. ... 

或者，您可以創建一個包裝方法的類簡單地創建實例它，而不是每次創建一個新類：

class Dispatcher(object): 
    __slots__ = ('onSomethingMundane', 
       'onSomethingSpecial', 
       'onSomethingVerySpecial') 
    def __init__(self, mundane, special, very_special): 
     self.onSomethingMundane = mundane 
     self.onSomethingSpecial = special 
     self.onSomethingReallySpecial = very_special 

然後您的something方法將是一個更清楚一點：

def something(self, other_stuff): 
     data = self.obtain_data() 
     dispatcher = Dispatcher(self.doFoo, self.doBar, self.doBaz) 
     self.categorizer.handleData(data, dispatcher) 

Answer 3

如果您有興趣分享與其他類調度員，你可以做這樣的事情：

class Dispatcher(object): 
    def __init__(self,f1,f2,f3): 
     self.onSomethingMundane=f1 
     self.onSomethingSpecial=f2 
     self.onSomethingReallySpecial=f3 


class IAmAReallyComplicatedBeast(object): 
    #... 
    def something(self, other_stuff): 
     data = self.obtain_data() 
     # this is probably wrong, but here's what I want to do: 
     beast = self 
     beast_dispatcher = Dispatcher(beast.doFoo,beast.doBar,beast.doBaz) 
     self.categorizer.handleData(data, beast_dispatcher) 
    #... 

Answer 4

由於@ ch3ka已經表明，字典將pythonic選擇在這裏恕我直言。 事情可能喜歡這則：

class Categorizer(object): 
    '''Determines which category data is in. 
     There may be multiple variants of this class''' 
    def handleData(self, data, callback_mapping): 
     # get the category 
     category = self.categorize(data) 
     # invoke the corresponding handler 
     callback_mapping[category](data) 


class IAmAReallyComplicatedBeast(object): 
    def __init__(self, categorizer, other_stuff): 
     self.categorizer = categorizer 
     # ... 
    # ... lots of other methods ... 
    def something(self, other_stuff): 
     data = self.obtain_data() 
     self.categorizer.handleData(data, 
            dict(mundane=self.doFoo, 
             special=self.doBar, 
             really_special=self.doBaz) 
    def doFoo(self, data): 
     # for mundane data 
    def doBar(self, data): 
     # for special data 
    def doBaz(self, data): 
     # for really special data 

經常使用的另一種模式是創建方法動態調用的名稱。 例如在python的內置BaseHTTPServerdo_XXX被調用，其中XXX是請求的佔位符的HTTP方法：

mname = 'do_' + self.command 
    if not hasattr(self, mname): 
     self.send_error(501, "Unsupported method (%r)" % self.command) 
     return 
    method = getattr(self, mname) 
    method() 

參見：https://hg.python.org/cpython/file/2.7/Lib/BaseHTTPServer.py#l323 因此你可以如爲您的方法命名爲doSpecial，doReallySpecial和doMundane，並從分類程序中調用它們。