Python 如何在parent\uuuu new\uuuuu中使用一些魔法创建子类实例？

例如，在以下层次结构中创建自定义编号类型

• 编号

  • Complex

  • Real

    • Int

    • Float

使用

\uuuu new\uuuu方法中的逻辑：

class Number:
    def __new__(cls, value):
        if isinstance(value, complex):
            return Complex(value)
        elif isinstance(value, (int, float)):
            return Real(value)
        else:
            raise TypeError('Ну ты и мудак!!!')

    def __init__(self, value):
        self.value = value


class Complex(Number):
    pass


class Real(Number):
    def __new__(cls, value):
        if isinstance(value, int):
            return Int(value)
        elif isinstance(value, float):
            return Float(value)
        else:
            raise TypeError('Ты больше не можешь вести себя так!!!')


class Int(Real):
    pass


class Float(Real):
    pass

然后，使用
Number
构造函数创建
Float
实例：

number = Number(6.6)
assert isinstance(number, Float)

由于递归限制，此代码将引发运行时错误。这只是一个理想行为的例子。但是我也尝试使用
super
来实现这一点，似乎我误解了这个世界。
你的
复杂的
，
浮点数
和
Int
类没有
\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu新的方法，所以它们从
Number
继承这些方法；这就是导致无限递归的原因

您可以针对
\uuuu类\uuuu
闭包进行测试，以查看是否有子类：

class Number:
    def __new__(cls, value):
        if cls is not __class__:
            # Subclass, create an instance (invokes object.__new__)
            return super().__new__(cls)

        if isinstance(value, complex):
            return Complex(value)
        elif isinstance(value, (int, float)):
            return Real(value)
        else:
            raise TypeError('Ну ты и мудак!!!')

    def __init__(self, value):
        self.value = value

并在
Real
中执行相同操作：

class Real(Number):
    def __new__(cls, value):
        if cls is not __class__:
            # Subclass, create an instance
            return super().__new__(cls, value)

        if isinstance(value, int):
            return Int(value)
        elif isinstance(value, float):
            return Float(value)
        else:
            raise TypeError('Ты больше не можешь вести себя так!!!')

演示：

您的
Complex
、
Float
和
Int
类没有
\uuuuuuuuu新的
方法，因此它们从
Number
继承这些方法；这就是导致无限递归的原因

您可以针对
\uuuu类\uuuu
闭包进行测试，以查看是否有子类：

class Number:
    def __new__(cls, value):
        if cls is not __class__:
            # Subclass, create an instance (invokes object.__new__)
            return super().__new__(cls)

        if isinstance(value, complex):
            return Complex(value)
        elif isinstance(value, (int, float)):
            return Real(value)
        else:
            raise TypeError('Ну ты и мудак!!!')

    def __init__(self, value):
        self.value = value

并在
Real
中执行相同操作：

class Real(Number):
    def __new__(cls, value):
        if cls is not __class__:
            # Subclass, create an instance
            return super().__new__(cls, value)

        if isinstance(value, int):
            return Int(value)
        elif isinstance(value, float):
            return Float(value)
        else:
            raise TypeError('Ты больше не можешь вести себя так!!!')

演示：

您的
Complex
、
Float
和
Int
类没有
\uuuuuuuuu新的
方法，因此它们从
Number
继承这些方法；这就是导致无限递归的原因

您可以针对
\uuuu类\uuuu
闭包进行测试，以查看是否有子类：

class Number:
    def __new__(cls, value):
        if cls is not __class__:
            # Subclass, create an instance (invokes object.__new__)
            return super().__new__(cls)

        if isinstance(value, complex):
            return Complex(value)
        elif isinstance(value, (int, float)):
            return Real(value)
        else:
            raise TypeError('Ну ты и мудак!!!')

    def __init__(self, value):
        self.value = value

并在
Real
中执行相同操作：

class Real(Number):
    def __new__(cls, value):
        if cls is not __class__:
            # Subclass, create an instance
            return super().__new__(cls, value)

        if isinstance(value, int):
            return Int(value)
        elif isinstance(value, float):
            return Float(value)
        else:
            raise TypeError('Ты больше не можешь вести себя так!!!')

演示：

您的
Complex
、
Float
和
Int
类没有
\uuuuuuuuu新的
方法，因此它们从
Number
继承这些方法；这就是导致无限递归的原因

您可以针对
\uuuu类\uuuu
闭包进行测试，以查看是否有子类：

class Number:
    def __new__(cls, value):
        if cls is not __class__:
            # Subclass, create an instance (invokes object.__new__)
            return super().__new__(cls)

        if isinstance(value, complex):
            return Complex(value)
        elif isinstance(value, (int, float)):
            return Real(value)
        else:
            raise TypeError('Ну ты и мудак!!!')

    def __init__(self, value):
        self.value = value

并在
Real
中执行相同操作：

class Real(Number):
    def __new__(cls, value):
        if cls is not __class__:
            # Subclass, create an instance
            return super().__new__(cls, value)

        if isinstance(value, int):
            return Int(value)
        elif isinstance(value, float):
            return Float(value)
        else:
            raise TypeError('Ты больше не можешь вести себя так!!!')

演示：

无需在
\uuuu new\uuuu
上使用
@staticmethod
；不管怎样，Python都将其视为静态方法，一点也不因为没有要绑定的类或实例。无需在
\uuuu new\uuuu
上使用
@staticmethod
；不管怎样，Python都将其视为静态方法，一点也不因为没有要绑定的类或实例。无需在
\uuuu new\uuuu
上使用
@staticmethod
；不管怎样，Python都将其视为静态方法，一点也不因为没有要绑定的类或实例。无需在
\uuuu new\uuuu
上使用
@staticmethod
；不管怎样，Python都将其视为一个静态方法，因为没有任何类或实例可绑定。