假设我们有一些复杂的表达式，里边包含了多种括号的嵌套，这个时候去肉眼判断括号匹配是一件非常令人蛋疼的事情，那么，怎么用Python来进行基本的判断呢，答案很简单，就是用python中的list来模拟栈结构进行判断。

举个例子来说加入我们的文件中有类似一下多重嵌套的算式：

rows = [
'([<^>x[ ]{a}]{/}{t}g<^>)<{x}b>{x}<z({%}w >[b][c[c]]{<h>{h}}',
 '[/]{((x)({{*}*}w)w){f}{v}[%(^[z]{u}{ })([[ ]-]h)]{c}(*)[y]}',
 '<<(^)z>>[b]< >[[(c)u[v]{z<b< >><b>}]g][/b[(])v(v)(+)](v)',
 '[[b]][(v)g]<z>([{{<->+}e}[*]d<+>]g[[a] <+>(v){b}<e>]){a}[u]',
 '<h>(({-}b}a>)[(v)b]+(e{g})( )){< >(t[f])[w](f)<',
 '[^](<g{+}>[f{t}](d){x}^))%}<+{ (f)}>{}[ (u{]{{{d}^}x}',
 '((%)(f)[e][b[%][*]]u)([h] c})<b>[w]{<t>(/)(d)< >[%]%}',
 '<c>[w][[<t>+]]<{(t)a}d({<v>y<^{-}>}b)><w>{{%}^}',
 'b[u]<%>(%)(w))[y]{[u(f)]f< >}[<(>+]<w>(((<z> )(c)(b[w])/){ }h< >)',
 '([ ])<y><({{f}d}a(b)){/}*>{^}(/{h}{t[+]{t{b}}{x}[y]})',
 '< {^}>{+}{[a[e]]<z<^><%>{h}>{y}{(/((t a(t)))*( )}<a>( )}',
 '(<h>(<[d]g>(d)/c]<d>(d)[)(<[^]h>c)(<b> )){c}(b){ }',
 '{(h)[t][y]{%}{e}*(d)[*]}(e)<<(>{t}(z<+>)<[*]t>-(w)><-b)><[c]d[ ]>',
 '<a>{<(^)<h>c>[f]<h>{{v}y[/]}}((w{h})f)<{+}e( )>[t{w}]',
 '([v<%>>/)[+]<t]<<%>b>(({a<[x]*>{+[^]}}[w]h)< >)(h)',
 '<((*)f)((g(w[ [*]]))w{<y>+}(^))>{g}{+}{t}(h)',
 '<b><{{+}c{{(x)[x]f}^(^)}}[f](%)[u][u]<v>{<[z]e>f(g[%])}>',
 '[<<(+)( )y<*[u]>> ><h>[{ <y{v}>}^[c< >]{g}]<f><->[c<v>](/<z>)][t]',
 '(u[/])< >{e}<->{-}(( )[f]%)(d)[][[x[y]]t]{ {d{x}[t]}}{(b)x[z]}'
 ]

我们要做的就是给一个基本的判断，看里边的括号是不是匹配正确，我们可以用一下程序经行判断

# 存储左括号和又括号
open_brackets = '([{<'
close_brackets = ')]}>'
# 映射左右括号便于出栈判断
brackets_map = {')': '(', ']': '[', '}': '{', '>': '<'}

# 对于没一行数据，进行如下判定若括号为左括号，加入栈，若括号为右括号，判断是否跟栈尾括号对应，若对应，弹出栈尾元素，若所有括号均正确闭合，则最后栈为空。
for row in rows:
    stack = []
    label = True
    for char in row:
        if char in open_brackets:
            stack.append(char)
        elif char in close_brackets:
            if len(stack) < 1:
                label = False
                break
            elif brackets_map[char] == stack[-1]:
                stack.pop()
            else:
                label = False
                break
        else:
            continue
    if stack != []:
        label = False
    print label,

简单解释一下上边代码，首先我们把各种括号的开始端和闭合端分开，作为出入栈的判定依据，然后将相应的括号对应起来以便判断。接下来我们对没一行进行括号的出入栈检验，只有满足条件的最后才能被判定为所有括号都闭合。