正则表达式Python/组量词
我想匹配一个类似目录的变量列表,例如:正则表达式Python/组量词,python,regex,regex-group,quantifiers,Python,Regex,Regex Group,Quantifiers,我想匹配一个类似目录的变量列表,例如: Same/Same2/Foot/Ankle/Joint/Actuator/Sensor/Temperature/Value=4.123 Same/Same2/Battery/Name=SomeString Same/Same2/Home/Land/Some/More/Stuff=0.34 “子目录”的长度是一个有上限的变量(大于9)。 我想对每个子目录进行分组,除了上面我命名为“相同”的第一个子目录 我能想到的最好办法是: ^(?:([^/]+)/){4
Same/Same2/Foot/Ankle/Joint/Actuator/Sensor/Temperature/Value=4.123
Same/Same2/Battery/Name=SomeString
Same/Same2/Home/Land/Some/More/Stuff=0.34
“子目录”的长度是一个有上限的变量(大于9)。
我想对每个子目录进行分组,除了上面我命名为“相同”的第一个子目录
我能想到的最好办法是:
^(?:([^/]+)/){4,8}([^/]+)=(.*)
它已经查找了4-8个子目录,但只对最后一个子目录进行分组。为什么?
使用组量词有更好的解决方案吗
编辑:已解决。将改为使用split()。是否只使用split
>>> p='Same/Same2/Foot/Ankle/Joint/Actuator/Sensor/Temperature/Value=4.123'
>>> p.split('/')
['Same', 'Same2', 'Foot', 'Ankle', 'Joint', 'Actuator', 'Sensor', 'Temperature', 'Value=4.123']
另外,如果您需要密钥/val对,您可以执行以下操作
>>> s = p.split('/')
>>> s[-1].split('=')
['Value', '4.123']
我可能误解了您到底想做什么,但以下是您在没有regex的情况下应该如何做:
for entry in list_of_vars:
key, value = entry.split('=')
key_components = key.split('/')
if 4 <= len(key_components) <= 8:
# here the actual work is done
print "%s=%s" % ('_'.join(key_components[1:]).upper(), value)
对于变量列表中的条目:
key,value=entry.split('='))
key_components=key.split(“/”)
如果4
结果
pat==^(?:.+?\\)(.+$)
Same\Same2\Foot\Ankle\Joint\Actuator\Sensor\Temperature\Value=4.123
Same2_Foot_Ankle_Joint_Actuator_Sensor_Temperature_Value=4.123
Same2_Foot_Ankle_Joint_Actuator_Sensor_Temperature_Value=4.123
Same\Same2\Battery\Name=SomeString
Same2_Battery_Name=SomeString
Same2_Battery_Name=SomeString
Same\Same2\Home\Land\Some\More\Stuff=0.34
Same2_Home_Land_Some_More_Stuff=0.34
Same2_Home_Land_Some_More_Stuff=0.34
编辑2
重新阅读您的评论时,我意识到我没有考虑到您希望将位于“=”符号之前但不在其之后的字符串部分上移
因此,这段新代码公开了3种满足此要求的方法。您将选择您喜欢的:
import re
from os import sep
sep2 = r'\\' if sep=='\\' else '/'
pot = '^(?:.+?%s)(.+?)=([^=]*$)' % sep2
print 'pot==%s\n' % pot
rogx = re.compile(pot)
pet = '^(?:.+?%s)(.+?(?==[^=]*$))' % sep2
print 'pet==%s\n' % pet
regx = re.compile(pet)
for ss in ('Same\Same2\Foot\Ankle\Joint\Sensor\Value=4.123',
'Same\Same2\Battery\Name=SomeString',
'Same\Same2\Ocean\Atlantic\North=',
'Same\Same2\Maths\Addition\\2+2=4\Simple=ohoh'):
print ss + '\n' + len(ss)*'-'
print 'rogx groups '.rjust(32),rogx.match(ss).groups()
a,b = ss.split(sep,1)[1].rsplit('=',1)
print 'split split '.rjust(32),(a,b)
print 'split split join upper replace %s=%s' % (a.replace(sep,'_').upper(),b)
print 'regx split group '.rjust(32),regx.match(ss.split(sep,1)[1]).group()
print 'regx split sub '.rjust(32),\
regx.sub(lambda x: x.group(1).replace(sep,'_').upper(), ss)
print
结果,在Windows平台上
pot==^(?:.+?\\)(.+?)=([^=]*$)
pet==^(?:.+?\\)(.+?(?==[^=]*$))
Same\Same2\Foot\Ankle\Joint\Sensor\Value=4.123
----------------------------------------------
rogx groups ('Same2\\Foot\\Ankle\\Joint\\Sensor\\Value', '4.123')
split split ('Same2\\Foot\\Ankle\\Joint\\Sensor\\Value', '4.123')
split split join upper replace SAME2_FOOT_ANKLE_JOINT_SENSOR_VALUE=4.123
regx split group Same2\Foot\Ankle\Joint\Sensor\Value
regx split sub SAME2_FOOT_ANKLE_JOINT_SENSOR_VALUE=4.123
Same\Same2\Battery\Name=SomeString
----------------------------------
rogx groups ('Same2\\Battery\\Name', 'SomeString')
split split ('Same2\\Battery\\Name', 'SomeString')
split split join upper replace SAME2_BATTERY_NAME=SomeString
regx split group Same2\Battery\Name
regx split sub SAME2_BATTERY_NAME=SomeString
Same\Same2\Ocean\Atlantic\North=
--------------------------------
rogx groups ('Same2\\Ocean\\Atlantic\\North', '')
split split ('Same2\\Ocean\\Atlantic\\North', '')
split split join upper replace SAME2_OCEAN_ATLANTIC_NORTH=
regx split group Same2\Ocean\Atlantic\North
regx split sub SAME2_OCEAN_ATLANTIC_NORTH=
Same\Same2\Maths\Addition\2+2=4\Simple=ohoh
-------------------------------------------
rogx groups ('Same2\\Maths\\Addition\\2+2=4\\Simple', 'ohoh')
split split ('Same2\\Maths\\Addition\\2+2=4\\Simple', 'ohoh')
split split join upper replace SAME2_MATHS_ADDITION_2+2=4_SIMPLE=ohoh
regx split group Same2\Maths\Addition\2+2=4\Simple
regx split sub SAME2_MATHS_ADDITION_2+2=4_SIMPLE=ohoh
你的主题有几个变化。首先,我总是发现regexen非常神秘,以至于无法维护,所以我编写了pyparsing模块。在我看来,我看了你的代码后会想,“哦,这是一个由“/”分隔的字符串、一个“=”符号和某种右值组成的列表。”这相当直接地转化为PyParser定义代码。通过在解析器中到处添加名称(“key”和“value”,类似于regex中的命名组),可以非常轻松地处理输出
data="""\
Same/Same2/Foot/Ankle/Joint/Actuator/Sensor/Temperature/Value=4.123
Same/Same2/Battery/Name=SomeString
Same/Same2/Home/Land/Some/More/Stuff=0.34""".splitlines()
from pyparsing import Word, alphas, alphanums, Word, nums, QuotedString, delimitedList
wd = Word(alphas, alphanums)
number = Word(nums+'+-', nums+'.').setParseAction(lambda t:float(t[0]))
rvalue = wd | number | QuotedString('"')
defn = delimitedList(wd, '/')('key') + '=' + rvalue('value')
for d in data:
result = defn.parseString(d)
其次,我质疑您定义所有这些变量名的方法——根据数据动态创建变量名是一种公认的代码味道(不一定很糟糕,但您可能真的想重新考虑这种方法)。我使用递归defaultdict创建了一个可导航的结构,这样您就可以轻松地执行诸如“查找作为“Same2”子元素的所有条目”(在本例中为“Foot”、“Battery”和“Home”)之类的操作—在尝试筛选一些变量名集合(如在locals()中找到的)时,这类工作更加困难,在我看来,您将重新解析这些名称以重建密钥层次结构
from collections import defaultdict
class recursivedefaultdict(defaultdict):
def __init__(self, attrFactory=int):
self.default_factory = lambda : type(self)(attrFactory)
self._attrFactory = attrFactory
def __getattr__(self, attr):
newval = self._attrFactory()
setattr(self, attr, newval)
return newval
table = recursivedefaultdict()
# parse each entry, and accumulate into hierarchical dict
for d in data:
# use pyparsing parser, gives us key (list of names) and value
result = defn.parseString(d)
t = table
for k in result.key[:-1]:
t = t[k]
t[result.key[-1]] = result.value
# recursive method to iterate over hierarchical dict
def showTable(t, indent=''):
for k,v in t.items():
print indent+k,
if isinstance(v,dict):
print
showTable(v, indent+' ')
else:
print v
showTable(table)
印刷品:
Same
Same2
Foot
Ankle
Joint
Actuator
Sensor
Temperature
Value 4.123
Battery
Name SomeString
Home
Land
Some
More
Stuff 0.34
SAME_SAME2_FOOT_ANKLE_JOINT_ACTUATOR_SENSOR_TEMPERATURE_VALUE = 4.123
SAME_SAME2_BATTERY_NAME = "SomeString"
SAME_SAME2_HOME_LAND_SOME_MORE_STUFF = 0.34
如果您真的开始定义这些变量名,那么向pyparsing添加一些有用的解析操作将在解析时重新格式化解析的数据,以便以后可以直接处理:
wd = Word(alphas, alphanums)
number = Word(nums+'+-', nums+'.').setParseAction(lambda t:float(t[0]))
rvaluewd = wd.copy().setParseAction(lambda t: '"%s"' % t[0])
rvalue = rvaluewd | number | QuotedString('"')
defn = delimitedList(wd, '/')('key') + '=' + rvalue('value')
def joinNamesWithAllCaps(tokens):
tokens["key"] = '_'.join(map(str.upper, tokens.key))
defn.setParseAction(joinNamesWithAllCaps)
for d in data:
result = defn.parseString(d)
print result.key,'=', result.value
印刷品:
Same
Same2
Foot
Ankle
Joint
Actuator
Sensor
Temperature
Value 4.123
Battery
Name SomeString
Home
Land
Some
More
Stuff 0.34
SAME_SAME2_FOOT_ANKLE_JOINT_ACTUATOR_SENSOR_TEMPERATURE_VALUE = 4.123
SAME_SAME2_BATTERY_NAME = "SomeString"
SAME_SAME2_HOME_LAND_SOME_MORE_STUFF = 0.34
(请注意,这还将SomeString值括在引号中,因此生成的赋值语句是有效的Python语句。)您真的需要正则表达式吗?有什么原因不能使用split
和其他常规Python字符串管理函数而不使用正则表达式吗?该列表包含数千个这样的目录,这些目录将在特定约定后解析为变量名,例如Same/Same2/Battery/Name=SomeString变为Same2\u BATTERY_NAME=SomeString。有没有比regex更好的方法?嗯。谢谢,从来没有想过拆分。这样做更简单更快!:)顺便说一句,您的解决方案不起作用,因为对于重复的组模式,只返回最后一个匹配项。我同意这种方法。不过,最终的变量列表应该是p.split('/')[1:]
,至于省略初始的相同的
值。@我看不出有兴趣按照“=”进行分割以获得随后被分割的键值。函数split()有一个默认参数,可以设置为1,以便仅在第一个“/”上进行分割。Thx提供了一个能如此优雅地显示这两种方法的解决方案!