¿Herencia múltiple en Taxonomía de animales?

[Koan]

Hola, no quiero demorar mas mi aprendizaje en POO y he creado una Taxonomía del reino animal. En principio, con los vertebrados. Esta claro, que luego hay un sin fin de subgrupos. Pero partiendo del grupo de vertebrados, solo llego a tres niveles para no hacerlo muy extenso.

Me gustaría saber, si en este código (esqueleto de clases) quitaríais alguna clase o bien, aplicaríais la herencia múltiple para no crear muchas clases.

De hecho, la duda de la herencia múltiple en este caso, es que luego no quiero que se solapen comportamientos raros entre animales. Es decir, que pongamos el método:

Código Python:

sapo.comer(bufalo)
 

Y el sapo se lo coma sin problemas al búfalo. Ya me entendéis. Creo, que al estar las clases como las pongo yo en el ejemplo, son más difíciles estas incongruencias.

Este es mi código de clases (Luego ya me meteré con el grupo de invertebrados):
(La instancia final sería la última hoja del árbol. Osea, el animal)

Código Python:

# REINO
class ReinoAnimal:
    pass
 
# CLASE GENERAL 
 
class Vertebrados(ReinoAnimal):
    pass
 
# 5 GRUPOS VERTEBRADOS
 
class Anfibios(Vertebrados):
    pass
class Aves(Vertebrados):
    pass
class Mamiferos(Vertebrados):
    pass
class Peces(Vertebrados):
    pass
class Reptiles(Vertebrados):
    pass
 
# ANBIBIOS
 
class Urodelos(Anfibios):
    pass
class Anuros(Anbibios):
    pass
 
# AVES
 
class Ratites(Aves):
    pass
class Carenadas(Aves):
    pass
 
# MAMIFEROS
 
class Monotremas(Mamiferos):
    pass
class Marsupiales(Mamiferos):
    pass
class Placentarios(Mamiferos): #Aquí sale un subgrupo de nivel 3
    pass
 
# MAMIFEROS/PLACENTARIOS
 
class Carnivoros(Placentarios):
    pass
class Cetaceos(Placentarios):
    pass
class Primates(Placentarios):
    pass
class Quiropteros(Placentarios):
    pass
class Roedores(Placentarios):
    pass
class Ungulados(Placentarios):
    pass
 
# REPTILES
 
class Cocodrilos(Reptiles):
    pass
class Ofidios(Reptiles):
    pass
class Quelonios(Reptiles):
    pass
class Saurios(Reptiles):
    pass
 
# PECES
 
class Condrictios(Peces):
    pass
class Osteoicteos(Peces):
    pass
 

[alzacon]

Y a todo esto ¿qué hay de la herencia?

[Koan]

Iniciado por alzacon

Y a todo esto ¿qué hay de la herencia?

Hombre, ya dije que era solo el esqueleto de clases. Luego, se trata de ir metiendo atributos y métodos.

Por ejemplo, la clase Marsupiales heredaran los métodos de mamíferos y vertebrados.

La duda que planteaba, es que dado como he jerarquizado las clases, si debería haber implantado la herencia múltiple. En todo caso, los atributos y métodos son los básicos. Luego, cada especie, iría añadiendo otros atributos de su especie.

[razpeitia]

No soy un experto en biología animal, pero que no la taxonomía se representa muy bien con herencia simple? Después de todo te lo ponen con un árbol.



Haciendo la herencia múltiple inpractica. Ademas no veo en ningún lugar la herencia múltiple. Siempre heredas de una sola clase en todas tus clases.

Ejemplo sencillo de herencia múltiple:

Código Python:

class A(object):
    def a(self):
        print "A"
 
class B(object):
    def b(self):
        print "B"
 
class C(A, B):
    def c(self):
        print "C"
        self.b()
        self.a()
 
c = C()
c.c()
 

Lo interesante de la herencia múltiple es orden de resolución de los métodos y atributos.

Por ejemplo, aquí vemos como imprime C, B, A:

Código Python:

class A(object):
    def __init__(self):
        super(A, self).__init__()
        print "A"
 
class B(object):
    def __init__(self):
        super(B, self).__init__()
        print "B"
 
class C(A, B):
    def __init__(self):
        print "C"
        super(C, self).__init__()
 
C()
 

Pero si cambiamos el orden.

Código Python:

class C(B, A):
    def __init__(self):
        print "C"
        super(C, self).__init__()
 

Obtenemos C, A, B

Pero si vemos el mro. C.mro() vemos que la resolución esta al revés, esto es porque es importante también la llamada a super de los métodos.

Código Python:

class A(object):
    def __init__(self):
        print "A"
        super(A, self).__init__()
 
class B(object):
    def __init__(self):
        print "B"
        super(B, self).__init__()
 
class C(A, B):
    def __init__(self):
        print "C"
        super(C, self).__init__()
 
C()
 

Si quieres aprender mas de mro te recomiendo ver la documentación.
https://www.python.org/download/releases/2.3/mro/

O tomar un libro de python donde expliquen a detalle herencia múltiple. Lamentablemente no hay tanto material en español como lo hay en ingles. Así que buena suerte con eso.

[alzacon]

Ah vale, no vi o se me olvido lo del solapamiento. Pero de todas formas depende de los atributos y métodos de las clases iniciales.

[Koan]

He estado dándole un poco de forma a la clase y eliminando subclases. Para dejar los 5 grupos de vertebrados. Luego, en las 5 subclases es donde se pueden poner esos pocos atributos o métodos mas especializados de cada animal.

Yo creo que con la clase Vertebrados ya se pueden crear interacción entre animales.

Código Python:

class Vertebrados(object):
    
    def __init__(self):        
        self.carnivoro = False
        self.herbivoro = False
        self.insectivoro = False
        self.omnivoro = False
        self.venenoso = False
        self.potenciaVeneno = 0
        self.inmunidadVeneno = 0
        self.oxigeno = 100
        self.nutrir = 0
        
    def caracteristicas(self):
        self.comunes = ('- Organizacion celular: Eucariota y pluricelular.',
                   '- Nutricion: Heterotrofa por ingestion.',
                   '- Metabolismo: Aerobio (consumo oxigeno).',
                   '- Reproducion: Sexual / Asexual.',
                   '- Forma: Simetrica (Excepto las esponjas)')
        for i in self.comunes:
            print(i)       
                                     
                  
    def comida(self, comida):
        self.comida = comida
        if self.comida == 'carne':
            self.carnivoro = True
            return ('Carnivoro')
        elif self.comida == 'hierba':
            self.herbivoro = True
            return ('Herbivoro')
        elif self.comida == 'insectos':
            self.insectivoro = True
            return ('Insectivoro')
        elif self.comida == 'animales/plantas':
            self.omnivoro = True
            return ('Omnivoro')        
        else:
            return ('No conozco esa alimentacion')
        
    def comer(self): 
        self.nutrir += 5
        return self.nutrir 
    
    def respirar(self):
        self.oxigeno -= 1
        return self.oxigeno
    
    def excretar(self):
        self.nutrir -= 2
        return self.nutrir
    
    def responder(self, sonido):
        self.sonido = sonido
        print('¡¡¡' + self.sonido + '!!!')
        
    def mover(self):
        print('Estoy caminando o volando o nadando')
        
    def reproducir(self):
        print('Sin comentarios...jejeje')
    
    def atacar(self, animal):
        self.animal = animal
        if animal.venenoso == True:
            print('¡El animal te he inyectado su veneno!')
        else:
            print('¡Que rico...!')
   
 
# 5 GRUPOS VERTEBRADOS
 
class Anfibios(Vertebrados):
    pass
class Aves(Vertebrados):
    pass
class Mamiferos(Vertebrados):
    pass
class Peces(Vertebrados):
    pass
class Reptiles(Vertebrados):
    pass
 

Luego, ya se podría entrar en el tema del encapsulamiento, polimorfismo y tal. Pero bueno, es mi primera clase creada.