0

我正在尝试在 python 中解析字符串。我已经发布了几个关于堆栈溢出的问题，我基本上是在尝试结合所有不同的可能方式的功能来解析我正在使用的字符串。

这是一个单独工作的代码片段，可以很好地解析以下两种字符串格式。

from __future__ import generators
from pprint import pprint
s2="<one><two><three> an.attribute ::"
s1="< one > < two > < three > here's one attribute < six : 10.3 > < seven : 8.5 > <   eight :   90.1 > < nine : 8.7 >"
def parse(s):
    for t in s.split('<'):
        for u in t.strip().split('>',1):
            if u.strip(): yield u.strip()
pprint(list(parse(s1)))
pprint(list(parse(s2)))

这是我得到的输出。它是我需要的格式，每个属性都存储在不同的索引位置。

['one',
 'two',
 'three',
 "here's one attribute",
 'six : 10.3',
 'seven : 8.5',
 'eight : 90.1',
 'nine : 8.7']
['one', 'two', 'three', 'an.attribute ::']

完成之后，我尝试将相同的代码合并到一个可以解析四种字符串格式的函数中，但由于某种原因，它似乎在这里不起作用，我不知道为什么。

这是完整的合并代码。

from __future__ import generators
import re
import string
from pprint import pprint
temp=[]
y=[]
s2="< one > < two > < three > an.attribute ::"
s1="< one > < two > < three > here's an attribute < four : 6.5 > < five : 7.5 > < six : 8.5 > < seven : 9.5 >"
t2="< one > < two > < three > < four : 220.0 > < five : 6.5 > < six : 7.5 > < seven : 8.5 > < eight : 9.5 > < nine : 6 -  7 >"
t3="One : two :  three : four  Value  : five  Value  : six  Value : seven  Value :  eight  Value :"
def parse(s):
    c=s.count('<')
    print c
    if c==9:
        res = re.findall('< (.*?) >', s)
        return res
    elif (c==7|c==3):
        temp=parsing(s)
        pprint(list(temp))
        #pprint(list(parsing(s)))
    else: 
        res=s.split(' : ')
        res = [item.strip() for item in s.split(':')]
        return res
def parsing(s):
    for t in s.split(' < '):
        for u in t.strip().split('>',1):
            if u.strip(): yield u.strip()
    pprint(list((s)))

现在，当我编译代码并调用时，parse(s1)我得到以下输出：

7
["< one > < two > < three > here's an attribute < four",
 '6.5 > < five',
 '7.5 > < six',
 '8.5 > < seven',

同样，在调用parse(s2)时，我得到：

3
['< one > < two > < three > an.attribute', '', '']
   '9.5 >']

为什么在解析字符串时拆分字符串不一致？我在两个地方都使用相同的代码。

有人可以帮我弄清楚为什么会这样吗？:)

4

1 回答 1

2

您正在使用二进制|按位或运算符，而应该使用or布尔运算符：

elif (c==7|c==3):

应该

elif c==7 or c==3:

也许：

elif c in (3, 7):

启动速度更快。

因为|运算符的优先级与运算符不同or，所以第一条语句被解释为(c == (7 | c) == 3)进行7 | c按位逻辑运算，返回一个永远不会等于cand的结果3，因此总是返回False：

>>> c = 7
>>> (c==7|c==3)
False
>>> c = 3
>>> (c==7|c==3)
False
>>> c==7 or c==3
True
于 2013-03-14T10:01:16.607 回答