Kann nicht eine Ausgabe Python Klassen und Funktionen Code

Question

Ich vor kurzem eingereicht diese Hausaufgabe, konnte aber nicht den Code der beiden Probleme arbeiten. Ich würde gerne wissen, was ich hätte tun können, um sicherzustellen, dass ich es das nächste Mal richtig mache.

Frage 1 (5 Punkte) Erstellen Sie eine Basis/Elternklasse namens 'InterestCalculator'. Erstellen Sie eine Kindklasse namens "CICalculator". Die Klasse 'CICalculator' hat nur einen Elternteil, den 'InterestCalculator'. Erstellen Sie eine Kindklasse namens "SICalculator". Die Klasse "SI" wird nur einen Elternteil haben, den "InterestCalculator". Die Elternklasse muss eine init Methode haben, die alle Werte initialisiert, die für die Berechnung und Speicherung von Zinsen benötigt werden.

Die untergeordnete Klasse 'CICalculator' und 'SICalculator' müssen die Methode 'calcfinalval' implementieren, die den endgültigen Wert für jeden Fall berechnet.

Zinseszins ist gegeben durch A = p * (1+ (r/(n * 100)))^(n * t) wobei p die Hauptmenge, r die Zinsrate und t die Zeit in ist Jahre und n ist die Anzahl der jährlichen Zinserhöhungen und A ist der Gesamtbetrag nach t Jahren. sei angenommen, n = 2.

Einfache Interesse von einem A = P (1 + (r * t/100) gegeben ist, wobei p die Haupt, r der Zinssatz ist und t die Zeit in Jahren, und A die Gesamtmenge nach t Jahren.

nachdem alle Klassen definiert, um den Anruf des Endwert zu berechnen und drucken müssen Sie den Code unten folgen.

c = CICalculator(2,0.1,1000) 
    c.calcfinalval() 
    print c.finalval 

    s = SICalculator(2,0.1,1000) 
    s.calcfinalval() 
    print s.finalval 

# Lösung 1

class InterestCalculator: 
    def __init__(self, A, p, r, y, t): 
     self.A = A 
     self.p = p 
     self.r = r 
     self.y = y 
     self.t = t 

    def calcfinalval(self): 
    return "Interest Rates" 


class CICalculator(InterestCalculator): 
    def __init__(self, A, p, r, y, t): 
    self.A = self.p*(1+(self.r/(self.t*100)))^(self.t*self.y) 

class SICalculator(InterestCalculator): 
    def __init__(self, A, p, r, y): 
    self.A = self.p(1+(self.r*self.y/100) 

c = CICalculator(2,0.1,1000) 
c.calcfinalval() 
print c.finalval 

s = SICalculator(2,0.1,1000) 
s.calcfinalval() 
print s.finalval 

Frage 2 (5 Punkte) Eine Warteschlange folgt FIFO (first-in, first-out). FIFO ist der Fall, in dem das erste hinzugefügte Element das erste Element ist, das abgerufen werden kann. Betrachten Sie eine Liste mit Werten [1,2,3]. Erstellen Sie eine Klasse namens MyQueue, die zwei Methoden aufweist: queueadd und queueretrieve, um Elemente aus der Liste in FIFO-Reihenfolge hinzuzufügen bzw. abzurufen. Nach jedem Funktionsaufruf drucken Sie den Inhalt der Liste. Fügen Sie der Warteschlange 7 hinzu und folgen Sie dann den FIFO-Regeln , um ein Element abzurufen.

zur Klasse Ihr Anruf wird wie folgt sein auf a = [1,2,3] q = myQueue (a) q.queueadd (7) q.queueretrieve()

Das Ausgangs der Bildschirm sollte ähnlich wie

1 2 3 7 
    2 3 7 
    3 7 
    7 

# Lösung 2

class MyQueue: 

    def __init__(self): 
    self.in_stack = [] 
    self.out_stack = [] 

    def queueadd(self, obj): 
    self.in_stack.append(obj) 

    def queueretrieve(self): 
    if not self.out_stack: 
     while self.in_stack: 
      self.out_stack.append(self.in_stack.pop()) 
    return self.out_stack.pop() 

    a = [1,2,3] 
    q = MyQueue(a) 
    q.queueadd(7) 
    q.queueretrieve() 

Answer 1

Es gibt viele Fehler in Ihrem Code. Die meisten davon sind Einzugfehler. Ich habe nur die Fehler sortiert, der Kernalgorithmus, den Sie implementieren wollten, ist unverändert.

class InterestCalculator: 
    def __init__(self, p, r,t,n=1,A=0): 
    self.A = A 
    self.p = p 
    self.r = r 
    self.n = n 
    self.t = t 

class CICalculator(InterestCalculator): 
    def __init__(self, p, r, t, n=1, A=0): 
    InterestCalculator.__init__(self,p,r,t,n) 

    def calcfinalval(self): 
    self.A = self.p*(1+ self.r/ (self.n*100))**(self.n*self.t) 
    return self.A 

class SICalculator(InterestCalculator): 
    def __init__(self, p, r, t): 
    InterestCalculator.__init__(self,p,r,t) 

    def calcfinalval(self): 
    self.A = self.p*(1+(self.r*self.t/100)) 
    return self.A 

c = CICalculator(2,0.1,1000) 
c.calcfinalval() 
print c.A 

s = SICalculator(2,0.1,1000) 
s.calcfinalval() 
print s.A 

Für das zweite Problem

class MyQueue: 
    def __init__(self,in_stack): 
    self.in_stack = in_stack 
    self.out_stack = [] 

    def queueadd(self, obj): 
    self.in_stack.append(obj) 

    def queueretrieve(self): 
    if not self.out_stack: 
     while self.in_stack: 
     self.out_stack.append(self.in_stack.pop()) 
    return self.out_stack.pop() 

a = [1,2,3] 
q = MyQueue(a) 
q.queueadd(7) 

print (q.queueretrieve()) 
print (q.queueretrieve()) 
print (q.queueretrieve()) 
print (q.queueretrieve()) 

Answer 2

Ein Weg Q1 in ähnlicher Weise zu implementieren, die Sie in Lösung implementiert haben 1:

class InterestCalculator: 
    def __init__(self,p, r, y, t): 
     self.p = p 
     self.r = r 
     self.y = y 
     self.t = t 

class CICalculator(InterestCalculator): 
    def __init__(self,InterestCalculator): 
     self.p=InterestCalculator.p 
     self.r=InterestCalculator.r 
     self.y=InterestCalculator.y 
     self.t=InterestCalculator.t 
    def calcfinalval(self): 
     val = self.p*(1+(self.r/(self.t*100.0)))**(self.t*self.y) 
     return val 

class SICalculator(InterestCalculator): 
    def __init__(self,InterestCalculator): 
     self.p=InterestCalculator.p 
     self.r=InterestCalculator.r 
     self.y=InterestCalculator.y 
    def calcfinalval(self): 
     val = self.p*(1+(self.r*self.y/100.0)) 
     return val 

#Initialize an interestcalculator object 
IC = InterestCalculator(1000,1,10,4) 

#Create a CICalculator object 
CI = CICalculator(IC) 
print CI.calcfinalval() 

SI = SICalculator(IC) 
print SI.calcfinalval() 

Allerdings gibt es viele Feinheiten, die ich in diesem Code geändert habe, und ich würde vorschlagen, mit jemandem zu sitzen, der dieses Zeug kennt, wenn Sie ernsthaft Python lernen wollen.