尝试了解和修改时间为[[hh：] mm：] ss格式的正则表达式规则，从右到左匹配

Question

I'm trying to understand the following regexp rule:

import re

time_format = r"(?:(?P<weeks>\d+)\W*(?:weeks?|w),?)?\W*(?:(?P<days>\d+)\W*(?:days?|d),?)?\W*(?:(?P<hours>\d+):(?P<minutes>\d+)(?::(?P<seconds>\d+)(?:\.(?P<microseconds>\d+))?)?)?"
time_matcher = re.compile(time_format)
time_matches = time_matcher.match(td_str)

With this rule, if I set td_str = '0:10' I get the following result:

{'days': None,
 'hours': '0',
 'microseconds': None,
 'minutes': '01',
 'seconds': None,
 'weeks': None}

If I set td_str = '0:0:10' I get the following result:

{'days': None,
 'hours': '0',
 'microseconds': None,
 'minutes': '0',
 'seconds': '01',
 'weeks': None}

How do I have to change the regexp rule, so that 0:10 will be interpreted as 0 minutes + 10 seconds? Additionally, '1:20:1' should be interpreted as 1 hour + 20 minutes + 1 second.

So the regexp rule that I want to create (as far as I understand regexps) is: [H:[M:]]S

EDIT1 : I believe I've constructed a correct rule for [M:]S :

time_format = r"((?P<minutes>\d+)?:?)(?P<seconds>\d+)"

Can anybody confirm that this is the correct way of doing it?

EDIT2 : expanding on the rule shown in Edit1, the following does work (sometimes):

time_format = r"((((?P<hours>\d+)?:?)(?P<minutes>\d+))?:?)(?P<seconds>\d+)"

However, if I say time='1:10' , then this get's translated incorrectly to 1 hour, 1 minute and 0 seconds, instead of 1 minute and 10 seconds.

EDIT3 : this is how I've solved the problem for now, not using regexps. I would still love to know how to accomplish the same using regexps.

# defaults
days = 0
hours = 0
minutes = 0
seconds = 0
microseconds = 0

split_fields = time_string.split(':')
nbr_fields = len(split_fields)

if nbr_fields == 0: # should never happen
    pass
if nbr_fields == 1:
    seconds = int(split_fields[0])
elif nbr_fields == 2:
    minutes = int(split_fields[0])
    seconds = int(split_fields[1])
elif nbr_fields == 3:
    hours = int(split_fields[0])
    minutes = int(split_fields[1])
    seconds = int(split_fields[2])
else: # in case there's more than 3 fields ...
    hours = int(split_fields[-3])
    minutes = int(split_fields[-2])
    seconds = int(split_fields[-1])

Answer 1

The part of the regex matching seconds is optional, so it can be matched as you have specified with a following ? character. The same applies to the microseconds field.

Taking just the H:M[:S.[USEC]] part of the regex would yield something like this:

(?P<hours>\d+):(?P<minutes>\d+)(?::(?P<seconds>\d+)(\.(?P<microseconds>\d+))?)?

It's not always necessary to use regex's to do this kind of matching. Sometimes its easier to write your own parser which splits the elements, eg using string.split(':') . It may be more understandable when you come back to read the code later.

(I just noticed you have a colon between seconds and microseconds. The regex listed above would have to change to account for that. The regex listed will match 01:02:03.456.

edit:

It's possible to structure your regex like (S)|(M:S)|(H:M:S) , however this will not work with named groups since the group name cannot appear more than once. The problem is that you want the engine to look ahead and match the rightmost token first before matching those to the left. The string will be scanned left-to-right for matches and as a result there is no way to describe the fields in an unambiguous manner, at least not when using named groups.

Another solution not involving named groups is to use a more general expression such as (\\d+)(:\\d+)?(:\\d+)? and then look at the returned groups that are not None to determine their meaning. If there's 1 group, only S present, if 2, M:S etc.