我想在python中使用括号检查器来计算错误的括号

我想编程括号检查器程序。但我希望它能计算出不匹配的括号。我正在使用python。在这个问题中我如何使用堆栈

我试过一些代码，但没有成功，因为它不能计算错误的括号

if __name__ == "__main__":
    # text = sys.stdin.read()
    text = str(input())
    stackie = []
    num = 0
    opening_brackets_stack = []
    for i, next in enumerate(text):
        if next == '(' or next == '[' or next == '{':
            # Process opening bracket, write your code here
            stackie.append(next)
            pass

        if next == ')' or next == ']' or next == '}':
            # Process closing bracket, write your code here
            if next == ")" :
                if '(' in stackie :
                    stackie.remove("(")
                else:
                    num += 1
            if next == "]" :
                if '[' in stackie :
                    stackie.remove("[")
                else:
                    num += 1
            if next == "}" :
                if '{' in stackie :
                    stackie.remove("{")
                else:
                    num += 1
            pass

---

我附上了下面的解决方案，希望它是自我描述，并将做你想要的

def check_closed_括号（打开括号、非关闭括号、非打开括号）：
如果len（非闭合的_打开的_括号）=0:#没有打开的括号剩余，因此闭合必须无效
未打开\关闭\括号。追加（元素）
否则：#存在开括号，让我们检查一下
如果元素==”）：
如果非闭式开括号[len（非闭式开括号）-1]=='（'：
非闭合的开口括号。移除（“”）
其他：
未打开\关闭\括号。追加（元素）
如果元素==“]”：
如果非闭合开括号[len（非闭合开括号）-1]='['：
非闭合的开口括号。删除（“[”）
其他：
未打开\关闭\括号。追加（元素）
如果元素==“}”：
如果非闭式括号[len（非闭式括号）-1]='{':
非闭合的括号。删除（“{”）
其他：
未打开\关闭\括号。追加（元素）
如果名称=“\uuuuu main\uuuuuuuu”：
#text=sys.stdin.read（）
text=str（输入（））
非闭合的开口方括号=[]
未打开\关闭\括号=[]
对于i，枚举中的元素（文本）：
如果元素=='（'或元素=='['或元素=='{'：
非闭式括号。追加（元素）
如果元素==''）或元素==']'或元素=='}'：
检查关闭括号（元素、非关闭括号、非打开括号、非关闭括号）
打印（'未闭合的已打开方括号的数目：{0}'。格式（len（非闭合方括号）））
打印（'未打开的闭括号数：{0}'。格式（len（未打开的闭括号）））

我想如果你想写一个，逻辑中的一个错误是在堆栈上调用

remove

，而不是与

pop

进行比较

要确定它何时按预期工作和何时不按预期工作并不容易，因此一些测试用例和它们的预期行为有很大的帮助，比如说，作为

'（asd（GDGDGD）[DFDFDF]）、
[（asd（GDGDGD）[dfdf]）和
'（asd（gdg{d）[dfdf}df df]）

以这段代码为例：

括号_匹配={'）：'（'，']'：'['，'}'：'{'}
def支架检查（文本）：
堆栈=[]
对于n，枚举中的字符（文本）：
如果字符在“（[{]”中：
stack.append（（字符，n））
如果字符在“]}”中：
match=stack.pop（）
如果匹配[0]！=括号_匹配[char]：
print（f“无法匹配{n}处的括号“{char}，”
f“在{match[1]}处与{match[0]}冲突。”）
返回错误
如果len（堆栈）！=0：
打印（f）“保留在以下位置的开放式支架：”
f“{.”连接（映射（str，堆栈））}”）
返回错误
返回真值

根据之前的样品，我们得到的是：

括号检查（'（asd（gdgd）[dfdf]））
真的
>>>括号检查（'（asd（gdg{d）[df}df]））
无法匹配10处的括号“'），与8处的“{”冲突
假的
>>>括号检查（'[（asd（gdgd）[dfdf]））
保留在以下位置的开括号：（“[”，0）
假的

此解决方案仅限于第一个不匹配的括号，主要是因为该问题比以人类的方式查找所有不匹配的括号要容易得多。后者在常规大小的文本中计算起来相当复杂，并且仍然无法确定是否能给出所需的结果

除非这是绝对不可行的，否则在我看来，通过修复括号错误来迭代工作更可取。
你能不能只计算代码中每个括号的总数并进行简单的减法？
total\u open\u square-total\u close\u square