added documentation and blurb

Author: Marius-Juston

Doc/howto/sorting.rst

@@ -400,6 +400,11 @@ library provides several tools that do less work than a full sort:
   respectively.  These functions make a single pass over the input data and
   require almost no auxiliary memory.
 
+* :func:`minmax` returns both the smallest and largest values,
+respectively. This functions make a single pass over the input data and
+require almost no auxiliary memory. This function is useful if both `min` and
+`max` need to be called and thus is more efficient for larger datasets.
+
 * :func:`heapq.nsmallest` and :func:`heapq.nlargest` return
   the *n* smallest and largest values, respectively.  These functions
   make a single pass over the data keeping only *n* elements in memory

Doc/library/functions.rst

@@ -1295,6 +1295,28 @@ are always available.  They are listed here in alphabetical order.
    .. versionchanged:: 3.8
       The *key* can be ``None``.
 
+.. function:: minmax(iterable, /, *, key=None)
+              minmax(iterable, /, *, default, key=None)
+              minmax(arg1, arg2, /, *args, key=None)
+
+   Return the smallest and largest items respectively in an iterable or the smallest and largest
+   of two or more arguments.
+
+   If one positional argument is provided, it should be an :term:`iterable`.
+   The smallest and largest items in the iterable are returned.  If two or more positional
+   arguments are provided, the smallest and largest of the positional arguments are
+   returned.
+
+   There are two optional keyword-only arguments. The *key* argument specifies
+   a one-argument ordering function like that used for :meth:`list.sort`. The
+   *default* argument specifies an object to return if the provided iterable is
+   empty. If the iterable is empty and *default* is not provided, a
+   :exc:`ValueError` is raised.
+
+   If multiple items are minimal / maximal, the function returns the first one
+   encountered.  This is consistent with other sort-stability preserving tools
+   such as ``(sorted(iterable, key=keyfunc)[0], sorted(iterable, key=keyfunc)[-1])``
+   and ``(heapq.nsmallest(1,iterable, key=keyfunc), heapq.nlargest(1,iterable, key=keyfunc))``.
 
 .. function:: next(iterator, /)
               next(iterator, default, /)

Misc/NEWS.d/next/Core_and_Builtins/2026-02-01-15-31-11.gh-issue-144382.EyosHQ.rst

@@ -0,0 +1,4 @@
+This creates a new builtin function called `minmax`, which does work similar
+to the functions `min` and `max`; however, is more efficient than running
+`min` and then `max` and computes the smallest and largest elements of the
+iterable in a single pass; rather than 2 passes.