Positive lookahead assertion

[tobiah]

(?=...)
Positive lookahead assertion. This succeeds if the contained
regular expression, represented here by ..., successfully
matches at the current location, and fails otherwise.
But, once the contained expression has been tried, the
matching engine doesn't advance at all; the rest of the
pattern is tried right where the assertion started.

I am unable to wrap my mind around this sentence. Could
someone give me an example of how this works, and why
it would be useful?

Thanks,

Toby

--
Posted via a free Usenet account from http://www.teranews.com

[tobiah]

Sorry, I should have tried harder. I see that the text
of the match is simply not consumed, so that:

m = re.search('(?=foo)fo', 'food')

succeeds, while

m = re.search('(?=fox)fo', 'food')

does not.

tobiah wrote:

(?=...)
Positive lookahead assertion. This succeeds if the contained regular
expression, represented here by ..., successfully matches at the current
location, and fails otherwise. But, once the contained expression has
been tried, the matching engine doesn't advance at all; the rest of the
pattern is tried right where the assertion started.

I am unable to wrap my mind around this sentence. Could
someone give me an example of how this works, and why
it would be useful?

Thanks,

Toby

--
Posted via a free Usenet account from http://www.teranews.com

[Paddy]

tobiah wrote:

(?=...)
Positive lookahead assertion. This succeeds if the contained
regular expression, represented here by ..., successfully
matches at the current location, and fails otherwise.
But, once the contained expression has been tried, the
matching engine doesn't advance at all; the rest of the
pattern is tried right where the assertion started.

I am unable to wrap my mind around this sentence. Could
someone give me an example of how this works, and why
it would be useful?

Thanks,

Toby

--
Posted via a free Usenet account from http://www.teranews.com

Its all about context. If you want to match something but only if it
precedes something else, then you follow the regular expression for
'something' by the regular expression for 'something else' where
`something else` is enclosed by (?=...)

The regular expression engine will surreptitiously check that
'something else' does indeed follow, before returning any match of
'something'.

Unfortunatley the above may be just as hard to decipher as the original
;-)

- Paddy.

[Neil Cerutti]

On 2006-09-07, Paddy <pa*******@netscape.netwrote:

tobiah wrote:

>(?=...)
Positive lookahead assertion. This succeeds if the contained
regular expression, represented here by ..., successfully
matches at the current location, and fails otherwise. But,
once the contained expression has been tried, the matching
engine doesn't advance at all; the rest of the pattern is
tried right where the assertion started.

I am unable to wrap my mind around this sentence. Could
someone give me an example of how this works, and why it would
be useful?

Its all about context. If you want to match something but only
if it precedes something else, then you follow the regular
expression for 'something' by the regular expression for
'something else' where `something else` is enclosed by (?=...)

The regular expression engine will surreptitiously check that
'something else' does indeed follow, before returning any match of
'something'.

At any rate it further blurs the line between parsing and
pattern-matching. ;)

--
Neil Cerutti

[tobiah]

>Posted via a free Usenet account from http://www.teranews.com

Its all about context. If you want to match something but only if it
precedes something else, then you follow the regular expression for
'something' by the regular expression for 'something else' where
`something else` is enclosed by (?=...)

The regular expression engine will surreptitiously check that
'something else' does indeed follow, before returning any match of
'something'.

How would this differ from just

re.search('somethingsomething else')

--
Posted via a free Usenet account from http://www.teranews.com

[Paddy]

tobiah wrote:

Posted via a free Usenet account from http://www.teranews.com

Its all about context. If you want to match something but only if it
precedes something else, then you follow the regular expression for
'something' by the regular expression for 'something else' where
`something else` is enclosed by (?=...)

The regular expression engine will surreptitiously check that
'something else' does indeed follow, before returning any match of
'something'.

How would this differ from just

re.search('somethingsomething else')

Notice that in the last search below, something else needs to follow,
but is not consumed.

>>import re
re.search(r'something', ' somethingsomethingsomething else').span()

(1, 10)

>>re.search(r'somethingsomething else', ' somethingsomethingsomething else').span()

(10, 33)

>>re.search(r'something(something else)', ' somethingsomethingsomething else').span()

(10, 33)

>>re.search(r'something(?=something else)', ' somethingsomethingsomething else').span()

(10, 19)

>>>

- Paddy.

[Carl Banks]

tobiah wrote:

Sorry, I should have tried harder. I see that the text
of the match is simply not consumed, so that:

m = re.search('(?=foo)fo', 'food')

succeeds, while

m = re.search('(?=fox)fo', 'food')

does not.

They are more commonly used, and generally more useful, at the end of a
regexp:

m = re.search(r"foo(?=d)","food")

matches, but afterwards m.group(0)=="foo" (without the d). Meanwhile,

m = re.search(r"foo(?=d)","fool")

doesn't match at all.

Carl Banks

[Paddy]

Paddy wrote:

tobiah wrote:

>Posted via a free Usenet account from http://www.teranews.com
Its all about context. If you want to match something but only if it
precedes something else, then you follow the regular expression for
'something' by the regular expression for 'something else' where
`something else` is enclosed by (?=...)
>
The regular expression engine will surreptitiously check that
'something else' does indeed follow, before returning any match of
'something'.

How would this differ from just

re.search('somethingsomething else')

Notice that in the last search below, something else needs to follow,
but is not consumed.

>import re
re.search(r'something', ' somethingsomethingsomething else').span()

(1, 10)

>re.search(r'somethingsomething else', ' somethingsomethingsomething else').span()

(10, 33)

>re.search(r'something(something else)', ' somethingsomethingsomething else').span()

(10, 33)

>re.search(r'something(?=something else)', ' somethingsomethingsomething else').span()

(10, 19)

>>

- Paddy.

Heres a more complicated example to show its effect on subsequent group
matches.
The lines are getting a little long so if you see S think something; E
think else.

Remember that .*? matches the LEAST amount of following characters, and
that (?P<name>...) creates a group that can be later referred to by
name.

>>import re

# The first else after something

>>re.search(r'S.*?(?P<else>E)', " SS EE").span("else")

(4, 5)

# The first else after somethingsomething else

>>re.search(r'S(S E).*?(?P<else>E)', " SS EE").span("else")

(5, 6)

# The first E after S but only if the S was followed immediately by S E

>>re.search(r'S(?=S E).*?(?P<else>E)'," SS EE").span("else")

(4, 5)

>>>

Back to bed for me in the UK.

- Paddy.

[Steve Holden]

tobiah wrote:

>>>Posted via a free Usenet account from http://www.teranews.com

Its all about context. If you want to match something but only if it
precedes something else, then you follow the regular expression for
'something' by the regular expression for 'something else' where
`something else` is enclosed by (?=...)

The regular expression engine will surreptitiously check that
'something else' does indeed follow, before returning any match of
'something'.

How would this differ from just

re.search('somethingsomething else')

The difference is only significant if your pattern contains groups that
should be available after the match is complete, or if the match is
folloed by further match elements. A lookahead assertion does precisely
that: it looks past the current cursor position and allows an assertion
about the contents, but without moving the cursor position.

regards
Steve
--
Steve Holden [phone] [phone]
Holden Web LLC/Ltd http://www.holdenweb.com
Skype: holdenweb http://holdenweb.blogspot.com
Recent Ramblings http://del.icio.us/steve.holden