gh-95913: Edit & expand Optimizations in 3.11 WhatsNew

Doc/whatsnew/3.11.rst

@@ -1128,34 +1128,63 @@ fcntl
 Optimizations
 =============
 
-* Compiler now optimizes simple C-style formatting with literal format
-  containing only format codes ``%s``, ``%r`` and ``%a`` and makes it as
-  fast as corresponding f-string expression.
-  (Contributed by Serhiy Storchaka in :issue:`28307`.)
+This section covers specific optimizations independent of the
+:ref:`whatsnew311-faster-cpython` project, which is covered in its own section.
 
-* "Zero-cost" exceptions are implemented. The cost of ``try`` statements is
-  almost eliminated when no exception is raised.
+* "Zero-cost" exceptions are implemented, eliminating the cost
+  of :keyword:`try` statements when no exception is raised.
   (Contributed by Mark Shannon in :issue:`40222`.)
 
-* Pure ASCII strings are now normalized in constant time by :func:`unicodedata.normalize`.
-  (Contributed by Dong-hee Na in :issue:`44987`.)
+* The compiler now optimizes simple
+  :ref:`printf-style % formatting <old-string-formatting>` on string literals
+  containing only the format codes ``%s``, ``%r`` and ``%a`` and makes it as
+  fast as a corresponding :term:`f-string` expression.
+  (Contributed by Serhiy Storchaka in :issue:`28307`.)
 
-* :mod:`math` functions :func:`~math.comb` and :func:`~math.perm` are now up
-  to 10 times or more faster for large arguments (the speed up is larger for
-  larger *k*).
-  (Contributed by Serhiy Storchaka in :issue:`37295`.)
+* Integer division (``//``) is better tuned for optimization by compilers.
+  It is now around 20% faster on x86-64 when dividing an :class:`int`
+  by a value smaller than ``2**30``.
+  (Contributed by Gregory P. Smith and Tim Peters in :gh:`90564`.)
+
+* :func:`sum` is now nearly 30% faster for integers smaller than ``2**30``.
+  (Contributed by Stefan Behnel in :gh:`68264`.)
+
+* Resizing lists is streamlined for the common case,
+  speeding up :meth:`list.append` by ≈15%
+  and simple :term:`list comprehension`\s by up to 20-30%
+  (Contributed by Dennis Sweeney in :gh:`91165`.)
 
-* Dict don't store hash value when all inserted keys are Unicode objects.
-  This reduces dict size. For example, ``sys.getsizeof(dict.fromkeys("abcdefg"))``
-  becomes 272 bytes from 352 bytes on 64bit platform.
+* Dictionaries don't store hash values when all keys are Unicode objects,
+  decreasing :class:`dict` size.
+  For example, ``sys.getsizeof(dict.fromkeys("abcdefg"))``
+  is reduced from 352 bytes to 272 bytes (23% smaller) on 64-bit platforms.
   (Contributed by Inada Naoki in :issue:`46845`.)
 
+* Using :class:`asyncio.DatagramProtocol` is now orders of magnitude faster
+  when transferring large files over UDP,
+  with speeds over 100 times higher for a ≈60 MiB file.
+  (Contributed by msoxzw in :gh:`91487`.)
+
+* :mod:`math` functions :func:`~math.comb` and :func:`~math.perm` are now
+  ≈10 times faster for large arguments (with a larger speedup for larger *k*).
+  (Contributed by Serhiy Storchaka in :issue:`37295`.)
+
 * :mod:`re`'s regular expression matching engine has been partially refactored,
   and now uses computed gotos (or "threaded code") on supported platforms. As a
   result, Python 3.11 executes the `pyperformance regular expression benchmarks
   <https://pyperformance.readthedocs.io/benchmarks.html#regex-dna>`_ up to 10%
   faster than Python 3.10.
 
+* The :mod:`statistics` functions :func:`~statistics.mean`,
+  :func:`~statistics.variance` and :func:`~statistics.stdev` now consume
+  iterators in one pass rather than converting them to a :class:`list` first.
+  This is twice as fast and can save substantial memory.
+  (Contributed by Raymond Hettinger in :gh:`90415`.)
+
+* :func:`unicodedata.normalize`
+  now normalizes pure-ASCII strings in constant time.
+  (Contributed by Dong-hee Na in :issue:`44987`.)
+
 
 .. _whatsnew311-faster-cpython: