0

所以我需要一种方法让 python 基本上检测一个字符串之间的差异，如下所示：

W:1.0,X:1.1(A:0.1,B:0.2,(C:0.3,D:0.4)E:0.5,(F:0.6,G:0.7)H:0.8)Y:0.9

还有这个：

A:0.1,B:0.2,(C:0.3,D:0.4)E:0.5,(F:0.6,G:0.7)H:0.8

是否有任何函数可用于检测在第一个字符串中，有 2 个相互连接的内括号，而在第二个字符串中，第一个内括号最终后面跟着一个闭括号？最好不是 .re 正则表达式。谢谢！

编辑：我正在处理任何括号的情况，来自：

A:0.1,B:0.2,(C:0.3,D:0.4)E:0.5,(F:0.6,G:0.7)H:0.8,(T:0.6,V:0.7)S:0.8,(D:0.6,Y:0.7)P:0.8,(X:0.6,L:0.7)M:0.8

内部 2 个子字符串上的任何无限量...到：

W:1.0,X:1.1(U:5.0(I:9.0)N:8.0,(A:0.1,B:0.2,(C:0.3,D:0.4)E:0.5,(F:0.6,G:0.7)H:0.8)R:3.4(O:5.5)P:3.0)Y:0.9

一个高度复杂的多子字段字符串，可以包含任意数量的具有自己的孩子的孩子

4

5 回答 5

2 
s = 'W:1.0,X:1.1(A:0.1,B:0.2,(C:0.3,D:0.4)E:0.5,(F:0.6,G:0.7)H:0.8)Y:0.9'

def max_depth(s, start_ch='(', end_ch=')'):
    depth = 0
    best = 0
    for ch in s:
        if ch == start_ch:
            depth += 1
            best = max(depth, best)
        elif ch == end_ch:
            depth -= 1
            if depth < 0:
                raise ValueError('illegal string - unmatched close-paren')
    if depth:
        raise ValueError('illegal string - unmatched open-paren')
    return best

print max_depth(s)    # => 2
于 2012-07-09T16:32:52.063 回答
1

您可以逐个字符地遍历字符串并计算开始与结束括号的数量。

正如蒂姆在评论中指出的那样，您应该有逻辑来识别何时结束括号多于开始括号。

于 2012-07-09T15:16:43.363 回答
1

这是一个尴尬的 numpy 方法。和 astay13 的建议基本一样，但是对于大数据集应该很快。如果数据太大以至于内存不足，则必须分块处理。

>>> import numpy as np
>>> a = 'W:1.0,X:1.1(A:0.1,B:0.2,(C:0.3,D:0.4)E:0.5,(F:0.6,G:0.7)H:0.8)Y:0.9'
>>> arr = np.fromstring(a, dtype=np.ubyte)
>>> parens = (arr==ord('(')).astype(int) - (arr==ord(')')) ## search for parens

>>> parens   ## 1 marks location of opening paren, -1 marks closing paren
array([ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,  0, -1,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0, -1,  0,  0,  0,  0,  0, -1,  0,  0,  0,  0,  0])

>>> parens[1:] += parens[:-1]  ## compute the nesting level at each character position
>>> parens   
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0])
于 2012-07-09T16:00:03.610 回答
0

正则表达式将是一种更优雅的方式来执行此操作，它可以像re.search(r'\(.*?\(.*?\)', string)这样简单，它会通知您字符串是否在一个闭合括号之前有两个打开的括号。

如果您不想使用这些，但是您可以遍历字符串中的字符，如果遇到两个没有关闭括号的打开括号，然后处理它

于 2012-07-09T15:20:27.090 回答
0

要确定一行没有嵌套括号（您的问题中的示例 2、3）：

re.match(r'(?: [^)]  |  \( [^)]* \) )*$', line, re.X)

即，一行是重复零次或多次的括号中的非括号字符或非嵌套表达式。

于 2012-07-09T15:58:37.747 回答