find_recursionlimit.py

• Current:

  if test_func_name.startswith("test_"):
      print(test_func_name[5:])
  else:
      print(test_func_name)
  

• Improved:

  print(test_func_name.removeprefix("test_"))
  

deccheck.py

This is an interesting case because the author chose to use the str.replace method in a situation where only a prefix was intended to be removed.

• Current:

  if funcname.startswith("context."):
      self.funcname = funcname.replace("context.", "")
      self.contextfunc = True
  else:
      self.funcname = funcname
      self.contextfunc = False
  

• Improved:

  if funcname.startswith("context."):
      self.funcname = funcname.removeprefix("context.")
      self.contextfunc = True
  else:
      self.funcname = funcname
      self.contextfunc = False
  

• Arguably further improved:

  self.contextfunc = funcname.startswith("context.")
  self.funcname = funcname.removeprefix("context.")
  

cookiejar.py

• Current:

  def strip_quotes(text):
      if text.startswith('"'):
          text = text[1:]
      if text.endswith('"'):
          text = text[:-1]
      return text
  

• Improved:

  def strip_quotes(text):
      return text.removeprefix('"').removesuffix('"')
  

test_i18n.py

• Current:

  creationDate = header['POT-Creation-Date']
  
  # peel off the escaped newline at the end of string
  if creationDate.endswith('\\n'):
      creationDate = creationDate[:-len('\\n')]
  

• Improved:

  creationDate = header['POT-Creation-Date'].removesuffix('\\n')
  

There were many other such examples in the stdlib.

Expand the lstrip and rstrip APIs

Because lstrip takes a string as its argument, it could be viewed as taking an iterable of length-1 strings. The API could, therefore, be generalized to accept any iterable of strings, which would be successively removed as prefixes. While this behavior would be consistent, it would not be obvious for users to have to call 'foobar'.lstrip(('foo',)) for the common use case of a single prefix.

Remove multiple copies of a prefix

This is the behavior that would be consistent with the aforementioned expansion of the lstrip/rstrip API – repeatedly applying the function until the argument is unchanged. This behavior is attainable from the proposed behavior via by the following:

>>> s = 'Foo' * 100 + 'Bar'
>>> prefix = 'Foo'
>>> while s.startswith(prefix): s = s.removeprefix(prefix)
>>> s
'Bar'

Raising an exception when not found

There was a suggestion that s.removeprefix(pre) should raise an exception if not s.startswith(pre). However, this does not match with the behavior and feel of other string methods. There could be required=False keyword added, but this violates the KISS principle.

Accepting a tuple of affixes

It could be convenient to write the test_concurrent_futures.py example above as name.removesuffix(('Mixin', 'Tests', 'Test')), so there was a suggestion that the new methods be able to take a tuple of strings as an argument, similar to the startswith() API. Within the tuple, only the first matching affix would be removed. This was rejected on the following grounds:

• This behavior can be surprising or visually confusing, especially when one prefix is empty or is a substring of another prefix, as in 'FooBar'.removeprefix(('', 'Foo')) == 'FooBar' or 'FooBar text'.removeprefix(('Foo', 'FooBar ')) == 'Bar text'.
• The API for str.replace() only accepts a single pair of replacement strings, but has stood the test of time by refusing the temptation to guess in the face of ambiguous multiple replacements.
• There may be a compelling use case for such a feature in the future, but generalization before the basic feature sees real-world use would be easy to get permanently wrong.

Alternative Method Names

Several alternatives method names have been proposed. Some are listed below, along with commentary for why they should be rejected in favor of removeprefix (the same arguments hold for removesuffix).

• ltrim, trimprefix, etc.:

  “Trim” does in other languages (e.g. JavaScript, Java, Go, PHP) what strip methods do in Python.

• lstrip(string=...)

  This would avoid adding a new method, but for different behavior, it’s better to have two different methods than one method with a keyword argument that selects the behavior.

• remove_prefix:

  All of the other methods of the string API, e.g. str.startswith(), use lowercase rather than lower_case_with_underscores.

• removeleft, leftremove, or lremove:

  The explicitness of “prefix” is preferred.

• cutprefix, deleteprefix, withoutprefix, dropprefix, etc.:

  Many of these might have been acceptable, but “remove” is unambiguous and matches how one would describe the “remove the prefix” behavior in English.

• stripprefix:

  Users may benefit from remembering that “strip” means working with sets of characters, while other methods work with substrings, so re-using “strip” here should be avoided.