python - 在 Python 中嵌套类 3 级 - 这是不好的做法吗？

Question

我正在编写一个 Python 脚本，用于与 XLS/XLSX/CSV 电子表格进行交互。三个主要类相互嵌套(不相互扩展，这些类确实在另一个类中)

三个主要类解释如下:

1. 主要的 Workbook 类，它是 XLS/XLSX/CSV 类的工厂方法。这可以从外部访问
2. Workbook 类中的私有(private) __Worksheet 类，用于打开文件本身中的特定电子表格或工作表。这只能通过 Workbook.worksheet() 方法访问
3. __Worksheet 类中的私有(private) __Cell 类，它与单元格本身交互。这不应该从外部访问，而只能通过 __Worksheet 类访问

到目前为止，这是类结构的简化版本:

class Workbook( object ):

    def __init__( self, file_name ):
        self.__file_name = file_name

    def worksheet( self, name ):
        return self.__Worksheet( self, name )

    class __Worksheet():
        def __init__( self, workbook, worksheet ):
            self.__workbook = workbook

        def cell( self, cell_id, data = None ):
            return self.__Cell( cell_id, data )

        class __Cell():
            def __init__( self, cell, data = None ):
                self.__cell = cell
                self.__data = data

            def setVal( self, data ):
                self.__data = data

            def __str__( self ):
                return self.__data

workbook = Workbook( 'test-file.csv' )
worksheet = workbook.worksheet( 'First Worksheet' )
cell_A1 = worksheet.cell('A1', 'Foo...')

print("Before - Cell A1: %s" % cell_A1) # => Before - Cell A1: Foo...
cell_A1.setVal('Bar...')
print("After - Cell A1: %s" % cell_A1)  # => Before - After - Cell A1: Bar...

所以我的问题是 - 在一个类(class)、一个类(class)中开设一个类(class)是否被认为是不好的做法？

我对 Python 有点陌生，我的经验主要是 PHP/JS/Perl。在 Python 中，类中有类似乎并不少见，但出于某种原因，将类嵌套到 3 层深似乎是错误的。如果是这样，并且有更好的方法来做到这一点，那就太好了。

我知道另一种方法是不嵌套类，只检查Workbook 的实例是否作为参数提供给Worksheet .然后在 Workbook 中创建一个方法，如果 Worksheet 只返回一个实例，同时将 self 作为用于启动它的参数之一。

例子:

class Workbook( object ):
    def __init__( self, file_name ):
        self.__file_name = file_name

    def worksheet( self, name ):
        return self.Worksheet( self, name )

class Worksheet( object ):
    def __init__( self, workbook, worksheet = 0 ):
        if not isinstance( workbook, Workbook ):
            raise Exception( 'Expected the workbook to be an instance of the Workbook class' )

        self.__workbook = workbook

    def cell( self, cell_id, data = None ):
        return self.Cell( cell_id, data )

class Cell( object ):
    def __init__( self, worksheet, cell, data = None ):
        if not isinstance( worksheet, Worksheet ):
            raise Exception( 'Expected the worksheet to be an instance of the Worksheet class' )

        self.__cell = cell
        self.__data = data

    def setVal( self, data ):
        self.__data = data

    def __str__( self ):
        return self.__data

# Example Usage One
workbook = Workbook( 'test-file.xls' )
worksheet = workbook.worksheet( 'First Worksheet' )
cell_A1 = worksheet.cell('A1', 'Foo...')

print("Before - Cell A1: %s" % cell_A1) # => Before - Cell A1: Foo...
cell_A1.setVal('Bar...')
print("After - Cell A1: %s" % cell_A1)  # => Before - After - Cell A1: Bar...

# Example Usage Two
workbook = Workbook( 'test-file.xlsx' )
worksheet = Worksheet( workbook, 'First Worksheet' )
cell_A1 = Cell( worksheet, 'A1', 'Foo...')

print("Before - Cell A1: %s" % cell_A1) # => Before - Cell A1: Foo...
cell_A1.setVal('Bar...')
print("After - Cell A1: %s" % cell_A1)  # => Before - After - Cell A1: Bar...

# Failed Example
worksheet = Worksheet( 'Not worksheet', 1 ) # => Exception, as expected

但是，这种替代方法意味着 Worksheet 和 Cell 类可以从外部访问并且可以手动启动...但我想这不是一件坏事。

让我知道您认为最好的路线是什么! 这篇文章的评论之一提供了指向 another SO post 的链接。 ，其中一位用户发布了嵌套类的 3 个优点，第一个是:

Logical grouping of classes: If a class is useful to only one other class then it is logical to embed it in that class and keep the two together. Nesting such "helper classes" makes their package more streamlined.

这正是我的想法。我只是觉得将它们嵌套到 3 层有点尴尬，因为我之前只做过 2 层。

Answer 1

反过来你的问题:将类写成嵌套有什么好处吗？与函数不同，类不使用“词法作用域”(即与函数不同，无法从当前类的命名空间解析的名称将不会从周围类解析)。这就是为什么您必须引用相对于 Workbook 实例的 __Worksheet 类。

这反过来意味着您使用的嵌套没有明显的优势，尽管它会起作用。大多数有经验的 Python 程序员可能会在不使用嵌套的情况下编写您的示例。这简化了代码(因为类名对于包含的模块来说都是全局的)。

请注意，这与在函数体内声明类完全不同。在那种情况下，类的代码可以引用函数命名空间中的变量，Python 会竭尽全力确保即使在函数调用终止并且与调用关联的局部命名空间已经终止后，这些引用仍然对类可用。被摧毁了。