Question

我正在尝试编写一个可以解决算术运算的代码。课程mult和plus旨在解决以下问题：

e1 = mult(const(3),const(4))
e1 = plus(const(3),const(4)

并返回结果（分别为12和7）

现在，讲师的任务要求我们编写可以解决这样问题的程序：

e1 = mult(plus(const(3),const(4)),const(5)) # should print 35
e2 = plus(mult(const(3),const(4)),const(5)) # should print 12

我尝试使用列表解决问题，以便将常量存储在列表中（即store_const），然后类mult(const(n),const(n))和plus(const(n),const(n))将解决问题并返回结果。我的问题是针对每个班级mult / plus，我创建的方法eval增加或增加store_const[0]和[1]，但每次我运行程序：e1返回12，e2返回7

我认为这是因为mult / plus只取store_const[0] = 3和store_const[1] = 4而遗漏store_const[2] = 5。

那么我该如何解决这个问题：

e1 = mult(plus(const(3),const(4)),const(5))

其中plus的结果存储为新的const(n)，然后mult类可以执行以产生35k

这是我的代码：

class expr(object): #ignore class
   pass


class const(expr):
   store_const = [] #list to store constants

   def __init__(self, n): #initial constructor
       self.n = n
       const.store_const.append(self.n) #store constants in list


class binOp(expr): #sublcass of expr

   def __init__(self, expr1, expr2): #initial constructor arguments
      self.expr1 = expr1
      self.expr2 = expr2

class mult(binOp):
   def __int__(self, *args):
      super(mult, self).__init__(*args) #inheriting the superclass constructor arguments

   def eval(self):
      self.expr1 = const.store_const[0]
      self.expr2 = const.store_const[1]
      self.result = self.expr1 * self.expr2
      return self.result


class plus(binOp):
   def __init__(self, *args):
      super(plus, self).__init__(*args) #inheriting the superclass constructor arguments

   def eval(self):
      self.expr1 = const.store_const[0] #assigning the 1st elem of list to expr1
      self.expr2 = const.store_const[1] #assigning the 2nd elem of list to expr2
      self.result1 = self.expr1 + self.expr2
      return self.result1

#input
e1 = mult(plus(const(3), const(4)),const(5))
print e1.eval()
e2 = plus(mult(const(3), const(4)),const(5))
print e2.eval()

#output
12
7

Answer 1

如果为const类提供eval方法，则不需要将consts存储在外部集合中。此外，您的binOp eval方法必须在其左右参数上递归调用eval。

class expr(object): #ignore class
   pass


class const(expr):
   store_const = [] #list to store constants

   def __init__(self, n): #initial constructor
       self.n = n
   def eval(self):
       return self.n

class binOp(expr): #sublcass of expr

   def __init__(self, expr1, expr2): #initial constructor arguments
      self.expr1 = expr1
      self.expr2 = expr2

class mult(binOp):
   def __int__(self, *args):
      super(mult, self).__init__(*args) #inheriting the superclass constructor arguments

   def eval(self):
      return self.expr1.eval() * self.expr2.eval()


class plus(binOp):
   def __init__(self, *args):
      super(plus, self).__init__(*args) #inheriting the superclass constructor arguments

   def eval(self):
      return self.expr1.eval() + self.expr2.eval()

#input
e1 = mult(plus(const(3), const(4)),const(5))
print e1.eval()
e2 = plus(mult(const(3), const(4)),const(5))
print e2.eval()

结果：

35
17

Answer 2

我尝试使用列表解决问题，以便将常量存储在列表中

我认为这是您怀疑的问题：

我认为这是因为mult / plus只占用store_const [0] = 3而store_const [1] = 4并且省略了store_const [2] = 5

由于这显然是一项任务，而你几乎就在那里，我只会给你提示：

您不需要存储const。您可以使用.n：

访问它们

>>> x = const(3)
>>> y = const(4)
>>> x.n
3
>>> y.n
4

在eval方法中，您必须＆＃34;猜测＆＃34;什么是expr1和expr2的类，如果它是.eval或mult和plus，如果它是.n，则调用const。在伪代码中：

if expr1 is a const:
   new_expr1 = expr1.n
else:
   new_expr1 = expr1.eval()
if expr2 is a const:
   new_expr2 = expr2.n
else:
   new_expr2 = expr2.eval()
result = new_expr1 + new_expr2 #or * in the mult class

但你必须为2 expr（1和2）做到这一点并且有一种更好的方法：正如你可能猜测const是否有eval方法返回.n那么你就不必猜测＆＃34;并且可以self.expr1.eval()+self.expr2.eval()（或*用于课程mult）。

self.expr1.eval()将返回.n作为常量，或者返回mult / plus操作的结果。

我如何在类属性上使用算术运算？

2 个答案: