如果子类是由构造逻辑决定的，那么将类及其父类的逻辑分开的最pythonic和优雅的方法是什么？

Question

I want to construct classes from strings such as "red apple" . This would create an instance of class Apple , which is a subclass of Fruit . The thing is, color attribute should belong to Fruit , not Apple . Therefore, the natural way of creating the object seem to me to be:

1. parse the string
2. create Fruit(color="red")
3. create Apple()
4. somehow make it a single entity

So far I have 3 options:

1. Everything becomes parameters

    class Fruit(object): def __init__(self, color): self.color = color def observe(self): print "Looks like a tasty %s fruit" % self.color @classmethod def fromstring(cls, string): color, kind = string.split() if kind == "apple": return Apple(color) class Apple(Fruit): def __init__(self, *args, **kwargs): super(Apple, self).__init__(*args, **kwargs) self.tasty = True def bite(self): print "I bite into a tasty apple" fruit = Fruit.fromstring("red apple") 

2. The color attribute is filled in from outside

    class Fruit(object): def observe(self): print "Looks like a tasty %s fruit" % self.color @classmethod def fromstring(cls, string): color, kind = string.split() if kind == "apple": ins = Apple() ins.color = color return ins class Apple(Fruit): def __init__(self): self.tasty = True def bite(self): print "I bite into a tasty apple" fruit = Fruit.fromstring("red apple") 

3. The most straightforward way: replacing __class__

    class Fruit(object): def __init__(self, string): self.color, kind = string.split() if kind == "apple": self.__class__ = Apple Apple.__init__(self) def observe(self): print "Looks like a tasty %s fruit" % self.color class Apple(Fruit): def __init__(self): self.tasty = True def bite(self): print "I bite into a tasty apple" fruit = Fruit("red apple") 

Running

fruit.observe()
fruit.bite()
print type(fruit), fruit.tasty

gives the same output:

Looks like a tasty red fruit
I bite into a tasty apple
<class '__main__.Apple'> True

The first method, arguably the most versatile, requires passing around arguments such as color , which are handled much more elegantly in the third method. Yet altering __class__ sounds like using advanced tools for a mundane task. Is there a better way to achieve the goal or I am better off using one of these things?

UPDATE : I probably must indicate that in real life the amount of attributes that Fruit 's and Apple 's initializers should set is variable , about 15 in total.

Answer 1

I would pull the creation logic out of the classes completely:

1. parse the string
2. determine the object to create
3. create object

So using the following code:

class Fruit(object):
    def __init__(self, color):
        self.color = color

    def observe(self):
        print "Looks like a tasty %s fruit" % self.color

class Apple(Fruit):
    def __init__(self,color):
        super(Apple, self).__init__(color)
        self.tasty = True

    def bite(self):
        print "I bite into a tasty apple"

fruit = None
color,type = "red apple".split()
if type == "apple":
    fruit = Apple(color)
if type == "banana" and color == "blue"
    raise Exception("Welcome to Chernobyl")

edit: In reply to your comment on dm03514's answer.

The major difference between this code, and your "option 1" is that in this, Fruit doesn't need to know about its subclasses. In my code I can do this:

class Banana(Fruit):
    def __init__(self,color):
        if color not in ["yellow","green"]:
            raise Exception("Welcome to Chernobyl")
        super(Banana).__init__(self,color)
        if color = "yellow":
            self.ripe = True
        elif color = "green:"
            self.ripe = False

    def bite(self):
        print "I bite into a %s banana"%["unripe","ripe"][self.ripe]

Fruit needs no knowledge of my subclass. In your code, for every new type of fruit, the Fruit class needs to be updated, essentially limiting any easy way to extend it. If you were designing a library that I wanted, I couldn't reuse Fruit as I can't add Banana, or orange, or any fruit you don't have without altering your code which is antithetical to code reuse.

Answer 2

I think you need to evaluate what the base class represents.

Does every fruit NEED a color (your observe function would suggest it does at least need a default value to not result in an error if it is called)? If so it should be part of the fruit constructor and should be required to create a fruit.

From my comment, I also am leery of your base class instantiating subtypes. Should a Fruit be aware of all its subtypes (see legos answer for example)?

Answer 3

class Fruit(object):
    def __init__(self,color):
        self.color = color

    def observe(self):
        print "Looks like a tasty %s fruit" % self.color
    @classmethod
    def fromstring(cls, my_string):
        color, kind = my_string.split()
        my_class = globals().get(kind.capitalize(),Fruit)(color)
        assert isinstance(my_class, Fruit),"Error Unknown Kind %s"%kind
        return my_class

class Apple(Fruit):
    def __init__(self,color):
        self.tasty = True
        Fruit.__init__(self,color)

    def bite(self):
        print "I bite into a tasty apple"

a = Fruit.fromstring("red apple")
print a
a.bite()