1.编写一个程序实现顺序栈的各种基本运算。 2.写一个普通算术代表式，其中操作数为整数，运算符不少8个（含一对括号），四则运算至少各一个，改成后缀表达式，输入后缀表达式，实现后缀表达式的计算。

1. 实现顺序栈的基本运算是常见的计算机科学练习之一，通常会包括以下几个函数：

class Stack:
    def __init__(self):
        self.items = []

    # 入栈
    def push(self, item):
        self.items.append(item)

    # 出栈
    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        else:
            return None

    # 查看栈顶元素
    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        else:
            return None

    # 判断栈是否为空
    def is_empty(self):
        return len(self.items) == 0

    # 打印栈内容
    def print_stack(self):
        print(self.items)

你可以通过创建这个栈对象并调用上述方法来进行压入、弹出、查看栈顶等操作。

2. 将普通算术表达式转换为后缀表达式（也称为逆波兰表示法），可以采用递归的方式，具体步骤如下：

def infix_to_postfix(expression):
    precedence = {'+': 1, '-': 1, '*': 2, '/': 2, '(': 0}  # 定义运算符优先级
    output = []  # 后缀表达式结果
    stack = []  # 运算符堆

    for char in expression:
        if char.isdigit():  # 如果是数字，直接添加到结果
            output.append(char)
        elif char in precedence:  # 如果是运算符
            while stack and precedence[char] <= precedence[stack[-1]]:
                output.append(stack.pop())
            stack.append(char)
        elif char == ')':  # 遇到右括号，将左括号和内部操作数依次加入结果
            while stack[-1] != '(':
                output.append(stack.pop())
            stack.pop()  # 移除左括号
        else:  # 非法字符，跳过
            pass

    # 结束遍历后，将剩余运算符全部加入结果
    while stack:
        output.append(stack.pop())

    return ''.join(output)

# 示例
expression = "3 + 4 * ( 5 - 6 ) / 7"
postfix_expression = infix_to_postfix(expression)
print(f"后缀表达式: {postfix_expression}")

# 计算后缀表达式
def evaluate_postfix(expression):
    stack = []
    operators = {
        '+': lambda x, y: x + y,
        '-': lambda x, y: x - y,
        '*': lambda x, y: x * y,
        '/': lambda x, y: x / y,
    }

    for token in expression:
        if token.isdigit():
            stack.append(int(token))
        else:
            y = stack.pop()
            x = stack.pop()
            result = operators[token](x, y)
            stack.append(result)

    return stack.pop()

result = evaluate_postfix(postfix_expression)
print(f"计算结果: {result}")