Inheritance Question

Python Conversations
#1

Animal Kingdom
Design a class hierarchy for different animals.
Create a base class Animal with attributes like species and methods like make_sound(),eat(),sleep(),reproduce()
Then, create subclasses like Mammal, Bird, and Fish,Reptiles
that inherit from Animal and have their own unique behaviors.

Mammal:
vertebrate: present:
mammary_gland:
warm_blooded:

Bird:
Fly:
has_feather:
def fly():

Fishes:
have_gills:
def swim()

Reptiles:
Cold Blooded
crawl()

1 Like
#2

class Animal:
def init(self, species):
self.species = species

def make_sound(self):
    pass

def eat(self):
    pass

def sleep(self):
    pass

def reproduce(self):
    pass

class Mammal(Animal):
def init(self, species, vertebrate, mammary_gland, warm_blooded):
super().init(species)
self.vertebrate = vertebrate
self.mammary_gland = mammary_gland
self.warm_blooded = warm_blooded

def give_birth(self):
    pass

class Bird(Animal):
def init(self, species, has_feather):
super().init(species)
self.has_feather = has_feather

def fly(self):
    pass

class Fish(Animal):
def init(self, species, have_gills):
super().init(species)
self.have_gills = have_gills

def swim(self):
    pass

class Reptile(Animal):
def init(self, species, cold_blooded):
super().init(species)
self.cold_blooded = cold_blooded

def crawl(self):
    pass

Creating instances of subclasses

lion = Mammal(“Lion”, True, True, True)
sparrow = Bird(“Sparrow”, True)
salmon = Fish(“Salmon”, True)
snake = Reptile(“Snake”, True)

Using methods

lion.make_sound()
lion.eat()
lion.sleep()
lion.reproduce()
lion.give_birth()

sparrow.make_sound()
sparrow.eat()
sparrow.sleep()
sparrow.reproduce()
sparrow.fly()

salmon.make_sound()
salmon.eat()
salmon.sleep()
salmon.reproduce()
salmon.swim()

snake.make_sound()
snake.eat()
snake.sleep()
snake.reproduce()
snake.crawl()

#3

#Neha Wagh

class animals:
def init(self,name,types):
self.name=name
self.types=types
self.cold_blooded=‘’

def cold_or_warm_blooded(self):
    if self.cold_blooded=='yes':
        print('{} is cold blooded'.format(self.name))
    else:
        print('{} is warm blooded'.format(self.name))

def print_type(self):
    print('{} is of {} type'.format(self.name,self.types))
    
def vertebra(self):
    print('{} is vertebrate animal'.format(self.name))
    
def make_sound(self):
    print('{} can make sound'.format(self.name))
    
def reproduce(self):
    print('{} can reproduce'.format(self.name))

class birds(animals):
def init(self,name,types):
super().init(name,types)
cold_blooded=‘yes’

def can_fly(self):
    print('{} can fly'.format(self.name))
def has_feather(self):
    print('{} has feather'.format(self.name))

class fishes(animals):
def init(self,name,types):
super().init(name,types)
cold_blooded=‘yes’

def can_swim(self):
    print('{} can swim'.format(self.name))
def have_grills(self):
    print('{} has grills'.format(self.name))

class mammals(animals):
def init(self,name,types):
super().init(name,types)
cold_blooded=‘no’

def have_fur(self):
    print('{} have hair/fur for covering their bodies'.format(self.name))
def have_mammarygland(self):
    print('{} have mammary glands'.format(self.name))

class reptiles(animals):
def init(self,name,types):
super().init(name,types)
cold_blooded=‘yes’

def can_fly(self):
    print('{} can fly'.format(self.name))
def has_feather(self):
    print('{} has feather'.format(self.name))

mammal=mammals(‘human’,‘mammal’)
mammal.cold_or_warm_blooded()

reptile=reptiles(‘snake’,‘Reptiles’)
reptile.print_type()

#4

class Animal_Kingdom:

def __init___(self, name, species, make_sound)
self.name = name
self.species = species
self.make_sound = make_sound

class mammal(Animal_Kingdom):
def init(self, name, species, make_sound)
super init(name, species, make_sound)

self.reproduce = mamalry
self.blood = warm

def print_details(self):
    print("mamal_name:{} species:{} make_sound:{} reproduce:{} blood{} ".format(self.name,self.species,self.make_sound,self.mamalry,self.warm))

class bird(Animal_Kingdom):
def init(self, name, species, make_sound)
super init(name, species, make_sound)

self.reproduce = eggs
self.blood= warm
self.skin = has_feathers

def print_details(self):
    print("Bird_name:{} species:{} make_sound:{} reproduce:{} blood{} skin{}".format(self.name,self.species,self.make_sound,self.eggs,self.warm,self.has_feathers))

class fish(Animal_Kingdom):
def init(self, name, species, make_sound)
super init(name, species, make_sound)

self.reproduce = eggs
self.blood= warm
self.skin = has_gills

def print_details(self):
print(“Fish_name:{} species:{} make_sound:{} reproduce:{} blood{} skin{}”.format(self.name,self.species,self.make_sound,self.eggs,self.warm,self.has_gills))

#5

Solution

class Animal:

def __init__(self,food_type,species):
    self.species = species
    self.food_consumed = food_type

def reproduces(self):
    print("{} is reproducing ".format(self.species))

def eat(self):
    print("{} is eating ".format(self.species))

def breathe(self):
    print("{} is breathing ".format(self.species))

def move(self):
    print("{} is moving ".format(self.species))

class Mammals(Animal):

def __init__(self,species,food_type):
    super().__init__(food_type,species)
    self.blood_type = "warm blooded"
    self.is_mammary_gland = True
    self.vertebrate = True
    self_heart_type = "four chambered"
    
def feed_baby(self):
    print("{}  is feeding its baby".format(self.species))

class Bird(Animal):

def __init__(self,species,food_type,can_fly):
    super().__init__(food_type,species)
    self.has_feather = True
    self.can_fly = can_fly
    
def fly(self):
    if self.can_fly==True:
        print("{} is flying".format(self.species))
    else:
        print("{} cannot fly".format(self.species))