Python風格問題：支持類作爲內部類嗎？

Question

我喜歡使用語言中內置的結構來組織我的代碼。但是有一種情況我不能保持一致，僅僅因爲我沒有看到明確的最佳方式。它是關於支持類的，也就是由另一個類內部專用的類：我是否讓它們成爲內部類或單獨的類。

內部類：

class Complicated: 
    class Utility1: 
     pass 
    class Utility2: 
     pass 
    pass 

獨立類：

class Complicated: 
    pass 

class Utility1: 
    pass 

class Utility2: 
    pass 

內部類有被作用域使用它們的唯一類中的優勢。但問題是，由於縮進，我得到的空間更少。

外部類既沒有優勢也沒有劣勢。每當我寫支持課時，我總是花費精力去思考這個愚蠢的問題，我感到厭倦。

我的問題是，是否有人在他們背上有豐富的python經驗可以提供一個關於這方面是否有最佳實踐的建議？即使答案是「這取決於」，但如果它帶有比我更有經驗的人，我們會很感激。

Answer 1

我建議

class Complicated: 
    pass 

class _Utility1: 
    pass 

class _Utility2: 
    pass 

，並把所有它自己的模塊中。領先的_表示實用程序類僅用於內部使用（因爲它是有用的，它們不會被from module import *導入;但我不喜歡這種方式）。

編輯：從PEP 8舉例：

類供內部使用有一個前導下劃線除。

Answer 2

我使用單下劃線作爲Python包內部類的前綴。我認爲這是一種常見的蟒圖案：

class Complicated: 
    pass 

class _Utility1: 
    pass 

class _Utility2: 
    pass 

Answer 3

是否我使用一個內部類或外部類很大程度上取決於我是否期望覆蓋的類型，無論是在一個子類或基於每個實例的基礎：

class Foo(object): 
    normalize = str 

    def process(self, input): 
     # Do some stuff in here... 
     return self.normalize(output) 

class UniFoo(Foo): 
    normalize = unicode 

class TotallyMungedFoo(Foo): 
    class normalize(object): ... 

如果我不期望需要（或明確不想）這樣的行爲，我在同一個模塊中使用類，但只在我的__all__聲明中包含「重要」類。

Answer 4

Python內部類

Python內部類可以創建和使用。 與其他語言（如Java）不同，Python內部類不會自動爲您提供對外部類屬性和方法的訪問權限。

解決此問題的方法： 使用父參數定義所有內部類。該參數可用於訪問外部類的屬性和方法。

Python的實施例類具有嵌套類

class Outer: 
    def __init__(self): 
     self.myVar = 100 
     self.inner = self.Inner(self) 

    def getDoubleVar(self): 
     return(self.myVar * 2) 

    #Define inner class 
    class Inner: 
     def __init__(self, parent): 
      self.parent = parent 

     #Use the parent variable to access parent class attributes/methods 
     def printOuterVar(self): 
      print(self.parent.myVar) 

     def callOuterMethod(self): 
      return(self.parent.getDoubleVar()) 




#Create Instance of Outer Class 
outer = Outer() 

#Display myVar 
print("Display myVar") 
print(outer.myVar) 


#Execute Outer Method 
print("\nExecute Outer Method") 
print("val = outer.getDoubleVar()") 
val = outer.getDoubleVar() 
print("val: {0}".format(val)) 

#Execute Inner Method 
print("\nExecute Inner Method") 
print("outer.inner.printOuterVar()") 
outer.inner.printOuterVar() 

#Execute Inner Method That Calls Outer Method 
print("\nExecute Inner Method That Calls Outer Method") 
val = outer.inner.callOuterMethod() 
print("val = outer.inner.callOuterMethod()") 
print("val: {0}".format(val)) 

#Create Instance of Inner Class Separately 
print("\nInstantiate Inner Class Separately") 
#Note that you provide the current outer instance as the parent parameter 
print("Note that you provide the current outer instance as the parent parameter") 
print("myInner = outer.Inner(outer)") 
myInner = outer.Inner(outer) 

#Call Inner Method 
print("\nCall Inner Method") 
print("myInner.printOuterVar()") 
myInner.printOuterVar() 
print("finished")