Question

Write three object-oriented classes to simulate your own kind of team in which a senior member type can give orders to a junior member type object, but both senior and junior members are team members. So, there is a general team member type, but also two specific types that inherit from that general type: one senior and one junior.

Write a Python object-oriented class definition that is a generic member of your team. For this writeup we call it X.

It captures the data and actions that are common to all team members. The team member class is not specific to any kind of team member. Name the class appropriately for its purpose. It defines what is common about all team members, for example a string variable to hold a name.

This class definition must include the following:

Define a constructor function to create objects built from this class. The statements in the block of this function must declare and initialize all TeamMember class variables.

Declare and initialize a class data variable to hold the name of the character as a string. Set its initial value to an empty string.

Define another Python class that inherits from the team member class X, so it will get all data and functions from X For this writeup we will call this class SeniorX. This class is a more specific type of team member that is senior ranking Name the class appropriately for its purpose.

This class definition must include the following:

One function as a constructor. In the block declare/initialize all class data variables, defined here or inherited.

Declare/initialize a data variable that means something unique to this type of team member (your choice).

Define a function for giving an order to a junior member this function accepts as parameter a junior team member type object.

In the indented block of statements do the following:

Print out the order being given (a string. You can use a constant string like ’Do a push up’), and the name of the junior member that will receive the order.

Call the order receiving function on the junior member object, passing in the order.

Define another Python class that inherits from the team member class X For this writeup we will call this class JuniorX. This class is a more specific type of team member that is a junior team member who takes orders from senior members.

The indented block for this function must include:

One constructor function. The block of statements for this function must set the value of all class data variables, defined here or inherited.

In the constructor declare/initialize one data variable unique to this type of team member (your choice).

Define a function for receiving an order from a senior member: This function accepts as parameter a string of orders. In the statement block for this function definition complete the order by printing it out along with the name of the junior member who is completing the order.

Outside and after your class definitions, write a main function definition to demonstrate using the classes. Its header line would be like def main (): In the indented block for main, write statements that do the following:

• Call the senior team member constructor function to create a senior team member object and save it in a variable.

• Call the junior team member constructor function to create a junior team member object and save it in a variable.

• Call the order giving function from a senior member object, passing in the junior member object.

Finally, using SQL figure out how to save one of your objects into a database within your code’s directory and then retrieve it back out of the database, then print out its contents.

Answer 1

So the task in hand is to create three classes such that :

• one is a generic class (TeamMember) which will store the basic information about a member of the team .
• two derived class inheriting the base class and assigning unique identifier to each of them.
• JuniorMember class has a function recieveorder which takes a string as order and prints it.
• SeniorMember class has a function give_order which takes a juniormember class object as parameter, asks the user for order and class the recieveorder function of juniormember class.
• use database to store the objects and retrieve the same. U can un-comment the code to use db functionality. We are using sqlalchemy package to store an object into the database and retrieve the same.Please note to change the path/url of database in the create_engine statement,.

the code for the same is :

Online Python Compiler -online x С https://www.onlinegdb.com/online-python-compiler 出Apps Dashboard Hacker G Geeksfo Geeks Ac D python Numpy Tuto D python Numpy Tutc OTp5Object Oriente e Expert Q&A Chegg <> Online Java Compile lineC--Compile RunDebugStop Share H Save Beautify Language Python 3 main.py 46 47 48 49 def get_name (self): print("Name: "+ self.fn+" "+self.ln) def get age(self input Adam Friak age: 18 : John Snow age: 12 Enter the order you want to give to John Snow: do 10 pushups John Snow has recieved order as: do 10 puahups ..Program finished with exit code 0 8s ENTER to exit console Activate Windows Go to Settings to activate Windo et,曲 9轰@ 210 AM
text code for the same is :

#uncomment below to use db fucntions.
"""from sqlalchemy import Column, Integer,String
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

#uncomment these lines to create a database:
#engine = create_engine('mysql://user:password@server')
#engine.execute("CREATE DATABASE dbname")
#engine.execute("USE dbname")

engine = create_engine('mysql:////folder/databasename') #to connect to the already formed database.
Base = declarative_base(bind=engine) #to bind the database and engine api.

class Member(Base): #class to fill the column of our table.
__tablename__ = 'member'
mid = Column(Integer, primary_key=True)
fn = Column(String(20))
ln = Column(String(20))
age = Column(Integer) #to set the attribute types.

def __init__(self, senior):
self.mid = senior.mid
self.fn = senior.fn
self.ln = senior.ln
self.age = senior.age #sets the attribute values.
  

Base.metadata.create_all() #creates the schema / table for above mentioned table specification.

Session = sessionmaker(bind=engine) #creates a session to run the add or retrieve.
s = Session() """

class TeamMember: #creates a generic class
def __init__(self,mid,fn,ln,age): #constructor to initialize basic details like id , name , age
self.mid = mid
self.fn = fn
self.ln = ln
self.age = age
self.year = "" #unique identifier for senior or junior type member (string)
  
def get_mid(self): #fucntion to print id.
print("MemberId: "+str(self.mid))
  
def get_name(self): #function to print name
print("Name: "+self.fn+" "+self.ln)
  
def get_age(self): #function to print age
print("age: "+str(self.age))
  
def __repr__(self): #string reputation built-in function to return year as string.
return self.year
  
class SeniorMember(TeamMember): #SeniorMember class inheriting TeamMember class
def __init__(self,mid ,fn,ln,age):   
super().__init__(mid,fn,ln,age) #calling super class constructor
self.year = "Senior" #assigning unique identifier.
  
  
  
def give_order(self,junior): #fucntion to give order to junior member
order = input("Enter the order you want to give to "+junior.fn+" "+junior.ln+": ") #taking order as input.
junior.recieveorder(order) #calling recieveorder fucntion of JuniorMember class.
  
class JuniorMember(TeamMember): #JuniorMember class inheriting TeamMember class to represent junior memeber.
def __init__(self,mid,fn,ln,age):
super().__init__(mid,fn,ln,age)
self.year = "Junior" #assigning unqiue identifier.
  
def recieveorder(self,order): #function to take an order as string and print it.
print(self.fn+" "+self.ln+" has recieved order as: "+str(order))  
  
  
def main(): #driver fucntion.
adam = SeniorMember(1,"Adam","Frisk",18) #creating an objec of SeniorMember class.
john = JuniorMember(2,"John","Snow",12) #creating an objec of JuniorMember class.
adam.get_name() #getting name and other details.
adam.get_age()
print(adam)
john.get_name()
john.get_age()
print(john)
adam.give_order(john) #calling give_order function through adam object and passing john as JuniorMember class object.
  
#uncomment below code to use db functions.   
# ad = Member(adam) #creating an objec of Member class and passing the SeniorMember class object to store.
# s.add_all(ad) #creating a list of objects to be stored
# s.commit() # adding to the database.
# for m in s.query(Member): #for all the objects stored in member class / table
# print(str(m.mid)+" "+m.fn+" "+m.ln+" "+str(m.age)) #prints the information from the db
  
main()