new string function suggestion

[Andy]

What do people think of this?

'prefixed string'.lchop(' prefix') == 'ed string'
'string with suffix'.rchop(' suffix') == 'string with '
'prefix and suffix.chop('pr efix', 'suffix') == ' and '

The names are analogous to strip, rstrip, and lstrip. But the functionality
is basically this:

def lchop(self, prefix):
assert self.startswith (prefix)
return self[len(prefix):]

def rchop(self, suffix):
assert self.endswith(s uffix)
return self[:-len(suffix]

def chop(self, prefix, suffix):
assert self.startswith (prefix)
assert self.endswith(s uffix)
return self[len(prefix):-len(suffix]

The assert can be a raise of an appropriate exception instead. I find this
to be a very common need, and often newbies assume that the
strip/lstrip/rstrip family behaves like this, but of course they don't.

I get tired of writing stuff like:

if path.startswith ('html/'):
path = path[len('html/'):]
elif s.startswith('t ext/'):
path = path[len('text/'):]

It just gets tedious, and there is duplication. Instead I could just write:

try:
path = path.lchop('htm l/')
path = path.lchop('tex t/')
except SomeException:
pass

Does anyone else find this to be a common need? Has this been suggested
before?

Andy

[Andrew Dalke]

Andy wrote:

What do people think of this?

'prefixed string'.lchop(' prefix') == 'ed string'
'string with suffix'.rchop(' suffix') == 'string with '
'prefix and suffix.chop('pr efix', 'suffix') == ' and '
Your use case is
I get tired of writing stuff like:

if path.startswith ('html/'):
path = path[len('html/'):]
elif s.startswith('t ext/'):
path = path[len('text/'):]

It just gets tedious, and there is duplication. Instead I could just write:

try:
path = path.lchop('htm l/')
path = path.lchop('tex t/')
except SomeException:
pass
But your posted code doesn't implement your use case. Consider
if path == "html/text/something". Then the if/elif code sets
path to "text/something" while the lchop code sets it to "something" .

One thing to consider is a function (or string method) which
is designed around the 'or' function, like this. (Named 'lchop2'
but it doesn't give the same interface as your code.)

def lchop2(s, prefix):
if s.startswith(pr efix):
return s[len(prefix):]
return None

path = lchop2(path, "html/") or lchop2(path, "text/") or path
If I saw a function named "lchop" (or perhaps named "lchomp") I
would expect it to be (named 'lchomp3' so I can distinguish
between it and the other two)

def lchop3(s, prefix):
if s.startswith(pr efix):
return s[len(prefix):]
return s

and not raise an exception if the prefix/suffix doesn't match.
Though in this case your use case is not made any simpler.
Indeed it's uglier with either

newpath = path.lchop3("ht ml/")
if newpath == path
newpath = path.lchop3("te xt/")
if newpath == path:
...

or

if path.startswith ("html/"):
path = path.lstrip("ht ml/")
elif path.startswith ("text/"):
path = path.lstrip("te xt/")
...

I tried finding an example in the stdlib of code that would be
improved with your proposal. Here's something that would not
be improved, from mimify.py (it was the first grep hit I
looked at)

if prefix and line[:len(prefix)] == prefix:
line = line[len(prefix):]
pref = prefix
else:
pref = ''

In your version it would be:

if prefix:
try:
line = line.rstrip(pre fix)
except TheException:
pref = ''
else:
pref = prefix
else:
pref = ''

which is longer than the original.

From pickle.py (grepping for 'endswith(' and a context of 2)

pickle.py- if ashex.endswith( 'L'):
pickle.py: ashex = ashex[2:-1]
pickle.py- else:
pickle.py: ashex = ashex[2:]

this would be better with my '3' variant, as

ashex = ashex.rchop3('L ')[2:]

while your version would have to be

try:
ashex = ashex.rchomp('L ')[2:]
except SomeException:
ashex = ashex[2:]
Even with my '2' version it's the simpler

ashex = (ashex.rchop2(' L') or ashex)[2:]

The most common case will be for something like this

tarfile.py- if self.name.endsw ith(".gz"):
tarfile.py- self.name = self.name[:-3]

My "3" code handles it best

self.name = self.name.rstri p3(".gz")

Because your code throws an exception for what isn't
really an exceptional case it in essence needlessly
requires try/except/else logic instead of the simpler
if/elif logic.
Does anyone else find this to be a common need? Has this been suggested
before?

To summarize:
- I don't think it's needed that often
- I don't think your implementation' s behavior (using an
exception) is what people would expect
- I don't think it does what you expect

Andrew
da***@dalkescie ntific.com

[Steven D'Aprano]

On Mon, 13 Jun 2005 07:05:39 +0000, Andy wrote:

What do people think of this?

'prefixed string'.lchop(' prefix') == 'ed string'
'string with suffix'.rchop(' suffix') == 'string with '
'prefix and suffix.chop('pr efix', 'suffix') == ' and '

The names are analogous to strip, rstrip, and lstrip.
If chop is analogous to strip, then they shouldn't raise exceptions if the
strings do not start with the prefix or suffix.
I get tired of writing stuff like:

if path.startswith ('html/'):
path = path[len('html/'):]
elif s.startswith('t ext/'):
path = path[len('text/'):]

It just gets tedious, and there is duplication. Instead I could just write:

Any time you are writing the same piece of code over and over again, you
should refactor it out as a function in your module, or even in a special
"utility functions" module:

def lchop(s, prefix):
if s.startswith(pr efix): return s[len(prefix):]
raise ValueError("Sub string doesn't begin with prefix.")
# or just return s if you prefer

and then call them whenever you need them.
--
Steven.

[Raymond Hettinger]

[Andrew Dalke]
<200 lines of thorough analysis>

To summarize:
- I don't think it's needed that often
- I don't think your implementation' s behavior (using an
exception) is what people would expect
- I don't think it does what you expect

Wow, that was a remarkably thoughtful, total demolition ;-)
I expect that this thread is going to be somewhat short lived.

[John Machin]

Andy wrote:

What do people think of this?

'prefixed string'.lchop(' prefix') == 'ed string'
'string with suffix'.rchop(' suffix') == 'string with '
'prefix and suffix.chop('pr efix', 'suffix') == ' and '

The names are analogous to strip, rstrip, and lstrip. But the functionality
is basically this:

def lchop(self, prefix):
assert self.startswith (prefix)
return self[len(prefix):]

def rchop(self, suffix):
assert self.endswith(s uffix)
return self[:-len(suffix]

def chop(self, prefix, suffix):
assert self.startswith (prefix)
assert self.endswith(s uffix)
return self[len(prefix):-len(suffix]

The assert can be a raise of an appropriate exception instead. I find this
to be a very common need,
I'm not sure whether I should be surprised or not. I've never felt the
need for such a gadget. I don't even recall seeing such a gadget in
other languages. One normally either maintains a cursor (index or
pointer) without chopping up the original text, or splits the whole text
up into tokens. AFAICT, most simple needs in Python are satisfied by
str.split or re.split. For the special case of file paths, see
os.path.split*. There are also various 3rd party parsing modules -- look
in PyPI.

and often newbies assume that the
strip/lstrip/rstrip family behaves like this, but of course they don't.

I get tired of writing stuff like:

if path.startswith ('html/'):
path = path[len('html/'):]
elif s.startswith('t ext/'):
path = path[len('text/'):]

So create a function (example below) and put it along with others in a
module called (say) andyutils.py ...

def chop_known_pref ixes(path, prefixes):
for prefix in prefixes:
if path.startswith (prefix):
return path[len(prefix):]
return path

By the way, what do you do if path doesn't start with one of the "known"
prefixes?
It just gets tedious, and there is duplication. Instead I could just write:

try:
path = path.lchop('htm l/')
path = path.lchop('tex t/')
except SomeException:
pass

In the event that path contains (say) 'html/text/blahblah...', this
produces 'blahblah...'; the original tedious stuff produces
'text/blahblah...'.
Does anyone else find this to be a common need? Has this been suggested
before?

You can answer that last question yourself by googling comp.lang.pytho n ...