cpython/Doc$ grep -r "normalis.*" 
library/xml.etree.elementtree.rst:   Canonicalization is a way to normalise XML output in a way that allows
cpython/Doc$ grep -r "normaliz.*" 
reference/expressions.rst:   intuitive to humans), use :func:`unicodedata.normalize`.
reference/lexical_analysis.rst:   xid_start: <all characters in `id_start` whose NFKC normalization is in "id_start xid_continue*">
reference/lexical_analysis.rst:   xid_continue: <all characters in `id_continue` whose NFKC normalization is in "id_continue*">
howto/sorting.rst:    >>> from unicodedata import normalize
howto/sorting.rst:    >>> sorted(names, key=partial(normalize, 'NFD'))
howto/sorting.rst:    >>> sorted(names, key=partial(normalize, 'NFC'))
howto/unicode.rst::func:`~unicodedata.normalize` function that converts strings to one
howto/unicode.rst:replaced with single characters.  :func:`~unicodedata.normalize` can
howto/unicode.rst:            return unicodedata.normalize('NFD', s)
howto/unicode.rst:The first argument to the :func:`~unicodedata.normalize` function is a
howto/unicode.rst:string giving the desired normalization form, which can be one of
howto/unicode.rst:            return unicodedata.normalize('NFD', s)
howto/unicode.rst:non-normalized string, so the result needs to be normalized again. See
c-api/long.rst:   The function takes care of normalizing the digits and converts the object
c-api/exceptions.rst:      to avoid any possible de-normalization.
c-api/exceptions.rst:   can be "unnormalized", meaning that ``*exc`` is a class object but ``*val`` is
c-api/exceptions.rst:   the class in that case.  If the values are already normalized, nothing happens.
c-api/exceptions.rst:   The delayed normalization is implemented to improve performance.
c-api/init_config.rst:      At Python startup, the encoding name is normalized to the Python codec
c-api/float.rst:   Return the minimum normalized positive float *DBL_MIN* as C :c:expr:`double`.
whatsnew/3.12.rst:* The interpreter's error indicator is now always normalized. This means
whatsnew/3.12.rst:  functions that set the error indicator now normalize the exception
whatsnew/3.5.rst:a normalized number string, taking the ``LC_NUMERIC`` settings into account::
whatsnew/3.10.rst::func:`encodings.normalize_encoding` now ignores non-ASCII characters.
whatsnew/3.2.rst:  custom :class:`dict` subclasses that normalize keys before look-up or that
whatsnew/3.11.rst:* :func:`unicodedata.normalize`
whatsnew/3.11.rst:  now normalizes pure-ASCII strings in constant time.
whatsnew/3.9.rst::mod:`xml.etree.ElementTree` to XML file. EOLNs are no longer normalized
whatsnew/3.9.rst:* :func:`codecs.lookup` now normalizes the encoding name the same way as
whatsnew/3.9.rst:  :func:`encodings.normalize_encoding`, except that :func:`codecs.lookup` also
whatsnew/3.9.rst:  name is now normalized to ``"latex_latin1"``.
whatsnew/3.8.rst:   from unicodedata import normalize
whatsnew/3.8.rst:    if (clean_name := normalize('NFC', name)) in allowed_names]
whatsnew/3.8.rst:    >>> {(n := normalize('NFC', name)).casefold() : n for name in names}
whatsnew/3.8.rst:New function :func:`~unicodedata.is_normalized` can be used to verify a string
whatsnew/3.8.rst:is in a specific normal form, often much faster than by actually normalizing
library/sys.rst:        - The minimum representable positive *normalized* float.
library/sys.rst:          *denormalized* representable float.
library/sys.rst:        - The minimum integer *e* such that ``radix**(e-1)`` is a normalized
library/sys.rst:        - The minimum integer *e* such that ``10**e`` is a normalized float.
library/datetime.rst:   and days, seconds and microseconds are then normalized so that the
library/datetime.rst:   *days*, *seconds* and *microseconds* are "merged" and normalized into those
library/datetime.rst:   conversion and normalization processes are exact (no information is
library/datetime.rst:   If the normalized value of days lies outside the indicated range,
library/datetime.rst:   Note that normalization of negative values may be surprising at first. For
library/datetime.rst:Note that, because of normalization, ``timedelta.max`` is greater than ``-timedelta.min``.
library/datetime.rst:   String representations of :class:`timedelta` objects are normalized
library/datetime.rst:An additional example of normalization::
library/datetime.rst:   If ``d`` is aware, ``d`` is normalized to UTC time, by subtracting
library/datetime.rst:   normalized time is returned. :attr:`!tm_isdst` is forced to 0. Note
library/locale.rst:.. function:: normalize(localename)
library/locale.rst:   Returns a normalized locale code for the given locale name.  The returned locale
library/locale.rst:   code is formatted for use with :func:`setlocale`.  If normalization fails, the
library/locale.rst:    Converts a string into a normalized number string, following the
library/locale.rst:    Converts a normalized number string into a formatted string following the
library/gettext.rst:   :func:`find` then expands and normalizes the languages, and then iterates
library/email.charset.rst:   case.  After being alias normalized it is also used as a lookup into the
library/fnmatch.rst:   returning ``True`` or ``False``.  Both parameters are case-normalized
library/email.contentmanager.rst:         :meth:`str.splitlines` is used to normalize all line boundaries,
library/urllib.parse.rst:   normalization (as used by the IDNA encoding) into any of ``/``, ``?``,
library/urllib.parse.rst:      Characters that affect netloc parsing under NFKC normalization will
library/urllib.parse.rst:   normalization (as used by the IDNA encoding) into any of ``/``, ``?``,
library/urllib.parse.rst:      Characters that affect netloc parsing under NFKC normalization will
library/urllib.parse.rst:   differ from the original URL in that the scheme may be normalized to lower
library/codecs.rst:performs certain normalizations on host names, to achieve case-insensitivity of
library/math.rst:     *denormalized* representable float (smaller than the minimum positive
library/math.rst:     *normalized* float, :data:`sys.float_info.min <sys.float_info>`).
library/os.path.rst:   Return a normalized absolutized version of the pathname *path*. On most
library/os.path.rst:   backward slashes. To normalize case, use :func:`normcase`.
library/random.rst:positive unnormalized float and is equal to ``math.ulp(0.0)``.)
library/zoneinfo.rst:    ``key`` must be in the form of a relative, normalized POSIX path, with no
library/gzip.rst:      with no other normalization, resolution or expansion.
library/textwrap.rst:   Lines containing only whitespace are ignored in the input and normalized to a
library/annotationlib.rst:      whitespace normalizations and constant values optimizations.
library/fractions.rst:      The :func:`math.gcd` function is now used to normalize the *numerator*
library/typing.rst:   :mod:`collections` class, it will be normalized to the original class.
library/xml.dom.rst:.. method:: Node.normalize()
library/bdb.rst:      :func:`case-normalized <os.path.normcase>` :func:`absolute path
library/ctypes.rst:   process.  These paths are not normalized or processed in any way.  The function
library/pathlib.rst:   Make the path absolute, without normalization or resolving symlinks.
library/pathlib.rst:pathlib's path normalization is slightly more opinionated and consistent than
library/pathlib.rst:pathlib's path normalization may render it unsuitable for some applications:
library/pathlib.rst:1. pathlib normalizes ``Path("my_folder/")`` to ``Path("my_folder")``, which
library/pathlib.rst:2. pathlib normalizes ``Path("./my_program")`` to ``Path("my_program")``,
library/unicodedata.rst:.. function:: normalize(form, unistr)
library/unicodedata.rst:   The Unicode standard defines various normalization forms of a Unicode string,
library/unicodedata.rst:   Even if two unicode strings are normalized and look the same to
library/unicodedata.rst:.. function:: is_normalized(form, unistr)
library/decimal.rst:   .. method:: normalize(context=None)
library/decimal.rst:      normalize to the equivalent value ``Decimal('32.1')``.
library/decimal.rst:   .. method:: normalize(x)
library/decimal.rst:normalized floating-point representations, it is not immediately obvious that
library/decimal.rst:A. The :meth:`~Decimal.normalize` method maps all equivalent values to a single
library/decimal.rst:   >>> [v.normalize() for v in values]
library/decimal.rst:    ...     return d.quantize(Decimal(1)) if d == d.to_integral() else d.normalize()
library/stringprep.rst:preparation procedure, after which they have a certain normalized form. The RFC
library/stringprep.rst:   case-folding used with no normalization).
library/zipfile.rst:   Returns the normalized path created (a directory or new file).
conf.py:    # pypi.org project name normalization (upper to lowercase, underscore to hyphen)