Python 使用太多运算符验证后缀

我正在计算一个后缀表达式，我需要它说明，如果一个接一个的运算符太多，则无法计算该表达式。我知道堆栈中没有任何内容，因此无法对其求值，但我不知道如何将其添加到代码中

我只在这里添加了我认为必要的代码。如果代码可以保持相对相似，那就太好了

编辑：现在只是说任何东西都不能被评估

def过程（测试线、计数）： k=[] 对于范围内的i（0，len（测试线），1）： 如果（测试线[i].isdigit（）==True）： k、 追加（浮点（测试线[i]）） 其他： 尝试： x=j.pop（） y=j.pop（） 除索引器外： 打破 如果（测试线[i]='*'）： ans=x*y k、 附加（ans） elif（测试线[i]='+'）： ans=x+y k、 附加（ans） elif（测试线[i]='-'）： ans=x-y k、 附加（ans） elif（测试线[i]='/'）： ans=x/y k、 附加（ans） 其他： 打印（“行”，计数，“无法评估”） 返回 如果len（k）！=1: 打印（“行”，计数，“无法评估”） 其他： 打印（'Line'，count，'result is'，k[0]） 返回 打印（'Line'，count，'result is'，k[0]） 现在，输出是：

    Line 1 is not able to be evaluated
    Line 2 is not able to be evaluated
    Line 3 is not able to be evaluated
    Line 4 is not able to be evaluated

('Line', 1, 'result is', 25.0)
('Line', 2, 'result is', -4.0)
('Line', 3, 'is not able to be evaluated')
('Line', 4, 'is not able to be evaluated')
('Line', 5, 'is not able to be evaluated')
('Line', 6, 'is not able to be evaluated. not enough operands')

输入为：

    295+*3-
    61*7-4*
    61*79-15*
    6a*7-b*
    623-+*-1

---

您可以将您的

pop

s移动到迭代开始处，并用

try/except

环绕以检查您是否可以弹出：

用于范围内的i（0，len（测试线），1）：
如果（测试线[i].isdigit（）==True）：
k、 追加（浮点（测试线[i]））
其他：
尝试：
x=k.pop（）
y=k.pop（）
除索引器外：
打破
如果（测试线[i]='*'）：
ans=x*y
k、 附加（ans）
elif（测试线[i]='+'）：
ans=x+y
k、 附加（ans）
elif（测试线[i]='-'）：
ans=x-y
k、 附加（ans）
elif（测试线[i]='/'）：
ans=x/y
k、 附加（ans）
其他：
打印（“行”，计数，“无法评估”）
返回

为了使它更加健壮，并且不需要添加额外的

附件，我将执行以下操作：

operators={'*'：lambda x，y:x*y，
“/”：λx，y:x/y，
“+”：λx，y:x+y，
“-”：λx，y:x-y}
对于测试行中的c：
如果c.isdigit（）：
k、 附加（浮动（c））
操作员中的elif c：
尝试：
x=k.pop（）
y=k.pop（）
除索引器外：
打破
ans=运算符[c]（x，y）
k、 附加（ans）
其他：
打印（“行”，计数，“无法评估”）
返回

编辑：更简单：

operators={'*'：lambda x，y:x*y，
“/”：λx，y:x/y，
“+”：λx，y:x+y，
“-”：λx，y:x-y}
对于测试行中的c：
如果c.isdigit（）：
k、 附加（浮动（c））
其他：
尝试：
x=k.pop（）
y=k.pop（）
ans=运算符[c]（x，y）
k、 附加（ans）
除了索引器：#无法弹出。。。（空堆栈）
打破
除了KeyError:#char不是数字，也不是运算符
打印（“行”，计数，“无法评估”）
返回
您可以将
弹出窗口
移动到迭代开始处，并用
try/except
环绕，以检查是否可以弹出：

用于范围内的i（0，len（测试线），1）：
如果（测试线[i].isdigit（）==True）：
k、 追加（浮点（测试线[i]））
其他：
尝试：
x=k.pop（）
y=k.pop（）
除索引器外：
打破
如果（测试线[i]='*'）：
ans=x*y
k、 附加（ans）
elif（测试线[i]='+'）：
ans=x+y
k、 附加（ans）
elif（测试线[i]='-'）：
ans=x-y
k、 附加（ans）
elif（测试线[i]='/'）：
ans=x/y
k、 附加（ans）
其他：
打印（“行”，计数，“无法评估”）
返回

为了使它更加健壮，并且不需要添加额外的
附件，我将执行以下操作：

operators={'*'：lambda x，y:x*y，
“/”：λx，y:x/y，
“+”：λx，y:x+y，
“-”：λx，y:x-y}
对于测试行中的c：
如果c.isdigit（）：
k、 附加（浮动（c））
操作员中的elif c：
尝试：
x=k.pop（）
y=k.pop（）
除索引器外：
打破
ans=运算符[c]（x，y）
k、 附加（ans）
其他：
打印（“行”，计数，“无法评估”）
返回

编辑：更简单：

operators={'*'：lambda x，y:x*y，
“/”：λx，y:x/y，
“+”：λx，y:x+y，
“-”：λx，y:x-y}
对于测试行中的c：
如果c.isdigit（）：
k、 附加（浮动（c））
其他：
尝试：
x=k.pop（）
y=k.pop（）
ans=运算符[c]（x，y）
k、 附加（ans）
除了索引器：#无法弹出。。。（空堆栈）
打破
除了KeyError:#char不是数字，也不是运算符
打印（“行”，计数，“无法评估”）
返回
根据OP希望尽可能保持原始代码不变的愿望，这里有一个版本的代码，可以进行最小的更改。OP特别要求的主要变化是，在每次算术运算之前添加操作数不足的检查。此代码在计算中的操作数顺序也在必要时颠倒：lines = [
    '295+*3-',
    '61*7-4*',
    '61*79-15*',
    '6a*7-b*',
    '(-1)*2',
    '623-+*-1',
]

for i in range(len(lines)):
    process(lines[i], i + 1)

('Line', 1, 'result is', 25.0)
('Line', 2, 'result is', -4.0)
('Line', 3, 'is not able to be evaluated')
('Line', 4, 'is not able to be evaluated')
('Line', 5, 'is not able to be evaluated')
('Line', 6, 'is not able to be evaluated. not enough operands')

def process(testline, count):

    operations = {
        '+': lambda x, y: y + x,
        '-': lambda x, y: y - x,
        '*': lambda x, y: y * x,
        '/': lambda x, y: y / x,
    }

    k = []

    for c in testline:

        if c.isdigit():
            k.append(float(c))

        elif c in operations:
            if len(k) < 2:
                print("Line {}: bad expression '{}' (not enough operands)".format(count, testline))
                return
            k.append(operations[c](k.pop(), k.pop()))

        else:
            print("Line {}: unexpected character '{}' in expression '{}'".format(count, c, testline))
            return

    if len(k) != 1:
        print("Line {}: bad expression '{}' (too many operands)".format(count, testline))
    else:
        print("Line {}: Result: '{}' = {}".format(count, testline, k[0]))


lines = [
    '295+*3-',
    '61*7-4*',
    '61*79-15*',
    '6a*7-b*',
    '(-1)*2',
    '623-+*-1',
]

for i in range(len(lines)):
    process(lines[i], i + 1)

Line 1: Result: '295+*3-' = 25.0
Line 2: Result: '61*7-4*' = -4.0
Line 3: bad expression '61*79-15*' (too many operands)
Line 4: unexpected character 'a' in expression '6a*7-b*'
Line 5: unexpected character '(' in expression '(-1)*2'
Line 6: bad expression '623-+*-1' (not enough operands)