bpo-38237: Make pow's arguments have more descriptive names and be keyword passable (GH-16302)
Edit: `math.pow` changes removed on Mark's request.
https://bugs.python.org/issue38237
Automerge-Triggered-By: @rhettinger
diff --git a/Doc/faq/programming.rst b/Doc/faq/programming.rst
index 2ff7236..9d45765 100644
--- a/Doc/faq/programming.rst
+++ b/Doc/faq/programming.rst
@@ -779,26 +779,23 @@
it are positional-only. Positional-only parameters are the ones without an
externally-usable name. Upon calling a function that accepts positional-only
parameters, arguments are mapped to parameters based solely on their position.
-For example, :func:`pow` is a function that accepts positional-only parameters.
-Its documentation looks like this::
+For example, :func:`divmod` is a function that accepts positional-only
+parameters. Its documentation looks like this::
- >>> help(pow)
- Help on built-in function pow in module builtins:
+ >>> help(divmod)
+ Help on built-in function divmod in module builtins:
- pow(x, y, z=None, /)
- Equivalent to x**y (with two arguments) or x**y % z (with three arguments)
+ divmod(x, y, /)
+ Return the tuple (x//y, x%y). Invariant: div*y + mod == x.
- Some types, such as ints, are able to use a more efficient algorithm when
- invoked using the three argument form.
+The slash at the end of the parameter list means that both parameters are
+positional-only. Thus, calling :func:`divmod` with keyword arguments would lead
+to an error::
-The slash at the end of the parameter list means that all three parameters are
-positional-only. Thus, calling :func:`pow` with keyword arguments would lead to
-an error::
-
- >>> pow(x=3, y=4)
+ >>> divmod(x=3, y=4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
- TypeError: pow() takes no keyword arguments
+ TypeError: divmod() takes no keyword arguments
Numbers and strings
diff --git a/Doc/library/functions.rst b/Doc/library/functions.rst
index ea2777f..4d3b2f5 100644
--- a/Doc/library/functions.rst
+++ b/Doc/library/functions.rst
@@ -1274,11 +1274,12 @@
returns ``8364``. This is the inverse of :func:`chr`.
-.. function:: pow(x, y[, z])
+.. function:: pow(base, exp[, mod])
- Return *x* to the power *y*; if *z* is present, return *x* to the power *y*,
- modulo *z* (computed more efficiently than ``pow(x, y) % z``). The two-argument
- form ``pow(x, y)`` is equivalent to using the power operator: ``x**y``.
+ Return *base* to the power *exp*; if *mod* is present, return *base* to the
+ power *exp*, modulo *mod* (computed more efficiently than
+ ``pow(base, exp) % mod``). The two-argument form ``pow(base, exp)`` is
+ equivalent to using the power operator: ``base**exp``.
The arguments must have numeric types. With mixed operand types, the
coercion rules for binary arithmetic operators apply. For :class:`int`
@@ -1287,14 +1288,15 @@
converted to float and a float result is delivered. For example, ``10**2``
returns ``100``, but ``10**-2`` returns ``0.01``.
- For :class:`int` operands *x* and *y*, if *z* is present, *z* must also be
- of integer type and *z* must be nonzero. If *z* is present and *y* is
- negative, *x* must be relatively prime to *z*. In that case, ``pow(inv_x,
- -y, z)`` is returned, where *inv_x* is an inverse to *x* modulo *z*.
+ For :class:`int` operands *base* and *exp*, if *mod* is present, *mod* must
+ also be of integer type and *mod* must be nonzero. If *mod* is present and
+ *exp* is negative, *base* must be relatively prime to *mod*. In that case,
+ ``pow(inv_base, -exp, mod)`` is returned, where *inv_base* is an inverse to
+ *base* modulo *mod*.
Here's an example of computing an inverse for ``38`` modulo ``97``::
- >>> pow(38, -1, 97)
+ >>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True
@@ -1304,6 +1306,10 @@
the second argument to be negative, permitting computation of modular
inverses.
+ .. versionchanged:: 3.9
+ Allow keyword arguments. Formerly, only positional arguments were
+ supported.
+
.. function:: print(*objects, sep=' ', end='\\n', file=sys.stdout, flush=False)