主页 / 问题 / 1594072
Accepted
egorka_angelskiy
Asked:2024-09-17 18:22:43 +0000 UTC2024-09-17 18:22:43 +0000 UTC

超出类中的最大递归深度

  • 772

我正在编写一个矩阵类，并希望将同一类的方法放入属性类中

class Matrix:
    def __init__(
            self, 
            rows: int=None, 
            columns: int=None, 
            values: list[int | float | list[int | float]]=None
        ) -> None:
        self.__rows = 3 if not rows else (3 if rows <= 0 else rows)
        self.__columns = 3 if not columns else (3 if columns <= 0 else columns)
        self.__values = [
                            [
                                random.randint(-10, 10) 
                                for _ in range(self.__columns)
                            ]
                            for _ in range(self.__rows)
                        ] if not values and self.__rows != 1 \
                        else [
                            random.randint(-10, 10)
                            for _ in range(self.get_columns)
                        ] if self.__rows == 1 else values
        
        self.T = self.__transposition()
    
   
    
    def __transposition(self) -> typing.Self:
        return Matrix(
            self.__columns, 
            self.__rows, 
            [
                [
                    self.__values[j][i] 
                    for j in range(self.__rows)
                ] 
                for i in range(self.__columns)
            ]
        )
    
    
if name == 'main': 
    a = Matrix(rows=2)  
    print(a.T)

但有深度递归

File "Matrix.py", line 25, in __init__
    self.T = self.__transposition()
             ^^^^^^^^^^^^^^^^^^^^^^
  File "Matrix.py", line 47, in __transposition
    return Matrix(
           ^^^^^^^
RecursionError: maximum recursion depth exceeded

可以做什么？我尝试通过静态方法装饰器运行它，但没有任何效果。

python

1 个回答

  1. Best Answer

    好吧，你立即__init__调用转置，并在转置中创建一个新对象，这样你就得到了无限递归。

    有必要在初始化期间不要调用转置，而是在访问属性时调用转置T；为此，它必须是带有装饰器的方法@property：

    class Matrix:
    def __init__(
            self, 
            rows: int=None, 
            columns: int=None, 
            values: list[int | float | list[int | float]]=None
        ) -> None:
        ...
        # Эту строку убираете:
        # self.T = self.__transposition()
    
    def __transposition(self) -> typing.Self:
        ...

    @property
    def T(self):
        return self.__transposition()
    
    
if name == 'main': 
    a = Matrix(rows=2)  
    print(a.T)

    您可以像这样编写它，而不是将其声明T为方法：

    class Matrix:
    def __init__(
            self, 
            rows: int=None, 
            columns: int=None, 
            values: list[int | float | list[int | float]]=None
        ) -> None:
        ...
        # Эту строку убираете:
        # self.T = self.__transposition()

    def __transposition(self) -> typing.Self:
        ...

    T = property(__transposition)

    本质上与上面大致相同，但没有中间方法，“简单地”属性T成为方法的属性__transposition。

    • 0

相关问题