On 7/2/2019 12:56 PM, Terry Reedy
7/2/2019 12:16 AM, Glenn Linderman wrote:
On 7/1/2019 8:28 PM, Terry Reedy wrote:
I did not read much of the thread, but
the proposal is to wrap a near-trivial expression (2
operations) or replace a current method call with a method
call than is more or less the same len as what it replaces.
>>> 'prefix_more_suffix'[len('prefix'):] # if know s
begins with p
>>> 'prefix_more_suffix'.replace('prefix', '')
>>> 'prefix_more_suffix'.strip_pre('prefix') #
Your example isn't equivalent: .replace would replace multiple
instances of prefix, not necessarily at the beginning. The
.strip_pre (however spelled) would strip one instance, only if
it is at the beginning.
I left out the slightly longer regex which does exactly that.
>>> re.sub('^prefix', '', 'prefix_more_suffix')
>>> re.sub('^prefix', '', 'Xprefix_more_suffix')
or with minor variation, deletes only suffixes.
>>> re.sub('suffix$', '', 'prefix_more_suffix')
Are these special cases, which can be easily generalized to match
more than one string, and to replace rather than delete, special
enough to merit a new method each. This remains to be
The more I thought about this, the more I
think a more functional goal is a variation of replace that
works only on one end or the other, rather than a variation of
strip. I outlined that in a different branch in this thread.
To me, a new parameter to str.replace would have a lower bar to
two extra boolean parameters has been suggested; alternatives would
be a single string or flag parameter. replace already accepts a
count parameter for maximum number of replacements from the start.
One could extend that to pass a negative count parameter to mean how
many from the end, which is similar to negative indexing for slices,
which wouldn't even need an extra parameter, but also wouldn't
restrict it to the exact front or end. Together with one extra
boolean to declare the replacement must be at the very front (for
positive count) or very end (for negative count), would also allow
removal of repeated prefixes or suffixes, although I'm not sure that
would be a common case:
text = 'Hello Hello Hello Is this Fred?'
text.replace('Hello ', '', 2, True )
would leave one Hello.
Of course it wouldn't have that effect with a non-empty replacement:
text.replace('Hello ', 'Greetings', 2, True )
would leave two Hello.
To suggest a change, I'd first have run lots of experiments to
figure out what they do... and what the edge conditions are... or,
I'd have to read the implementation to figure it out. I've never
used anything but the first parameter and reading the documentation
for the other two raises more questions than it answers. But I'll
open the issue, maybe someone can quickly answer the questions I
raise, but the terseness of the description of the parameters leaves
a lot of room for speculation.
The other documentation issue I noticed is
that the 2nd and 3rd parameters to startswith and endswith are
not fully documented. Typically startswith and endswitch are in
the logic prior to the strip/replace operation, and typically
only use the first parameter, but looking at their documentation
as part of this discussion, I found it lacking.
File an issue? Preferably with a suggested change.