Почему на минимальное (не жадное) совпадение влияет символ конца строки '$'?

Совпадения «упорядочены» по "самый левый, затем самый длинный"; однако «самый длинный» - это термин, использовавшийся до того, как был разрешен нежадный режим, и вместо этого он означает что-то вроде «предпочтительного количества повторений для каждого атома». Быть крайним слева более важно, чем количество повторений. Таким образом, «a+?$» не будет соответствовать последней букве «А» в «baaaaa», поскольку сопоставление первой буквы «А» начинается раньше в строке.

(Ответ изменен после уточнения OP в комментариях. См. История для предыдущего текста.)

Нежадный модификатор влияет только на то место, где совпадение останавливается, и никогда не влияет на то место, где оно начинается. Если вы хотите начать матч как можно позже, вам придется добавить .+? в начало вашего шаблона.

Без $ ваш шаблон разрешено быть менее жадным и останавливаться раньше, потому что он не должен совпадать с концом строки.

РЕДАКТИРОВАТЬ:

Подробнее... В этом случае:

re.search(r"a+?$", "baaaaaaaa")

движок регулярных выражений будет игнорировать все до первой буквы «а», потому что так работает re.search. Он будет соответствовать первому a и «захочет» вернуть совпадение, за исключением того, что он еще не соответствует шаблону, потому что он должен достичь совпадения для $. Так что он просто ест a по одной и проверяет $. Если бы он был жадным, он не проверял бы $ после каждого a, а только после того, как не смог бы найти больше a.

Но в этом случае:

re.search(r"a+?", "baaaaaaaa")

механизм регулярных выражений проверит наличие полного совпадения после первого совпадения (потому что оно не жадное) и успешно, поскольку в этом случае нет $.

Наличие $ в регулярном выражении не влияет на жадность выражения. Он просто добавляет еще одно условие, которое должно быть выполнено для успешного совпадения в целом.

И a+, и a+? должны потреблять первое найденное a. Если за этим a следуют еще a, a+ идет вперед и поглощает их тоже, в то время как a+? довольствуется только одним. Если бы в регулярном выражении было что-то еще, a+ согласился бы на меньшее количество a, а a+? потреблял бы больше, если это требуется для достижения совпадения.

С помощью a+$ и a+?$ вы добавили еще одно условие: совпадение хотя бы с одним a, за которым следует конец строки. a+ сначала потребляет все a, а затем переходит к якорю ($). Это удается с первой попытки, поэтому a+ не требуется возвращать какие-либо из своих a.

С другой стороны, a+? изначально потребляет только один a, прежде чем передать его $. Это не удается, поэтому управление возвращается к a+?, который потребляет еще один a и снова переключается. И так до тех пор, пока a+? не поглотит последний a, а $, наконец, не добьется успеха. Так что да, a+?$ соответствует тому же количеству a, что и a+$, но делает это неохотно, а не жадно.

Что касается самого длинного правила слева, которое упоминалось в другом месте, оно никогда не применялось к производным от Perl разновидностям регулярных выражений, таким как Python. Даже без неохотных квантификаторов они всегда могут вернуть меньшее, чем максимальное соответствие благодаря упорядоченному чередованию. Я думаю, Ян понял правильную идею: производные от Perl (или ориентированные на регулярные выражения) варианты должны называться eager, не жадный.

Я считаю, что самое длинное правило слева применяется только к регулярным выражениям POSIX NFA, которые используют механизмы NFA под капотом, но должны возвращать те же результаты, что и регулярное выражение DFA (текстовое).

Ответ на исходный вопрос:

Почему первый search() охватывает несколько «/», а не кратчайшее совпадение?

Нежадный подшаблон будет использовать кратчайшее совпадение, согласующееся со всем последующим шаблоном. В вашем примере последний подшаблон — $, поэтому предыдущие нужно растянуть до конца строки.

Ответ на измененный вопрос:

Нежадный подшаблон будет использовать кратчайшее совпадение, согласующееся со всем последующим шаблоном.

Другой взгляд на это: нежадный подшаблон изначально будет соответствовать кратчайшему возможному совпадению. Однако, если это приведет к сбою всего шаблона, он будет повторен с дополнительным символом. Этот процесс продолжается до тех пор, пока подшаблон не выйдет из строя (что приведет к сбою всего шаблона) или пока не совпадет весь шаблон.

Здесь есть две проблемы. Вы использовали group() без указания группы, и я могу говорят, что вы запутались между поведением регулярных выражений с группой, явно заключенной в скобки, и без группы, заключенной в скобки. Это поведение без круглых скобок, которое вы наблюдаете, — это просто ярлык, который предоставляет Python, и вам нужно прочитать документацию на group(), чтобы понять его полностью.

>>> import re
>>> string = "baaa"
>>> 
>>> # Here you're searching for one or more `a`s until the end of the line.
>>> pattern = re.search(r"a+$", string)
>>> pattern.group()
'aaa'
>>> 
>>> # This means the same thing as above, since the presence of the `$`
>>> # cancels out any meaning that the `?` might have.
>>> pattern = re.search(r"a+?$", string)
>>> pattern.group()
'aaa'
>>> 
>>> # Here you remove the `$`, so it matches the least amount of `a` it can.
>>> pattern = re.search(r"a+?", string)
>>> pattern.group()
'a'

Суть в том, что строка a+? соответствует одному a, точка. Однако a+?$ совпадает с a до конца строки. Обратите внимание, что без явной группировки вам будет трудно заставить ? вообще что-либо означать. В общем, в любом случае лучше четко указать, что вы группируете с помощью круглых скобок. Позвольте мне привести вам пример с явными группами.

>>> # This is close to the example pattern with `a+?$` and therefore `a+$`.
>>> # It matches `a`s until the end of the line. Again the `?` can't do anything.
>>> pattern = re.search(r"(a+?)$", string)
>>> pattern.group(1)
'aaa'
>>>
>>> # In order to get the `?` to work, you need something else in your pattern
>>> # and outside your group that can be matched that will allow the selection
>>> # of `a`s to be lazy. # In this case, the `.*` is greedy and will gobble up
>>> # everything that the lazy `a+?` doesn't want to.
>>> pattern = re.search(r"(a+?).*$", string)
>>> pattern.group(1)
'a'

_{Изменить: удален текст, относящийся к старым версиям вопроса.}

Если ваш вопрос не содержит какой-либо важной информации, вам не нужно и не следует использовать регулярное выражение для этой задачи.

>>> import os
>>> p = "/we/shant/see/this/butshouldseethis"
>>> os.path.basename(p)
butshouldseethis