Assignment expression in a while loop

m = re.match(pattern, text)
while m := p.search(text, m.end()):
    # do with match

Does the m.end() refer to the previous match m so that the search starts from the end of the previous match? I read PEP-572, and there's a section that talks specifically about regex matches, but not with a while loop. I understand that m is available in the body of the loop, that's not the question here.

This code assumes the text will always start with a match, otherwise, the while cause would raise a type error, since re.match always tries to match at the beginning, unlike re.search which will search the whole string (unless of course you use an anchor).

So yes, it basically keeps searching from the end of the last matching position, finding each subsequent non-overlapping match. You can see this happen like this:

>>> import re
>>> text = "foo some other stuff foo again foo foofofoo"
>>> p = re.compile("foo")
>>> m = p.match(s) # assumes it always matches at the beginning
>>> while print(m) or (m:= p.search(s, m.end())):
...     pass
...
<re.Match object; span=(0, 3), match='foo'>
<re.Match object; span=(21, 24), match='foo'>
<re.Match object; span=(31, 34), match='foo'>
<re.Match object; span=(35, 38), match='foo'>
<re.Match object; span=(40, 43), match='foo'>

So the actual body of the while-loop will only have access to every match starting with the second match.

Note that in this case, you probably just want to use .finditer and a for-loop

>>> for m in p.finditer(text):
...     print(m)
...
<re.Match object; span=(0, 3), match='foo'>
<re.Match object; span=(21, 24), match='foo'>
<re.Match object; span=(31, 34), match='foo'>
<re.Match object; span=(35, 38), match='foo'>
<re.Match object; span=(40, 43), match='foo'>

Unless the body is updating m. Note, in this case, the for-loop would have access to the first match, unlike the body of the while loop. if you wanted to skip the first one, you could always do:

>>> it = p.finditer(text)
>>> next(it)
<re.Match object; span=(0, 3), match='foo'>
>>> for m in it:
...     print(m)
...
<re.Match object; span=(21, 24), match='foo'>
<re.Match object; span=(31, 34), match='foo'>
<re.Match object; span=(35, 38), match='foo'>
<re.Match object; span=(40, 43), match

OP here. I did a small experiment that proved what I was after.

def do(x):
    print(f'x in do = {x}')
    return (x + 1) if x < 5 else None
    
x = 0
while (x := do(x)) is not None:
    print(f'x in while = {x}')

Output:

x in do = 0
x in while = 1
x in do = 1
x in while = 2
x in do = 2
x in while = 3
x in do = 3
x in while = 4
x in do = 4
x in while = 5
x in do = 5

Thus, the answer to my question is "yes, the previous value of the variable is available to the while loop even after the body is exited". Actually, just like a regular variable, the assignment variable is in scope for the rest of the function from the point it is defined.