构造一个解释器语言，使得系统可以对个位数的算术表达式的表达式进行语法检查并解释运行。例如：用户输入表达式“3 *(4+2)/ 4”，输出结果为4。

好的，我可以帮您构造一个解释器语言来实现这个功能。这个解释器语言可以解释包含加、减、乘、除四则运算的个位数算术表达式，并输出计算结果。

首先，我们需要定义语法规则。一个简单的语法规则可以是：

expression -> term ((ADD | SUB) term)*
term -> factor ((MUL | DIV) factor)*
factor -> INTEGER | LPAREN expression RPAREN

其中，`ADD`、`SUB`、`MUL`、`DIV`分别表示加、减、乘、除运算符，`LPAREN`、`RPAREN`表示左右括号，`INTEGER`表示整数常量。

然后，我们可以通过递归下降解析器来解析这个语法规则。具体实现可以参考下面的代码：

class Interpreter:
    def __init__(self, text):
        self.text = text
        self.pos = 0
        self.current_token = None
    
    def error(self):
        raise Exception("Invalid syntax")
    
    def get_next_token(self):
        text = self.text
        if self.pos >= len(text):
            return Token(EOF, None)
        
        current_char = text[self.pos]
        if current_char.isdigit():
            value = int(current_char)
            self.pos += 1
            return Token(INTEGER, value)
        elif current_char == '+':
            self.pos += 1
            return Token(ADD, '+')
        elif current_char == '-':
            self.pos += 1
            return Token(SUB, '-')
        elif current_char == '*':
            self.pos += 1
            return Token(MUL, '*')
        elif current_char == '/':
            self.pos += 1
            return Token(DIV, '/')
        elif current_char == '(':
            self.pos += 1
            return Token(LPAREN, '(')
        elif current_char == ')':
            self.pos += 1
            return Token(RPAREN, ')')
        
        self.error()
        
    def eat(self, token_type):
        if self.current_token.type == token_type:
            self.current_token = self.get_next_token()
        else:
            self.error()
    
    def factor(self):
        token = self.current_token
        if token.type == INTEGER:
            self.eat(INTEGER)
            return token.value
        elif token.type == LPAREN:
            self.eat(LPAREN)
            result = self.expression()
            self.eat(RPAREN)
            return result
    
    def term(self):
        result = self.factor()
        while self.current_token.type in (MUL, DIV):
            token = self.current_token
            if token.type == MUL:
                self.eat(MUL)
                result = result * self.factor()
            elif token.type == DIV:
                self.eat(DIV)
                result = result / self.factor()
        return result
    
    def expression(self):
        result = self.term()
        while self.current_token.type in (ADD, SUB):
            token = self.current_token
            if token.type == ADD:
                self.eat(ADD)
                result = result + self.term()
            elif token.type == SUB:
                self.eat(SUB)
                result = result - self.term()
        return result
    
    def interpret(self):
        self.current_token = self.get_next_token()
        return self.expression()

使用这个解释器可以很方便地计算出输入表达式的结果，只需要调用`interpret()`方法即可。例如：

interpreter = Interpreter("3*(4+2)/4")
result = interpreter.interpret()
print(result)  # 输出4