Python 在父类中创建子类对象

在父类中创建子类的对象是否是一个好的设计，如下面的示例所示，它似乎可以工作，但它是否是一个好的设计，是否有更好的方法来做到这一点

class parent(object):
    def __init__(self):
        print('Im running')
    def execute(self):
        x = child()
        x.run()
        x.myfun()
    def myfun(self):
        print('parent function')
    def run(self):
        print('parent running')

class child(parent):
    def __init__(self):
        super().__init__()
        print('Im running too')
    def run(self):
        print('child running')


f = parent()
f.execute()

---

对于你的问题来说，这绝对不是一个好的设计，一般来说也不是一个好的设计（除了我想不出的任何例外），而且绝对是违反OOP设计和可靠原则的

简单地说，在OOP设计或任何其他软件工程的思维框架中，您需要明确的关系。这使得父类和子类之间的关系本质上更加复杂。更不用说大多数其他语言（至少是运行编译代码的语言）都不允许这样的事情发生

---

如果您需要一个实例在另一个实例中，反之亦然，那么继承可能是错误的模式，因为您的类似乎是以双向方式连接的，这与使用继承的场景不同

对于你的问题来说，这绝对不是一个好的设计，总体来说也不是一个好的设计（除了我想不出的例外），而且肯定是违反面向对象设计和可靠原则的

简单地说，在OOP设计或任何其他软件工程的思维框架中，您需要明确的关系。这使得父类和子类之间的关系本质上更加复杂。更不用说大多数其他语言（至少是运行编译代码的语言）都不允许这样的事情发生

---

如果您需要一个实例在另一个实例中，反之亦然，那么继承可能是错误的模式，因为您的类似乎是以双向方式连接的，这与使用继承的场景不同

execute根本不使用

self

这一事实表明它应该是一个类方法，在这种情况下，您可以使用实际提供的任何类来实例化

x

一旦这样做了，

Parent

的定义就不再依赖于任何特定的子类；事实上，它根本不依赖于

Parent

是子类这一事实

Parent.execute（）

将继续工作

比如说,

class Parent:
    def __init__(self):
        print('Im running')

    @classmethod
    def execute(cls):
        x = cls()
        x.run()
        x.myfun()

    def myfun(self):
        print('parent function')

    def run(self):
        print('parent running')


class Child(Parent):
    def __init__(self):
        super().__init__()
        print('Im running too')

    def run(self):
        print('child running')


Child.execute()

由于未定义

Child.execute

，因此它解析为

Parent.execute

。但是

Child

仍然是传递的第一个参数。因此，

x

将是

子对象的实例，而不是
父对象的实例
x.run（）
因此运行
Child.run
，但
x.myfun（）
运行
Parent.myfun

尽管如此，
Parent.execute
仍然依赖于
x
具有特定于
cls
的属性，这一事实表明，您应该推迟将
execute
限制为仅使用由
Parent
定义的内容，并让子级重写
execute
以添加任何子级特定行为

或者，
execute
应该是一个实例方法，但它应该简单地调用
self.fun
，这会让调用方负担使用适当的对象调用
execute

c = Child()
c.execute()

execute
根本不使用
self
这一事实表明它应该是一个类方法，在这种情况下，您可以使用实际提供的任何类来实例化
x

一旦这样做了，
Parent
的定义就不再依赖于任何特定的子类；事实上，它根本不依赖于
Parent
是子类这一事实
Parent.execute（）
将继续工作

比如说,

class Parent:
    def __init__(self):
        print('Im running')

    @classmethod
    def execute(cls):
        x = cls()
        x.run()
        x.myfun()

    def myfun(self):
        print('parent function')

    def run(self):
        print('parent running')


class Child(Parent):
    def __init__(self):
        super().__init__()
        print('Im running too')

    def run(self):
        print('child running')


Child.execute()
由于未定义
Child.execute
，因此它解析为
Parent.execute
。但是
Child
仍然是传递的第一个参数。因此，
x
将是
子对象的实例，而不是
父对象的实例
x.run（）
因此运行
Child.run
，但
x.myfun（）
运行
Parent.myfun

尽管如此，
Parent.execute
仍然依赖于
x
具有特定于
cls
的属性，这一事实表明，您应该推迟将
execute
限制为仅使用由
Parent
定义的内容，并让子级重写
execute
以添加任何子级特定行为

或者，
execute
应该是一个实例方法，但它应该简单地调用
self.fun
，这会让调用方负担使用适当的对象调用
execute

c = Child()
c.execute()

对我来说，这似乎很奇怪。但这实际上取决于你的具体用例。也许你应该解释一下你为什么这么做。这段代码没有显示这一点。我的意思是，实际上，您可以简单地将
execute
移动到子类中。我想这样做的原因是，我将有父类和许多子类，所有子类都将从父类继承一些方法而不做任何更改，我将从父类创建对象并调用一个方法，这个基于某些输入的方法将创建一个子对象，并调用一个方法，对我来说，这个方法只存在于一个子类上，这似乎很奇怪。但这实际上取决于你的具体用例。也许你应该解释一下你为什么这么做。这段代码没有显示这一点。我的意思是，实际上，您可以简单地将
execute
移动到子类中。我想这样做的原因是，我将有父类和许多子类，所有子类都将从父类继承一些方法而不做任何更改，我将从父类创建对象并调用一个方法，这个基于某些输入的方法将创建一个子对象，并调用一个只存在于其中一个子类上的方法