1. 表达式计算（2人） 对输入的表达式按C语言的规则进行计算，具体要求如下： 1）只针对以下二元运算符：+、-、*、/、以及小括号。 2）可以判断表达式中()是否匹配。 3）运算数为位数不固定的十进制整数常量。 4）扩展功能：表达式中包含有变量时，如何处理？ 5）演示时，可以多次输入表达式，每次对表达式都进行1-4步骤的运算。

好的，我来和你一起完成这个项目。首先我们需要分析一下这个项目的需求，然后再逐步实现。

1. 读入表达式并判断括号是否匹配

我们需要读入一个字符串，然后判断其中的括号是否匹配。这可以通过栈来实现，具体步骤如下：

1. 初始化栈。
2. 从左到右遍历字符串中的每个字符。
3. 如果遇到左括号，将其入栈。
4. 如果遇到右括号，判断栈顶元素是否为左括号，如果是则将栈顶元素出栈，否则说明括号不匹配。
5. 遍历完成后，如果栈为空，则说明括号匹配，否则说明有未匹配的左括号。

代码如下：

def check_parentheses(s):
    stack = []
    for c in s:
        if c == '(':
            stack.append(c)
        elif c == ')':
            if not stack or stack[-1] != '(':
                return False
            stack.pop()
    return not stack

2. 中缀表达式转后缀表达式

我们需要将中缀表达式转换成后缀表达式，并同时处理运算符的优先级。这可以通过栈和队列来实现，具体步骤如下：

1. 初始化栈和队列。
2. 从左到右遍历字符串中的每个字符。
3. 如果遇到数字，将其加入队列。
4. 如果遇到左括号，将其入栈。
5. 如果遇到右括号，则将栈中的元素依次弹出并加入队列，直到遇到左括号为止。
6. 如果遇到运算符，将其与栈顶元素比较优先级，如果栈顶元素优先级不低于当前运算符，则将栈顶元素弹出并加入队列，重复此步骤直到栈为空或栈顶元素优先级低于当前运算符，然后将当前运算符入栈。
7. 遍历完成后，将栈中的元素依次弹出并加入队列。

代码如下：

def infix_to_postfix(s):
    stack = []
    queue = []
    precedence = {'+': 1, '-': 1, '*': 2, '/': 2}
    for c in s:
        if c.isdigit():
            queue.append(c)
        elif c == '(':
            stack.append(c)
        elif c == ')':
            while stack and stack[-1] != '(':
                queue.append(stack.pop())
            stack.pop()
        elif c in precedence:
            while stack and stack[-1] != '(' and precedence[stack[-1]] >= precedence[c]:
                queue.append(stack.pop())
            stack.append(c)
    while stack:
        queue.append(stack.pop())
    return queue

3. 计算后缀表达式的值

我们需要计算后缀表达式的值，这可以通过栈来实现，具体步骤如下：

1. 初始化栈。
2. 从左到右遍历后缀表达式中的每个元素。
3. 如果遇到数字，将其入栈。
4. 如果遇到运算符，则从栈中弹出两个元素，并根据运算符进行计算，将结果入栈。
5. 遍历完成后，栈中只剩下一个元素，即为表达式的值。

代码如下：

def evaluate_postfix(queue):
    stack = []
    for c in queue:
        if c.isdigit():
            stack.append(int(c))
        else:
            b = stack.pop()
            a = stack.pop()
            if c == '+':
                stack.append(a + b)
            elif c == '-':
                stack.append(a - b)
            elif c == '*':
                stack.append(a * b)
            elif c == '/':
                stack.append(a // b)
    return stack.pop()

4. 处理变量

如果表达式中包含变量，我们需要先将变量替换成对应的值，然后再按照上述步骤计算表达式的值。这可以通过字典来实现，具体步骤如下：

1. 初始化字典。
2. 读入表达式并找出其中的变量。
3. 依次输入变量的值，并将其存入字典。
4. 将表达式中的变量替换成对应的值。
5. 按照上述步骤计算表达式的值。

代码如下：

def replace_variables(s, var_dict):
    for var in var_dict:
        s = s.replace(var, str(var_dict[var]))
    return s

完整代码如下：

def check_parentheses(s):
    stack = []
    for c in s:
        if c == '(':
            stack.append(c)
        elif c == ')':
            if not stack or stack[-1] != '(':
                return False
            stack.pop()
    return not stack

def infix_to_postfix(s):
    stack = []
    queue = []
    precedence = {'+': 1, '-': 1, '*': 2, '/': 2}
    for c in s:
        if c.isdigit():
            queue.append(c)
        elif c == '(':
            stack.append(c)
        elif c == ')':
            while stack and stack[-1] != '(':
                queue.append(stack.pop())
            stack.pop()
        elif c in precedence:
            while stack and stack[-1] != '(' and precedence[stack[-1]] >= precedence[c]:
                queue.append(stack.pop())
            stack.append(c)
    while stack:
        queue.append(stack.pop())
    return queue

def evaluate_postfix(queue):
    stack = []
    for c in queue:
        if c.isdigit():
            stack.append(int(c))
        else:
            b = stack.pop()
            a = stack.pop()
            if c == '+':
                stack.append(a + b)
            elif c == '-':
                stack.append(a - b)
            elif c == '*':
                stack.append(a * b)
            elif c == '/':
                stack.append(a // b)
    return stack.pop()

def replace_variables(s, var_dict):
    for var in var_dict:
        s = s.replace(var, str(var_dict[var]))
    return s

def main():
    var_dict = {}
    while True:
        s = input('请输入表达式：')
        if not s:
            break
        if not check_parentheses(s):
            print('括号不匹配')
            continue
        if any(c.isalpha() for c in s):
            var = input('请输入变量的值：')
            var_dict[s.split('=')[0].strip()] = var
            s = s.split('=')[1].strip()
            s = replace_variables(s, var_dict)
        queue = infix_to_postfix(s)
        value = evaluate_postfix(queue)
        print(value)

if __name__ == '__main__':
    main()

这样，我们就完成了对输入的表达式按C语言的规则进行计算的项目。