Fix error with stop/end, update chr() and ord(), change kwdto kwargs.

serhiy-storchaka · serhiy-storchaka · commit 899cc860a51e · 2025-08-12T13:48:31.000+03:00
diff --git a/Doc/library/functions.rst b/Doc/library/functions.rst
@@ -242,14 +242,14 @@ are always available.  They are listed here in alphabetical order.
       in Python 3.2.
 
 
-.. function:: chr(i, /)
+.. function:: chr(codepoint, /)
 
-   Return the string representing a character whose Unicode code point is the
-   integer *i*.  For example, ``chr(97)`` returns the string ``'a'``, while
+   Return the string representing a character with the specified Unicode code point.
+   For example, ``chr(97)`` returns the string ``'a'``, while
    ``chr(8364)`` returns the string ``'€'``. This is the inverse of :func:`ord`.
 
    The valid range for the argument is from 0 through 1,114,111 (0x10FFFF in
-   base 16).  :exc:`ValueError` will be raised if *i* is outside that range.
+   base 16).  :exc:`ValueError` will be raised if it is outside that range.
 
 
 .. decorator:: classmethod
@@ -1559,13 +1559,18 @@ are always available.  They are listed here in alphabetical order.
    .. versionchanged:: 3.11
       The ``'U'`` mode has been removed.
 
-.. function:: ord(c, /)
+.. function:: ord(character, /)
 
-   Given a string representing one Unicode character, return an integer
+   The argument must be a one-character string or a :term:`bytes-like object`
+   of length 1.
+   If it is a one-character string, return an integer
    representing the Unicode code point of that character.  For example,
    ``ord('a')`` returns the integer ``97`` and ``ord('€')`` (Euro sign)
    returns ``8364``.  This is the inverse of :func:`chr`.
 
+   If the argument is a bytes-like object of length 1, return an integer value
+   of its element.
+
 
 .. function:: pow(base, exp, mod=None)
 
@@ -2059,7 +2064,7 @@ are always available.  They are listed here in alphabetical order.
 
 
 .. class:: type(object, /)
-           type(name, bases, dict, /, **kwds)
+           type(name, bases, dict, /, **kwargs)
 
    .. index:: pair: object; type
 
diff --git a/Doc/library/stdtypes.rst b/Doc/library/stdtypes.rst
@@ -1806,7 +1806,7 @@ expression support in the :mod:`re` module).
       'Python'
 
 
-.. method:: str.count(sub, start=0, stop=None, /)
+.. method:: str.count(sub, start=0, end=None, /)
 
    Return the number of non-overlapping occurrences of substring *sub* in the
    range [*start*, *end*].  Optional arguments *start* and *end* are
@@ -1861,7 +1861,7 @@ expression support in the :mod:`re` module).
       in :ref:`debug mode <debug-build>`.
 
 
-.. method:: str.endswith(suffix, start=0, stop=None, /)
+.. method:: str.endswith(suffix, start=0, end=None, /)
 
    Return ``True`` if the string ends with the specified *suffix*, otherwise return
    ``False``.  *suffix* can also be a tuple of suffixes to look for.  With optional
@@ -1905,7 +1905,7 @@ expression support in the :mod:`re` module).
       0123    01234
 
 
-.. method:: str.find(sub, start=0, stop=None, /)
+.. method:: str.find(sub, start=0, end=None, /)
 
    Return the lowest index in the string where substring *sub* is found within
    the slice ``s[start:end]``.  Optional arguments *start* and *end* are
@@ -1968,7 +1968,7 @@ expression support in the :mod:`re` module).
    .. versionadded:: 3.2
 
 
-.. method:: str.index(sub, start=0, stop=None, /)
+.. method:: str.index(sub, start=0, end=None, /)
 
    Like :meth:`~str.find`, but raise :exc:`ValueError` when the substring is
    not found.
@@ -2217,14 +2217,14 @@ expression support in the :mod:`re` module).
       *count* is now supported as a keyword argument.
 
 
-.. method:: str.rfind(sub, start=0, stop=None, /)
+.. method:: str.rfind(sub, start=0, end=None, /)
 
    Return the highest index in the string where substring *sub* is found, such
    that *sub* is contained within ``s[start:end]``.  Optional arguments *start*
    and *end* are interpreted as in slice notation.  Return ``-1`` on failure.
 
 
-.. method:: str.rindex(sub, start=0, stop=None, /)
+.. method:: str.rindex(sub, start=0, end=None, /)
 
    Like :meth:`rfind` but raises :exc:`ValueError` when the substring *sub* is not
    found.
@@ -2395,7 +2395,7 @@ expression support in the :mod:`re` module).
       ['Two lines', '']
 
 
-.. method:: str.startswith(prefix, start=0, stop=None, /)
+.. method:: str.startswith(prefix, start=0, end=None, /)
 
    Return ``True`` if string starts with the *prefix*, otherwise return ``False``.
    *prefix* can also be a tuple of prefixes to look for.  With optional *start*,
@@ -3141,8 +3141,8 @@ binary data. These restrictions are covered below.
 The following methods on bytes and bytearray objects can be used with
 arbitrary binary data.
 
-.. method:: bytes.count(sub, start=0, stop=None, /)
-            bytearray.count(sub, start=0, stop=None, /)
+.. method:: bytes.count(sub, start=0, end=None, /)
+            bytearray.count(sub, start=0, end=None, /)
 
    Return the number of non-overlapping occurrences of subsequence *sub* in
    the range [*start*, *end*].  Optional arguments *start* and *end* are
@@ -3234,8 +3234,8 @@ arbitrary binary data.
       in :ref:`debug mode <debug-build>`.
 
 
-.. method:: bytes.endswith(suffix, start=0, stop=None, /)
-            bytearray.endswith(suffix, start=0, stop=None, /)
+.. method:: bytes.endswith(suffix, start=0, end=None, /)
+            bytearray.endswith(suffix, start=0, end=None, /)
 
    Return ``True`` if the binary data ends with the specified *suffix*,
    otherwise return ``False``.  *suffix* can also be a tuple of suffixes to
@@ -3245,8 +3245,8 @@ arbitrary binary data.
    The suffix(es) to search for may be any :term:`bytes-like object`.
 
 
-.. method:: bytes.find(sub, start=0, stop=None, /)
-            bytearray.find(sub, start=0, stop=None, /)
+.. method:: bytes.find(sub, start=0, end=None, /)
+            bytearray.find(sub, start=0, end=None, /)
 
    Return the lowest index in the data where the subsequence *sub* is found,
    such that *sub* is contained in the slice ``s[start:end]``.  Optional
@@ -3269,8 +3269,8 @@ arbitrary binary data.
       Also accept an integer in the range 0 to 255 as the subsequence.
 
 
-.. method:: bytes.index(sub, start=0, stop=None, /)
-            bytearray.index(sub, start=0, stop=None, /)
+.. method:: bytes.index(sub, start=0, end=None, /)
+            bytearray.index(sub, start=0, end=None, /)
 
    Like :meth:`~bytes.find`, but raise :exc:`ValueError` when the
    subsequence is not found.
@@ -3333,8 +3333,8 @@ arbitrary binary data.
       always produces a new object, even if no changes were made.
 
 
-.. method:: bytes.rfind(sub, start=0, stop=None, /)
-            bytearray.rfind(sub, start=0, stop=None, /)
+.. method:: bytes.rfind(sub, start=0, end=None, /)
+            bytearray.rfind(sub, start=0, end=None, /)
 
    Return the highest index in the sequence where the subsequence *sub* is
    found, such that *sub* is contained within ``s[start:end]``.  Optional
@@ -3348,8 +3348,8 @@ arbitrary binary data.
       Also accept an integer in the range 0 to 255 as the subsequence.
 
 
-.. method:: bytes.rindex(sub, start=0, stop=None, /)
-            bytearray.rindex(sub, start=0, stop=None, /)
+.. method:: bytes.rindex(sub, start=0, end=None, /)
+            bytearray.rindex(sub, start=0, end=None, /)
 
    Like :meth:`~bytes.rfind` but raises :exc:`ValueError` when the
    subsequence *sub* is not found.
@@ -3374,8 +3374,8 @@ arbitrary binary data.
    The separator to search for may be any :term:`bytes-like object`.
 
 
-.. method:: bytes.startswith(prefix, start=0, stop=None, /)
-            bytearray.startswith(prefix, start=0, stop=None, /)
+.. method:: bytes.startswith(prefix, start=0, end=None, /)
+            bytearray.startswith(prefix, start=0, end=None, /)
 
    Return ``True`` if the binary data starts with the specified *prefix*,
    otherwise return ``False``.  *prefix* can also be a tuple of prefixes to
@@ -4501,10 +4501,10 @@ copying.
 
       .. versionadded:: 3.14
 
-  .. method:: index(value, start=0, stop=None, /)
+  .. method:: index(value, start=0, end=None, /)
 
       Return the index of the first occurrence of *value* (at or after
-      index *start* and before index *stop*).
+      index *start* and before index *end*).
 
       Raises a :exc:`ValueError` if *value* cannot be found.
 
