gh-133438: Fix the use of the terms "argument" and "parameter" in the documentation

Author: serhiy-storchaka

Doc/c-api/arg.rst

@@ -410,8 +410,8 @@ inside nested parentheses.  They are:
 
 ``$``
    :c:func:`PyArg_ParseTupleAndKeywords` only:
-   Indicates that the remaining arguments in the Python argument list are
-   keyword-only.  Currently, all keyword-only arguments must also be optional
+   Indicates that the remaining arguments in the Python argument list can be
+   supplied only by keyword.  Currently, all such arguments must also be optional
    arguments, so ``|`` must always be specified before ``$`` in the format
    string.
 
@@ -450,7 +450,7 @@ API Functions
 
 .. c:function:: int PyArg_ParseTuple(PyObject *args, const char *format, ...)
 
-   Parse the parameters of a function that takes only positional parameters into
+   Parse the arguments of a function that takes only positional arguments into
    local variables.  Returns true on success; on failure, it returns false and
    raises the appropriate exception.
 
@@ -463,8 +463,8 @@ API Functions
 
 .. c:function:: int PyArg_ParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, char * const *keywords, ...)
 
-   Parse the parameters of a function that takes both positional and keyword
-   parameters into local variables.
+   Parse the arguments of a function that takes both positional and keyword
+   arguments into local variables.
    The *keywords* argument is a ``NULL``-terminated array of keyword parameter
    names specified as null-terminated ASCII or UTF-8 encoded C strings.
    Empty names denote
@@ -506,7 +506,7 @@ API Functions
 
 .. c:function:: int PyArg_Parse(PyObject *args, const char *format, ...)
 
-   Parse the parameter of a function that takes a single positional parameter
+   Parse the argument of a function that takes a single positional parameter
    into a local variable.  Returns true on success; on failure, it returns
    false and raises the appropriate exception.
 

Doc/c-api/code.rst

@@ -71,7 +71,7 @@ bound into a function.
 
 .. c:function:: PyCodeObject* PyUnstable_Code_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount, int nlocals, int stacksize, int flags, PyObject *code, PyObject *consts, PyObject *names, PyObject *varnames, PyObject *freevars, PyObject *cellvars, PyObject *filename, PyObject *name, PyObject *qualname, int firstlineno, PyObject *linetable, PyObject *exceptiontable)
 
-   Similar to :c:func:`PyUnstable_Code_New`, but with an extra "posonlyargcount" for positional-only arguments.
+   Similar to :c:func:`PyUnstable_Code_New`, but with an extra "posonlyargcount" for positional-only parameters.
    The same caveats that apply to ``PyUnstable_Code_New`` also apply to this function.
 
    .. index:: single: PyCode_NewWithPosOnlyArgs (C function)

Doc/c-api/veryhigh.rst

@@ -267,7 +267,7 @@ the same library that the Python runtime is using.
    evaluation.  This environment consists of a dictionary of global variables,
    a mapping object of local variables, arrays of arguments, keywords and
    defaults, a dictionary of default values for :ref:`keyword-only
-   <keyword-only_parameter>` arguments and a closure tuple of cells.
+   <keyword-only_parameter>` parameters and a closure tuple of cells.
 
 
 .. c:function:: PyObject* PyEval_EvalFrame(PyFrameObject *f)

Doc/deprecations/pending-removal-in-3.19.rst

@@ -18,7 +18,7 @@ Pending removal in Python 3.19
     Support for the ``string`` keyword argument name is now deprecated
     and slated for removal in Python 3.19.
 
-    Before Python 3.13, the ``string`` keyword parameter was not correctly
+    Before Python 3.13, the ``string`` keyword argument was not correctly
     supported depending on the backend implementation of hash functions.
     Prefer passing the initial data as a positional argument for maximum
     backwards compatibility.

Doc/faq/programming.rst

@@ -390,8 +390,8 @@ You could use a global variable containing a dictionary instead of the default
 value; it's a matter of taste.
 
 
-How can I pass optional or keyword parameters from one function to another?
----------------------------------------------------------------------------
+How can I pass optional positional or keyword arguments from one function to another?
+-------------------------------------------------------------------------------------
 
 Collect the arguments using the ``*`` and ``**`` specifiers in the function's
 parameter list; this gives you the positional arguments as a tuple and the

Doc/howto/logging-cookbook.rst

@@ -1634,7 +1634,7 @@ method. Since then, Python has gained two new formatting approaches:
 
 Logging (as of 3.2) provides improved support for these two additional
 formatting styles. The :class:`Formatter` class been enhanced to take an
-additional, optional keyword parameter named ``style``. This defaults to
+additional, optional keyword argument named ``style``. This defaults to
 ``'%'``, but other possible values are ``'{'`` and ``'$'``, which correspond
 to the other two formatting styles. Backwards compatibility is maintained by
 default (as you would expect), but by explicitly specifying a style parameter,
@@ -1675,10 +1675,10 @@ That can still use %-formatting, as shown here::
     >>>
 
 Logging calls (``logger.debug()``, ``logger.info()`` etc.) only take
-positional parameters for the actual logging message itself, with keyword
-parameters used only for determining options for how to handle the actual
-logging call (e.g. the ``exc_info`` keyword parameter to indicate that
-traceback information should be logged, or the ``extra`` keyword parameter
+positional arguments for the actual logging message itself, with keyword
+arguments used only for determining options for how to handle the actual
+logging call (e.g. the ``exc_info`` keyword argument to indicate that
+traceback information should be logged, or the ``extra`` keyword argument
 to indicate additional contextual information to be added to the log). So
 you cannot directly make logging calls using :meth:`str.format` or
 :class:`string.Template` syntax, because internally the logging package
@@ -2732,10 +2732,10 @@ governs the formatting of logging messages for final output to logs, and is
 completely orthogonal to how an individual logging message is constructed.
 
 Logging calls (:meth:`~Logger.debug`, :meth:`~Logger.info` etc.) only take
-positional parameters for the actual logging message itself, with keyword
-parameters used only for determining options for how to handle the logging call
-(e.g. the ``exc_info`` keyword parameter to indicate that traceback information
-should be logged, or the ``extra`` keyword parameter to indicate additional
+positional arguments for the actual logging message itself, with keyword
+arguments used only for determining options for how to handle the logging call
+(e.g. the ``exc_info`` keyword argument to indicate that traceback information
+should be logged, or the ``extra`` keyword argument to indicate additional
 contextual information to be added to the log). So you cannot directly make
 logging calls using :meth:`str.format` or :class:`string.Template` syntax,
 because internally the logging package uses %-formatting to merge the format

Doc/library/ast.rst

@@ -1930,21 +1930,22 @@ Function and class definitions
 
 .. class:: arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)
 
-   The arguments for a function.
+   The parameters for a function.
 
    * ``posonlyargs``, ``args`` and ``kwonlyargs`` are lists of :class:`arg` nodes.
    * ``vararg`` and ``kwarg`` are single :class:`arg` nodes, referring to the
      ``*args, **kwargs`` parameters.
-   * ``kw_defaults`` is a list of default values for keyword-only arguments. If
+   * ``kw_defaults`` is a list of default values for keyword-only parameters. If
      one is ``None``, the corresponding argument is required.
-   * ``defaults`` is a list of default values for arguments that can be passed
-     positionally. If there are fewer defaults, they correspond to the last n
-     arguments.
+   * ``defaults`` is a list of default values for positional-only and
+     keyword-or-positional parameter.
+     If there are fewer defaults, they correspond to the last n
+     parameters.
 
 
 .. class:: arg(arg, annotation, type_comment)
 
-   A single argument in a list. ``arg`` is a raw string of the argument
+   A single parameter in a list. ``arg`` is a raw string of the parameter
    name; ``annotation`` is its annotation, such as a :class:`Name` node.
 
    .. attribute:: type_comment

Doc/library/asyncio-eventloop.rst

@@ -232,7 +232,7 @@ Scheduling callbacks
    Callbacks are called in the order in which they are registered.
    Each callback will be called exactly once.
 
-   The optional keyword-only *context* argument specifies a
+   The optional keyword argument *context* specifies a
    custom :class:`contextvars.Context` for the *callback* to run in.
    Callbacks use the current context when no *context* is provided.
 
@@ -296,11 +296,11 @@ clocks to track time.
    scheduled for exactly the same time, the order in which they
    are called is undefined.
 
-   The optional positional *args* will be passed to the callback when
+   The optional positional arguments *args* will be passed to the callback when
    it is called. If you want the callback to be called with keyword
    arguments use :func:`functools.partial`.
 
-   An optional keyword-only *context* argument allows specifying a
+   An optional keyword argument *context* allows specifying a
    custom :class:`contextvars.Context` for the *callback* to run in.
    The current context is used when no *context* is provided.
 
@@ -377,11 +377,11 @@ Creating Futures and Tasks
    If the *name* argument is provided and not ``None``, it is set as
    the name of the task using :meth:`Task.set_name`.
 
-   An optional keyword-only *context* argument allows specifying a
+   An optional keyword argument *context* allows specifying a
    custom :class:`contextvars.Context` for the *coro* to run in.
    The current context copy is created when no *context* is provided.
 
-   An optional keyword-only *eager_start* argument allows specifying
+   An optional keyword argument *eager_start* allows specifying
    if the task should execute eagerly during the call to create_task,
    or be scheduled later. If *eager_start* is not passed the mode set
    by :meth:`loop.set_task_factory` will be used.

Doc/library/asyncio-future.rst

@@ -165,7 +165,7 @@ Future Object
       If the Future is already *done* when this method is called,
       the callback is scheduled with :meth:`loop.call_soon`.
 
-      An optional keyword-only *context* argument allows specifying a
+      An optional keyword argument *context* allows specifying a
       custom :class:`contextvars.Context` for the *callback* to run in.
       The current context is used when no *context* is provided.
 

Doc/library/asyncio-graph.rst

@@ -32,10 +32,10 @@ and debuggers.
    If not passed, the current running task will be used.
 
    If the function is called on *the current task*, the optional
-   keyword-only *depth* argument can be used to skip the specified
+   keyword argument *depth* can be used to skip the specified
    number of frames from top of the stack.
 
-   If the optional keyword-only *limit* argument is provided, each call stack
+   If the optional keyword argument *limit* is provided, each call stack
    in the resulting graph is truncated to include at most ``abs(limit)``
    entries. If *limit* is positive, the entries left are the closest to
    the invocation point. If *limit* is negative, the topmost entries are
@@ -91,7 +91,7 @@ and debuggers.
    current task, the function returns ``None``.
 
    If the function is called on *the current task*, the optional
-   keyword-only *depth* argument can be used to skip the specified
+   keyword argument *depth* can be used to skip the specified
    number of frames from top of the stack.
 
    Returns a ``FutureCallGraph`` data class object: