Python计算器带括号表达式报错及结果异常问题排查请求

Hey there! Let's break down your calculator issues one by one—even with the partial code you shared, I can spot a couple of common pitfalls causing your problems.

1. Why 86*4(3+5)88 throws TypeError: 'int' object is not callable #

The core issue here is that Python (and most expression parsers) don't recognize implicit multiplication. When you write 4(3+5), Python interprets this as trying to call the integer 4 like a function (passing 3+5 as an argument)—hence the "int object not callable" error. On top of that, the trailing 88 with no operator before it is invalid syntax for Python.

Fix: Preprocess the input to add explicit multiplication signs #

You need to clean up the user's input before calculating to insert * where implicit multiplication is intended. Here's a simple function to handle the cases in your example:

def preprocess_expression(expr):
    processed = []
    for idx, char in enumerate(expr):
        # Add * between a number and an opening parenthesis
        if char == "(" and idx > 0 and expr[idx-1].isdigit():
            processed.append("*")
        processed.append(char)
    
    # Add * between a closing parenthesis and a number
    processed_str = "".join(processed)
    processed_str = processed_str.replace(")", ")*")
    
    # Fix any extra * we added (e.g., if two parentheses are adjacent)
    processed_str = processed_str.replace(")*)", "))")
    
    return processed_str

This will convert 86*4(3+5)88 to 86*4*(3+5)*88—a valid expression Python can parse.

2. Incorrect result after pressing equals #

Without seeing the full code for your calculator class, here are the most likely culprits:

• Not fetching the full input correctly: Make sure your equals button handler uses txtDisplay.get() to grab the entire expression from the entry field.
• Skipping expression preprocessing: Even if users input explicit operators, failing to handle implicit cases (or invalid characters) will lead to wrong results.
• Misusing eval: If you're using eval() to compute the result, ensure you're converting the output back to a string to display, and adding error handling for invalid inputs.
• Broken button handlers: If your number/operator buttons aren't appending to the entry field properly (e.g., overwriting instead of adding), the expression sent for calculation will be incorrect.

Example equals button handler #

Here's how you might implement a robust calculation function:

def on_equals_click():
    try:
        raw_expr = txtDisplay.get()
        cleaned_expr = preprocess_expression(raw_expr)
        result = eval(cleaned_expr)
        # Clear the display and show the result
        txtDisplay.delete(0, END)
        txtDisplay.insert(0, str(result))
    except SyntaxError:
        txtDisplay.delete(0, END)
        txtDisplay.insert(0, "Invalid Syntax")
    except Exception as e:
        txtDisplay.delete(0, END)
        txtDisplay.insert(0, "Error")

A quick note: Using eval() is convenient for personal calculators, but it's not secure if others will use this tool (it can execute arbitrary code). For a safer alternative, you could use Python's ast module to parse the expression, but that's more complex.

内容的提问来源于stack exchange，提问作者preetika mondal