Question

class Bool(Expr):
"""A boolean constant literal.

=== Attributes ===
b: the value of the constant
"""
b: bool

def __init__(self, b: bool) -> None:
"""Initialize a new boolean constant."""
self.b = b

# TODO: implement this method!
def evaluate(self) -> Any:
"""Return the *value* of this expression.

The returned value should the result of how this expression would be
evaluated by the Python interpreter.

>>> expr = Bool(True)
>>> expr.evaluate()
True
"""
return self.b

def __str__(self) -> str:
"""Return a string representation of this expression.

One feature we'll stick with for all Expr subclasses here is that we'll
want to return a string that is valid Python code representing the same
expression.

>>> str(Bool(True))
'True'
"""
return str(self.b)

class BoolOp(Expr):
"""A boolean operation.

Represents either a sequences of `and`s or a sequence of `or`s.
Unlike BinOp, this expression can contains more than two operands,
each separated by SAME operator:

True and False and True and False
True or False or True or False

=== Attributes ===
op: the name of the boolean operation
values: a list of operands that the operation is applied to

=== Representation invariants ===
- self.op == 'and' or self.op == 'or'
- len(self.values) >= 2
- the expressions in self.values all evaluate to boolean values.
"""
op: str
values: List[Expr]

def __init__(self, op: str, values: List[Expr]) -> None:
"""Initialize a new boolean operation expression.

Precondition: op == 'and' or op == 'or' and the expressions in
self.values all evaluate to boolean values.
"""
self.op = op
self.values = values

# TODO: implement this method!
def evaluate(self) -> Any:
"""Return the *value* of this expression.

The returned value should the result of how this expression would be
evaluated by the Python interpreter.

>>> expr = BoolOp('and', [Bool(True), Bool(True), Bool(False)])
>>> expr.evaluate()
False
"""

help me with evaluate plz

Answer 1

Summary :

   python code and output are shown as exhibit and also code is pasted text form.

Note : evaluate is implmented in recursive function which closures when there are 2 parameters .

########################## python Code #######################

from typing import Any
from typing import List
from _ast import Expr

class Bool(Expr) :
    def __init__(self, b: bool) -> None:
        self.b = b

    def evaluate(self) -> Any:
        return self.b

    def __str__(self) -> str:
        return str(self.b)

class BoolOp(Expr):

    def __init__(self, op: str, values: List[Expr]) -> None:
        self.op = op
        self.values = values
        #print (" op :" , op )
        #print (" List ", values)
      
      
    def evaluate(self) -> Any:
        str1 =""
        if (len(self.values) == 2) :
            str1 = self.values[0].__str__() + " " + str(self.op) + " " + self.values[1].__str__()
            #print(" Eval0 : ",str1)
            return eval(str1)
        else :
            tmp = BoolOp(self.op,self.values[1:])
            str1 = self.values[0].__str__() + " " + str(self.op) + " " + str(tmp.evaluate())
            #print(" Eval1 : ",str1)
            return eval(str1)
  
if __name__ == '__main__':
    expt = Bool(True)
    expf = Bool(False)
    print(" T ", expt , " Evl ", expt.evaluate() , " STR ", expt.__str__())
    print(" T ", expf , " Evl ", expf.evaluate() , " STR ", expf.__str__())
  
    expr = BoolOp('or', [Bool(True), Bool(True), Bool(False), Bool(False), Bool(True)])
    expr1 = expr.evaluate()
    print("BoolOp OR :", expr1)
  
    expr = BoolOp('and', [Bool(True), Bool(True), Bool(False)])
    expr1 = expr.evaluate()
    print("BoolOp And :", expr1)

#####################End Code #######################

####################### Exhibit ###########################