Add list.discard() and deque.discard()

gerardw · October 12, 2025, 8:14pm

Sometimes you want to remove something collection if it’s in there.
set → discard()
dict → pop()
list → requires checking first on try / except.
deque → requires checking first on try / except.
It’s a weird inconsistency and I’m not aware of any reason beyond tradtion.

discard would be consistent with set and list and deque already have pop methods.

JoBe · October 12, 2025, 8:43pm

Personal im +1 on this. Perhaps adding a dict.discard (same as dict.pop) would help it be the same name everywhere.

But generally, great idea, I’ve found myself often implementing helpers doing this kind of stuff.

Stefan2 · October 12, 2025, 8:45pm

Or an elephant.

Elephant in Cairo - Wikipedia

def discard(xs, x):
    xs.append(x)
    xs.remove(x)
    if xs and xs[-1] is x:
        xs.pop()

xs = [1, 2, 3]
discard(xs, 3)
print(xs)
discard(xs, 3)
print(xs)

Attempt This Online!

JoBe · October 12, 2025, 8:52pm

This works, but it’s both less readable and slower (assuming .remove, .pop, .append and .__contains__each take some time C).

It’s complexed than it needs to be. Another thing this lacks are standards. .append, .remove are not guaranteed for, say a Sequence[...]). Just adding a simple .discard to all sequences would be easier.

tim.one · October 12, 2025, 9:21pm

I think it’s actually stranger that the indexed sequence types support .remove() at all .

The dict and set types are “content-addressable”. Insertion and deletion work by object value, are O(1), and can’t be indexed directly by ordinals.

The indexed sequence types share none of those properties.

It became “a tradition” because nobody cared enough about sequence.discard(unwanted) to press for it in the early years. Lack of compelling use cases. Things like dict.pop(unwanted) were driven by frequently expressed need. dict.pop() in fact was added in Python 2.0, along with dict.popitem(). They didn’t exist from the start.

I’m neutral on whether sequence.discard() is added now. Not an itch I have, but if enough others do, fine by me.

Stefan2 · October 12, 2025, 9:28pm

Only searches once, so can be twice as fast as “checking first”. And can be hundreds of ns faster than “try / except” when the value isn’t there.

blhsing · October 13, 2025, 1:52am

sequence.remove can be more efficient than set.remove/dict.pop when the size of a typical sequence for the specific use case is expected to be small, since sets and dicts require hashing first.

Use cases for sequence.discard are not uncommon at all, including:

github.com/python/cpython

Lib/threading.py

bb85af343


      
                  else:
                      if timeout > 0:
                          gotit = waiter.acquire(True, timeout)
                      else:
                          gotit = waiter.acquire(False)
                  return gotit
              finally:
                  self._acquire_restore(saved_state)
                  if not gotit:
                      try:
                          self._waiters.remove(waiter)
                      except ValueError:
                          pass
          
          def wait_for(self, predicate, timeout=None):
              """Wait until a condition evaluates to True.
          
              predicate should be a callable which result will be interpreted as a
              boolean value.  A timeout may be provided giving the maximum time to
              wait.

github.com/python/cpython

Lib/runpy.py

bb85af343


      
                      # code. If we don't do this, a __loader__ attribute in the
                      # existing __main__ module may prevent location of the new module.
                      mod_name, mod_spec, code = _get_main_module_details()
                      with _TempModule(run_name) as temp_module, \
                           _ModifiedArgv0(path_name):
                          mod_globals = temp_module.module.__dict__
                          return _run_code(code, mod_globals, init_globals,
                                              run_name, mod_spec, pkg_name).copy()
                  finally:
                      try:
                          sys.path.remove(path_name)
                      except ValueError:
                          pass
          
          
          if __name__ == "__main__":
              # Run the module specified as the next command line argument
              if len(sys.argv) < 2:
                  print("No module specified for execution", file=sys.stderr)
              else:
                  del sys.argv[0] # Make the requested module sys.argv[0]

github.com/python/cpython

Lib/_py_warnings.py

bb85af343


      
                  _wm._filters_mutated_lock_held()
          
          
          def _add_filter(*item, append):
              with _wm._lock:
                  filters = _wm._get_filters()
                  if not append:
                      # Remove possible duplicate filters, so new one will be placed
                      # in correct place. If append=True and duplicate exists, do nothing.
                      try:
                          filters.remove(item)
                      except ValueError:
                          pass
                      filters.insert(0, item)
                  else:
                      if item not in filters:
                          filters.append(item)
                  _wm._filters_mutated_lock_held()
          
          
          def resetwarnings():

github.com/python/cpython

Lib/idlelib/window.py

bb85af343


      
                  list.append((title, key, window))
              list.sort()
              for title, key, window in list:
                  menu.add_command(label=title, command=window.wakeup)
          
          def register_callback(self, callback):
              self.callbacks.append(callback)
          
          def unregister_callback(self, callback):
              try:
                  self.callbacks.remove(callback)
              except ValueError:
                  pass
          
          def call_callbacks(self):
              for callback in self.callbacks:
                  try:
                      callback()
                  except:
                      t, v, tb = sys.exc_info()
                      print("warning: callback failed in WindowList", t, ":", v)

github.com/python/cpython

Lib/subprocess.py

bb85af343


      
              # created, to avoid zombie processes.
              _active = []
          
              def _cleanup():
                  if _active is None:
                      return
                  for inst in _active[:]:
                      res = inst._internal_poll(_deadstate=sys.maxsize)
                      if res is not None:
                          try:
                              _active.remove(inst)
                          except ValueError:
                              # This can happen if two threads create a new Popen instance.
                              # It's harmless that it was already removed, so ignore.
                              pass
          
          PIPE = -1
          STDOUT = -2
          DEVNULL = -3

github.com/python/cpython

Lib/logging/init.py

bb85af343


      
              # This function can be called during module teardown, when globals are
              # set to None. It can also be called from another thread. So we need to
              # pre-emptively grab the necessary globals and check if they're None,
              # to prevent race conditions and failures during interpreter shutdown.
              handlers, lock = _handlerList, _lock
              if lock and handlers:
                  with lock:
                      try:
                          handlers.remove(wr)
                      except ValueError:
                          pass
          
          def _addHandlerRef(handler):
              """
              Add a handler to the internal cleanup list using a weak reference.
              """
              with _lock:
                  _handlerList.append(weakref.ref(handler, _removeHandlerRef))
          
          
          def getHandlerByName(name):

So while yes it is easily worked around with a try-except block, it would still be a meaningful method to have.

Paddy3118 · October 13, 2025, 2:58pm

I’ve learnt something new today, (despite it being dated 1989).

Thank you

Stanfromireland · October 14, 2025, 4:33pm

For those curious, list.discard() can be implemented by removing a single line (i.e. raise ValueError) from the list.remove() implementation. Here is a patch.

tjreedy · October 15, 2025, 4:05pm

I suspect that some of the ‘remove’ examples could now use a set rather than a list, but predate that addition, or wrap OS functions that return (short) lists.

Rather than a new, near duplicate function, I would prefer a proposal to add a parameter to the existing list.remove to raise or not upon value absence (defaulting to True for back compatibility).

Stanfromireland · October 15, 2025, 4:53pm

Rather than a new, near duplicate function, I would prefer a proposal to add a parameter to the existing list.remove to raise or not upon value absence (defaulting to True for back compatibility).

I think this would be inconsistent with the other API’s as mentioned in the original post. As for the implementation, that could be moved to a helper to deduplicate.

Anyhow, if anyone wants to propose this as a PEP, (I myself would find it useful, though not particularly important) I am happy to help write it/co-author.