Python风格的问题：支持类作为内部类？

我喜欢使用语言中内置的结构来组织代码。但有一种情况我不能保持一致，仅仅因为我看不到一个明确的最佳方式。这是关于支持类，也就是说，由另一个类在内部专门使用的类：我是将它们设置为内部类，还是单独的类

内部类：

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

不同类别：

class Complicated:
    pass

class Utility1:
    pass

class Utility2:
    pass

内部类的优点是作用域位于使用它们的唯一类内。但问题是，由于缩进，我得到更少的空间来编写代码

外部阶级既没有优势也没有劣势。每当我写支持课程的时候，我总是花费一些精神上的精力来思考这个愚蠢的问题，我已经厌倦了

我的问题是，有丰富python经验的人是否可以建议是否有关于这方面的最佳实践？即使答案是“视情况而定”，但如果有比我更有经验的人提供，我们也会很感激。

我建议

class Complicated:
    pass

class _Utility1:
    pass

class _Utility2:
    pass

把所有这些都放在它自己的模块中。前导的

\uuu

表示实用程序类仅供内部使用（实际上，它们不会通过模块导入中的

导入*

；但我不喜欢这样）

编辑：引用自：

内部使用的类还有一个前导下划线

---

我使用单下划线作为python包内部类的前缀。我认为这是一种常见的python模式：

class Complicated:
    pass

class _Utility1:
    pass

class _Utility2:
    pass

---

我使用的是内部类还是外部类很大程度上取决于我是否希望在子类或每个实例的基础上重写类型：

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): ...

如果我不希望需要（或明确不希望）这样的行为，我会在同一个模块中使用类，但只在我的

\uuuuuuu all\uuuuu

声明中包含“重要”的类。

Python内部类 Python内部类可以创建和使用。 与Java等其他语言不同，Python内部类不会自动为您提供对外部类属性和方法的访问

此问题的解决方法： 使用父参数定义所有内部类。此参数可用于访问外部类属性和方法

带有内部类的Python示例类

---

你是说

Foo

是其他类的基类吗？为什么选择

\u

-前缀是

\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu。领先的
\uu
是Python中的内部使用指示符。为什么首选
\u
-前缀为
\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
？@Joe:我从来没有定义过
\uuuu。我注意到python标准库和开源项目中的许多模块都使用了前导下划线，并复制了它。我认为它适合许多python公开内部（例如，
\uu dict\uu
对象）并依赖程序员的纪律不滥用它们。
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")