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 包内部类的前缀。我认为这是一个常见的 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")