Can't find the correct regex syntax to match newline or end of string

Question

This feels like a really simple question, but I can't find the answer anywhere.

(Notes: I'm using Python, but this shouldn't matter.)

Say I have the following string:

s = "foo\nbar\nfood\nfoo"

I am simply trying to find a regex that will match both instances of "foo", but not "food", based on the fact that the "foo" in "food" is not immediately followed by either a newline or the end of the string.

This is perhaps an overly complicated way to express my question, but it gives something concrete to work with.

Here are some of the things I have tried, with results (Note: the result I want is [foo\n, foo]):

foo[\n\Z] => ['foo\n']

foo(\n\Z) => ['\n', ''] <= This seems to match the newline and EOS, but not the foo

foo($|\n) => ['\n', '']

(foo)($|\n) => [(foo,'\n'), (foo,'')] <= Almost there, and this is a useable plan B, but I would like to find the perfect solution.

The only thing I found that does work is:

foo$|foo\n => ['foo\n', `'foo']

This is fine for such a simple example, but it is easy to see how it could become unwieldy with a much larger expression (and yes, this foo thing is a stand in for the larger expression I am actually using).

---

Interesting aside: The closest SO question I could find to my problem was this one: In regex, match either the end of the string or a specific character

Here, I could simply substitute \n for my 'specific character'. Now, the accepted answer uses the regex /(&|\?)list=.*?(&|$)/. I notice that the OP was using JavaScript (question was tagged with the javascript tag), so maybe the JavaScript regex interpreter is different, but when I use the exact strings given in the question with the above regex in Python, I get bad results:

>>> findall("(&|\?)list=.*?(&|$)", "index.php?test=1&list=UL")
[('&', '')]
>>> findall("(&|\?)list=.*?(&|$)", "index.php?list=UL&more=1")
[('?', '&')]

So, I'm stumped.

Answer 1

>>> import re
>>> re.findall(r'foo(?:$|\n)', "foo\nbar\nfood\nfoo")
['foo\n', 'foo']

(?:...) makes a non-capturing group.

This works because (from re module reference):

re.findall(pattern, string, flags=0)

Return all non-overlapping matches of pattern in string, as a list of strings. The string is scanned left-to-right, and matches are returned in the order found. If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result unless they touch the beginning of another match.

Answer 2

You could use re.MULTILINE and include an optional linebreak after the $ in your pattern:

s = "foo\nbar\nfood\nfoo"
pattern = re.compile('foo$\n?', re.MULTILINE)
print re.findall(pattern, s)
# -> ['foo\n', 'foo']

Answer 3

If you're only concerned with foo:

In [42]: import re

In [43]: strs="foo\nbar\nfood\nfoo"

In [44]: re.findall(r'\bfoo\b',strs)
Out[44]: ['foo', 'foo']

\b is denotes a word boundary:

\b

Matches the empty string, but only at the beginning or end of a word. A word is defined as a sequence of alphanumeric or underscore characters, so the end of a word is indicated by whitespace or a non-alphanumeric, non-underscore character. Note that formally, \b is defined as the boundary between a \w and a \W character (or vice versa), or between \w and the beginning/end of the string, so the precise set of characters deemed to be alphanumeric depends on the values of the UNICODE and LOCALE flags. For example, r'\bfoo\b' matches 'foo', 'foo.', '(foo)', 'bar foo baz' but not 'foobar' or 'foo3'. Inside a character range, \b represents the backspace character, for compatibility with Python’s string literals.

(Source)