Question

这可能很明显，但是我对此很陌生。

如果想到任何有关此类问题的优秀学习材料，我也将不胜感激。

有没有一种方法可以处理基于超级类型的子对象实例？

例如，如果对象模型是Person-Minor / Regular / Senior

class Person:
    def __init__(self, full_name, age):
        self.species = "human"
        self.age = age
        self.first_name = full_name.split()[0]
        self.last_name = full_name.split()[1]
        self.age_classification = self.classify_age(self.age)

    def classify_age(self, input_age):
        if input_age < 18:
            return 'minor'
        elif input_age <= 64:
            return 'regular adult'
        elif input_age > 64:
            return 'senior'

class Minor(Person):
    def __init__(self):
        self.number_older_siblings = 0
        self.number_younger_siblings = 0

    def is_unloved(self):
        if self.number_older_siblings > 0 and self.number_younger_siblings > 0:
            return True
        else:
            return False

有没有一种干净的方法来声明一个人，例如，如果他们未满18岁，它将“自动”成为一个子类型对象？

Ex不必做

my_person = Person('John Smith', 15)

if my_person.age_classification == 'minor':
    my_person = Minor()
    my_person.number_older_siblings = 1
    my_person.number_younger_siblings = 1
    print(my_person.is_unloved())

但是只要声明满足条件，就可以推断出这一点

my_person = Person('John Smith', 15)

my_person.number_older_siblings = 1
my_person.number_younger_siblings = 1
print(my_person.is_unloved())

Answer 1

为什么不编写实例化Person的函数？

def create_person(full_name, age):
    if age <= 18:
        return Minor()
    else:
        return Person(full_name, age)

然后：

>>> type(create_person("John Smith", 19))
__main__.Person

>>> type(create_person("Bob Smith", 12))
__main__.Minor

此外，您可能希望使Minor的构造函数也采用full_name和age。

Answer 2

我认为Moira Jones的解决方案很好，但是您可以采取进一步的措施：

class Person:

    @staticmethod
    def create(full_name, age):
        if age <= 18:
            return Minor()
        else:
            return Person(full_name, age)

    def __init__(self, full_name, age):
        self.species = "human"
        self.age = age
        self.first_name = full_name.split()[0]
        self.last_name = full_name.split()[1]
        self.age_classification = self.classify_age(self.age)

    def classify_age(self, input_age):
        if input_age < 18:
            return 'minor'
        elif input_age <= 64:
            return 'regular adult'
        elif input_age > 64:
            return 'senior'

class Minor(Person):
    def __init__(self):
        self.number_older_siblings = 0
        self.number_younger_siblings = 0

    def is_unloved(self):
        if self.number_older_siblings > 0 and self.number_younger_siblings > 0:
            return True
        else:
            return False

print(type(Person.create("John Smith", 19)))
print(type(Person.create("Bob Smith", 12)))

输出：

<类'__main __。Person'>

如果我们将create()设为父类的静态方法，则可以按照Moira建议的功能使用它，但是它可以与类定义一起使用，而不是成为其上浮动的函数拥有。我认为这使函数与其所操作的对象之间的关系更加清晰。请注意，静态方法不会像其他对象方法那样接收self参数。

混淆处理好对象类型

2 个答案: