RegEx question about repeating

[phossler]

I have simple stored search RE to replace em, en, and dash in Hx's (mostly for consistent formatting)

Find : <([Hh][1-6])>(.*?)\s*[-—–]{1,}\s*(.*?)</\1>

Replace: <\1>\2 \3</\1>

The once in awhile problem occurs when there are 2 or more em, en, or dash in the same Hx

<h1>fasfasdsadf –    asdfsdfsd — sdafasdasd - asasdf - asdsadf - asdasdf</h1>

Is there are a way to have the RE do them all, or do I still have to do [Replace All] until 0 are found?

[eschwartz]

<([Hh][1-6])>(.*?)\s*(?:[-—–]{1,}\s*(.*?))+</\1>

Repeating a capturing group

[phossler]

Did I do something wrong? I see how the repeat capture group works (or at least I think I do), but the Replace is not what I was expecting

It seems to replace too much, and all I was trying to do was end up with the fourth line in the picture. The F&R generated the first line.

[phossler]

Also I tried a FR function

import regex
def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
  	return match.group().replace('–',' ').replace('—',' ').replace('-',' ').replace(' {2,}',' ')

which actually seems to replace the dashes, but then the remove multiple spaces piece on the end doesn't seem to do anything

So I suspect that I'm missing something fundamental here

[eschwartz]

Err, good point. It will only capture the last match.

You could search for that match multiple times though, and use a "?" to make all but the first optional.

[jbacelar]

FuntcionRegex:

Search:
<([Hh][1-6])>.+?<

Code:
def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
return match.group().replace("@-@","@").replace("@–@","@").replace("@—@","@")

Naturally must change @ by space

[phossler]

This is what I have now, and it works, but just looks ugly.

It replaces the em, en, and dashes in Hx's, even multiples, and then shrinks multiple spaces to a single space (up to 10)

Is there a way to make it a little more elegant (and maintainable)?

Find:

<([Hh][1-6])>(.*?)</\1>

def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    return match.group().replace("-"," ").replace("–"," ").replace("—"," ").replace ("  "," ").replace ("  "," ").replace ("  "," ").replace ("  "," ").replace ("  "," ").replace ("  "," ").replace ("  "," ").replace ("  "," ").replace ("  "," ").replace ("  "," ").replace ("  "," ")

[jbacelar]

I do not know which is the layout of dashes or spaces (and quantity) into your text, but I think something like what I propose (or similar) should work, (up to 10 spaces).

Code:
def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
return match.group().replace('@@','@').replace('-','@').replace('–','@').replace('—','@').replace(' @@@','@').replace('@@','@')

[DiapDealer]

Find:

<([Hh][1-6])([^>]*)>(.*?)</\1>

import regex
def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    text_str = regex.sub(r'''[-–—]''', ' ', match.group(3))
    text_str = regex.sub(r''' {2,}''', ' ', text_str)
    return '<{0}{1}>{2}</{0}>'.format(match.group(1), match.group(2), text_str)

I don't know about graceful (I've always been strangely comforted by the aesthetics of the python one-liner, myself), but the above won't have the ten-space-or-less limitation.

** added the possibility to work with header tags that may have attributes.

[jbacelar]

@DiapDealer

Definitivo

[phossler]

@DiapDealer









I will study the technique since I can see many more places I can save myself some tedious work

[phossler]

@DiapDealer --

Could you please explain the syntax, grammar, and punctuation of the function?

I read this ...

https://docs.python.org/2.7/library/...ght=sub#re.sub

but still don't get it

The match.group(3) and the space{2,} I recognize, then things like

r'''something''' i.e. why the r and 3 single quotes?

return .... i.e. I can figure out the {0}, etc. but why in ' ....' and what is the .format for?

In case you haven't realized, my understanding of python is zilch

I am trying to figure out enough to cookbook some other functions

Thanks

[eschwartz]

r'''something''' -- see: https://docs.python.org/2.0/ref/strings.html

.format() acts on a string, and takes x arguments. For each argument, insert the value into the original string, replacing {n}.

[DiapDealer]

The r''' ''' is probably overkill in this situation, but I've gotten into the habit of using them all the time for regex expressions in python. '[-–—]' or "[-–—]" would achieve the same thing in this particular instance. It's still just a string representation of the regex expression.

text_str = regex.sub(r'''[-–—]''', ' ', match.group(3))

regex.substitute('everything matching this expression', with 'this', in 'this string')
Find all occurrences of - or – or — and replace them with a space in the string contained in the 3rd matching group. Store the results in text_str.

text_str = regex.sub(r''' {2,}''', ' ', text_str)

Find all occurrences of two or more consecutive spaces and replace them with a single space in the text_str string. Store the results in text_str.

return '<{0}{1}>{2}</{0}>'.format(match.group(1), match.group(2), text_str)

String formatting/substitution.

'Hello {0}'.format('there')

Substitute {0} with 'there'

'Hello {0} {1} {2}, {0}'.format('there', 'you', 10)

Becomes 'Hello there you 10, there.'

You don't even need to use numbers if you're not going to repeat anything:

'Hello {} {} {}, {}'.format('there', 'you', 10, 'you')

You could also use string concatenation:

return match.group(1) + match.group(2) + text_str + match.group(1)

But then you have to worry about making sure everything is represented properly as a string beforehand. Probably not necessary in this case, but again, just a habit I've gotten into to avoid type mismatches (plus I just like it better than the %s %d string substitution method )

return '<%s%s>%s</%s>' % (match.group(1), match.group(2), text_str, match.group(1))

In this particular case:

return '<{0}{1}>{2}</{0}>'.format(match.group(1), match.group(2), text_str)

match.group(1) will be the tag name (h1, h2, h3, etc) and gets plugged into both {0}s.
match.group(2) will be any (optional) attributes (class="foo") and gets plugged into {1}.
text_str is our manipulated content from between the h-tags and gets plugged into {2}

[eschwartz]

Also because going forward, the format function is recommended -- for that very reason of course.