Question

所以我需要一种方法让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

一个高度复杂的多个儿童使用的字符串，可以包含任何无限量的孩子和自己的孩子

Answer 1

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

Answer 2

您可以按字符逐行处理字符串，并计算开始与结束括号的数量。

正如Tim在评论中指出的那样，你应该有一个逻辑来识别你有多个结束括号而不是开始括号。

Answer 3

这是一个尴尬的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])

Answer 4

正则表达式将是一种更优雅的方式，它可以像re.search(r'\(.*?\(.*?\)', string)一样简单。如果字符串在关闭paren之前有两个打开的parens，这将通知您。

如果你不想使用这些，你可以迭代字符串中的字符，如果你遇到两个没有关闭paren的开放的parens，那么处理它

Answer 5

确定一行没有嵌套括号（问题中的例子2,3）：

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

，即一条线是非重复字符或非嵌套表达式，在重复零次或多次的parens中。

如何在Python中搜索字符串中的重复

5 个答案: