✏️ Fix typos and reST syntax

Author: veit

docs/appendix/checks.rst

@@ -998,7 +998,7 @@ Checks
      >>> print(new_path)
      /Users/veit/python-basics-tutorial-de/example.log2
 
-* What is the significance of adding ``b`` as a parameter to
+* What is the significance of adding ``b`` as a :term:`parameter` to
   :func:`python3:open`?
 
   This opens the file in binary mode, which means that bytes and not characters

docs/appendix/glossary.rst

@@ -675,7 +675,7 @@ Glossary
 
    Dummy
        Object that is passed around but never actually used. Normally dummies
-       are only used to fill parameter lists.
+       are only used to fill :term:`parameter` lists.
 
    ``except``
        Keyword used to intercept an :term:`exception` and handle it carefully.

docs/functions/decorators.rst

@@ -3,9 +3,9 @@ Decorators
 
 Functions can also be passed as arguments to other functions and return the
 results of other functions. For example, it is possible to write a Python
-function that takes another function as a parameter, embeds it in another
-function that does something similar, and then returns the new function. This
-new combination can then be used instead of the original function:
+function that takes another function as a :term:`parameter`, embeds it in
+another function that does something similar, and then returns the new function.
+This new combination can then be used instead of the original function:
 
 .. code-block:: pycon
    :linenos:
@@ -41,8 +41,8 @@ much cleaner and easier to read. Using a decorator simply consists of two parts:
 #. the use of an ``@`` followed by the decorator just before the wrapped
    function is defined.
 
-The decorator function should take a function as a parameter and return a
-function, as follows:
+The decorator function should take a function as a :term:`parameter` and return
+a function, as follows:
 
 .. code-block:: pycon
    :linenos:
@@ -71,9 +71,9 @@ as decorators, such as:
 :func:`functools.cache`
     Simple, lightweight, function cache as of Python ≥ 3.9, sometimes called
     *memoize*. It returns the same as :func:`functools.lru_cache` with the
-    parameter ``maxsize=None``, additionally creating a :doc:`/types/dicts` with
-    the function arguments. Since old values never need to be deleted, this
-    function is then also smaller and faster. Example:
+    :term:`parameter` ``maxsize=None``, additionally creating a
+    :doc:`/types/dicts` with the function arguments. Since old values never
+    need to be deleted, this function is then also smaller and faster. Example:
 
     .. code-block:: pycon
        :linenos:

docs/functions/index.rst

@@ -30,13 +30,14 @@ inserts the code into a function so that you can call it to get the `factorial
 Line 2
     This is an optional documentation string, or ``docstring``. You can get its
     value by calling ``fact.__doc__``. The purpose of docstrings is to describe
-    the behaviour of a function and the parameters it takes, while comments are
-    to document internal information about how the code works. Docstrings are
-    :doc:`/types/strings/index` that immediately follow the first line of a
-    function definition and are usually enclosed in triple quotes to allow for
-    multi-line descriptions. For multi-line documentation strings, it is common
-    to give a summary of the function on the first line, follow this summary
-    with an empty line and end with the rest of the information.
+    the behaviour of a function and the :term:`parameters <Parameter>` it takes,
+    while comments are to document internal information about how the code
+    works. Docstrings are :doc:`/types/strings/index` that immediately follow
+    the first line of a function definition and are usually enclosed in triple
+    quotes to allow for multi-line descriptions. For multi-line documentation
+    strings, it is common to give a summary of the function on the first line,
+    follow this summary with an empty line and end with the rest of the
+    information.
 
     .. seealso::
         * :ref:`napoleon`

docs/functions/params.rst

@@ -47,29 +47,30 @@ Line 11
     Function arguments can be entered either by position or by name (keyword).
     ``z`` and ``y`` are specified by name in our example.
 Line 13
-    Function parameters can be defined with default values that will be used if
-    a function call omits them.
+    Function :term:`parameters <Parameter>` can be defined with default values
+    that will be used if a function call omits them.
 Line 18
-    A special parameter can be defined that combines all additional positional
-    arguments in a function call into one tuple.
+    A special :term:`parameter` can be defined that combines all additional
+    positional arguments in a function call into one tuple.
 Line 25
-    Similarly, a special parameter can be defined that summarises all additional
-    keyword arguments in a function call in a dictionary.
+    Similarly, a special :term:`parameter` can be defined that summarises all
+    additional keyword arguments in a function call in a dictionary.
 
 Options for function parameters
 -------------------------------
 
-Most functions need parameters. Python offers three options for defining
-function parameters.
+Most functions need :term:`parameters <Parameter>`. Python offers three options
+for defining function parameters.
 
 Positional parameters
 ~~~~~~~~~~~~~~~~~~~~~
 
-The simplest way to pass parameters to a function in Python is to pass them at
-the position. On the first line of the function, you specify the variable name
-for each parameter; when the function is called, the parameters used in the
-calling code are assigned to the function’s parameter variables based on their
-order. The following function calculates ``x`` as a power of ``y``:
+The simplest way to pass :term:`parameters <Parameter>` to a function in Python
+is to pass them at the position. On the first line of the function, you specify
+the variable name for each parameter; when the function is called, the
+parameters used in the calling code are assigned to the function’s parameter
+variables based on their order. The following function calculates ``x`` as a
+power of ``y``:
 
 .. code-block:: pycon
 
@@ -83,9 +84,9 @@ order. The following function calculates ``x`` as a power of ``y``:
     >>> power(2, 5)
     32
 
-This method requires that the number of parameters used by the calling code
-exactly matches the number of parameters in the function definition; otherwise,
-a type error exception is thrown:
+This method requires that the number of :term:`parameters <Parameter>` used by
+the calling code exactly matches the number of parameters in the function
+definition; otherwise, a type error exception is thrown:
 
 .. code-block:: pycon
 
@@ -94,15 +95,17 @@ a type error exception is thrown:
       File "<stdin>", line 1, in <module>
     TypeError: power() missing 1 required positional argument: 'y'
 
-Function parameters can have default values, which you can declare by assigning
-a default value in the first line of the function definition, like this:
+Function :term:`parameters <Parameter>` can have default values, which you can
+declare by assigning a default value in the first line of the function
+definition, like this:
 
 .. code-block:: pycon
 
     def function_name(param1, param2=Standardwert2, param3=Standardwert3, ...)
 
-Any number of parameters can be given default values, but parameters with
-default values must be defined as the last in the parameter list.
+Any number of :term:`parameters <Parameter>` can be given default values, but
+parameters with default values must be defined as the last in the parameter
+list.
 
 The following function also calculates ``x`` as a power of ``y``. However, if
 ``y`` is not specified in a function call, the default value ``5`` is used:
@@ -130,7 +133,7 @@ Parameter names
 ~~~~~~~~~~~~~~~
 
 You can also pass arguments to a function by using the name of the corresponding
-function parameter rather than its position. Similar to the previous example,
+function :term:`parameter` rather than its position. Similar to the previous example,
 you can enter the following:
 
 .. code-block:: pycon
@@ -139,12 +142,12 @@ you can enter the following:
     64
 
 Since the arguments for the power are named ``x`` and ``y`` in the last call,
-their order is irrelevant; the arguments are linked to the parameters of the
-same name in the definition of the power, and you get back ``2^6``. This type of
-argument passing is called keyword passing. Keyword passing can be very useful
-in combination with the default arguments of Python functions when you define
-functions with a large number of possible arguments, most of which have common
-default values.
+their order is irrelevant; the arguments are linked to the :term:`parameters
+<Parameter>` of the same name in the definition of the power, and you get back
+``2^6``. This type of argument passing is called keyword passing. Keyword
+passing can be very useful in combination with the default arguments of Python
+functions when you define functions with a large number of possible arguments,
+most of which have common default values.
 
 Variable number of arguments
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -153,14 +156,15 @@ Python functions can also be defined to handle a variable number of arguments.
 This is possible in two ways. One method collects an unknown number of arguments
 in a :doc:`list </types/sequences-sets/lists>`. The other method can collect an
 arbitrary number of arguments passed with a keyword that has no correspondingly
-named parameter in the function parameter list in a :doc:`dict </types/dicts>`.
+named :term:`parameter` in the function parameter list in a :doc:`dict
+</types/dicts>`.
 
 For an indeterminate number of positional arguments, prefixing the function’s
-final parameter name with a ``*`` causes all excess non-keyword arguments in a
-function call, that is, the positional arguments that are not assigned to any
-other parameter, to be collected and assigned as a tuple to the specified
-parameter. This is, for example, a simple way to implement a function that finds
-the mean in a list of numbers:
+final :term:`parameter` name with a ``*`` causes all excess non-keyword
+arguments in a function call, that is, the positional arguments that are not
+assigned to any other parameter, to be collected and assigned as a tuple to the
+specified parameter. This is, for example, a simple way to implement a function
+that finds the mean in a list of numbers:
 
 .. code-block:: pycon
 
@@ -179,13 +183,14 @@ Now you can test the behaviour of the function, for example with:
     >>> mean(3, 5, 2, 4, 6)
     4.0
 
-Any number of keyword arguments can also be processed if the last parameter in
-the parameter list is prefixed with ``**``. Then all arguments passed with a
-keyword are collected in a :doc:`dict </types/dicts>`. The key for each entry in
-the dict is the keyword (parameter name) for the argument. The value of this
-entry is the argument itself. An argument passed by keyword is superfluous in
-this context if the keyword with which it was passed does not match one of the
-parameter names in the function definition, for example:
+Any number of keyword arguments can also be processed if the last
+:term:`parameter` in the parameter list is prefixed with ``**``. Then all
+arguments passed with a keyword are collected in a :doc:`dict </types/dicts>`.
+The key for each entry in the dict is the keyword (parameter name) for the
+argument. The value of this entry is the argument itself. An argument passed by
+keyword is superfluous in this context if the keyword with which it was passed
+does not match one of the parameter names in the function definition, for
+example:
 
 .. code-block:: pycon
 
@@ -203,7 +208,7 @@ parameter names in the function definition, for example:
 
 Trying out this function shows that it can add the arguments passed under the
 keywords ``foo``, ``bar`` and ``baz``, even though ``foo``, ``bar`` and ``baz``
-are not parameter names in the function definition:
+are not :term:`parameter` names in the function definition:
 
 .. code-block:: pycon
 
@@ -223,11 +228,11 @@ keyword arguments with ``**``.
 Mutable objects as arguments
 ----------------------------
 
-Arguments are passed by object reference. The parameter becomes a new reference
-to the object. With :term:`immutable` objects such as
+Arguments are passed by object reference. The :term:`parameter` becomes a new
+reference to the object. With :term:`immutable` objects such as
 :doc:`/types/sequences-sets/tuples`, :doc:`/types/strings/index` and
-:doc:`/types/numbers/index`, what is done with a parameter has no effect
-outside the function. However, if you pass a mutable object, such as a
+:doc:`/types/numbers/index`, what is done with a parameter has no effect outside
+the function. However, if you pass a mutable object, such as a
 :doc:`/types/sequences-sets/lists`, a :doc:`/types/dicts` or a class instance,
 any change to the object changes what the argument refers to outside the
 function. Reassigning the parameter has no effect on the argument.
@@ -245,9 +250,9 @@ function. Reassigning the parameter has no effect on the argument.
     (5, [2, 4, 6, 1])
 
 The variable ``x`` is not changed because it is :term:`immutable`. Instead, the
-function parameter ``n`` is set so that it refers to the new value ``6``.
-However, there is a change in ``y`` because the list it refers to has been
-changed.
+function :term:`parameter` ``n`` is set so that it refers to the new value
+``6``. However, there is a change in ``y`` because the list it refers to has
+been changed.
 
 Checks
 ------

docs/functions/variables.rst

@@ -21,9 +21,9 @@ Here you return to the definition of ``fact`` from the beginning of this
 
 Both the variables ``f`` and ``n`` are local to a particular call to the
 function ``fact``; changes made to them during the execution of the function
-have no effect on variables outside the function. All variables in the parameter
-list of a function and all variables created within a function by an assignment,
-such as ``f = 1``, are local to the function:
+have no effect on variables outside the function. All variables in the
+:term:`parameter` list of a function and all variables created within a function
+by an assignment, such as ``f = 1``, are local to the function:
 
 .. code-block:: pycon
 

docs/libs/batteries.rst

@@ -56,7 +56,7 @@ Modules for data types
 | :py:mod:`pprint`      | prints Python data structures „pretty“.                                       |
 +-----------------------+-------------------------------------------------------------------------------+
 | :py:mod:`typing`      | supports commenting code with hints about the types of objects, especially    |
-|                       | function parameters and return values                                         |
+|                       | function :term:`parameters <Parameter>` and return values                     |
 +-----------------------+-------------------------------------------------------------------------------+
 
 Modules for numbers
@@ -175,7 +175,7 @@ Developing and debugging
 | :py:mod:`profile`,                | Python profiler                                                               |
 | :py:mod:`cProfile`                |                                                                               |
 +-----------------------------------+-------------------------------------------------------------------------------+
-| :py:mod:`sys`                     | System-specific parameters and functions                                      |
+| :py:mod:`sys`                     | System-specific :term:`parameters <Parameter>` and functions                  |
 +-----------------------------------+-------------------------------------------------------------------------------+
 | :py:mod:`gc`                      | Functions of the Python garbage collector                                     |
 +-----------------------------------+-------------------------------------------------------------------------------+

docs/oop/coherent.rst

@@ -15,12 +15,13 @@ Python. I will now illustrate these basics in a coherent example:
 
    Line 7
        The ``__init__`` method requires one instance (``self``) and two
-       parameters.
+       :term:`parameters <Parameter>`.
    Lines 8 and 9
        The two instance variables ``x`` and ``y``, which are accessed via
        ``self``.
    Line 10
-       The ``move`` method requires one instance (``self``) and two parameters.
+       The ``move`` method requires one instance (``self``) and two
+       :term:`parameters <Parameter>`.
    Lines 11 and 12
        Instance variables that are set in the ``move`` method.
 
@@ -36,7 +37,7 @@ Python. I will now illustrate these basics in a coherent example:
        The class ``Square`` inherits from the class ``Form``.
    Line 19
        ``Square``’s ``__init__`` takes one instance (``self``) and three
-       parameters, all with defaults.
+       :term:`parameters <Parameter>`, all with defaults.
    Line 20
        ``Square``’s ``__init__`` uses ``super()`` to call ``Form``’s
        ``__init__``.
@@ -56,13 +57,14 @@ Python. I will now illustrate these basics in a coherent example:
        ``circles`` list.
    Lines 37 and 38
        ``circumferences`` is a class method and takes the class itself
-       (``cls``) as a parameter.
+       (``cls``) as a :term:`parameter`.
    Line 41
-       uses the parameter ``cls`` to access the class variable ``circles``.
+       uses the :term:`parameter` ``cls`` to access the class variable
+       ``circles``.
 
 Now you can create some instances of the class ``Circle`` and analyse them.
-Since the ``__init__`` method of ``Circle`` has default parameters, you can
-create a circle without specifying any parameters:
+Since the ``__init__`` method of ``Circle`` has default :term:`parameters
+<Parameter>`, you can create a circle without specifying any parameters:
 
 .. code-block:: pycon
 
@@ -71,7 +73,8 @@ create a circle without specifying any parameters:
    >>> c1.diameter, c1.x, c1.y
    (1, 0, 0)
 
-If you specify parameters, they are used to set the values of the instance:
+If you specify :term:`parameters <Parameter>`, they are used to set the values
+of the instance:
 
 .. code-block:: pycon
 

docs/oop/inheritance.rst

@@ -102,9 +102,9 @@ another method in the ``Form`` class called ``move`` that moves a shape in the
         ...         self.diameter = diameter
         ...
 
-If you take the parameters ``delta_x`` and ``delta_y`` of the method ``move`` in
-the ``__init__`` methods of ``Circle`` and ``Square``, you can for example
-execute the following interactive session:
+If you take the :term:`parameters <Parameter>` ``delta_x`` and ``delta_y`` of
+the method ``move`` in the ``__init__`` methods of ``Circle`` and ``Square``,
+you can for example execute the following interactive session:
 
 .. code-block:: pycon
 

docs/oop/methods.rst

@@ -59,10 +59,10 @@ to set the edge length after creating a square:
     ``self.length`` and ``length`` are not the same!
 
     * ``self.length`` is the instance variable called ``length``
-    * ``length`` is the local function parameter
+    * ``length`` is the local function :term:`parameter`
 
-    In practice, you would probably refer to the local function parameter as
-    ``lng`` or ``l`` to avoid confusion.
+    In practice, you would probably refer to the local function
+    :term:`parameter` as ``lng`` or ``l`` to avoid confusion.
 
 With this definition of ``Square``, you can create squares with arbitrary edge
 lengths with a call to the ``Square`` class. In the following, a square with
@@ -138,7 +138,7 @@ Class methods
 :func:`Class methods <classmethod>` are similar to static methods in that they
 can be called before an object of the class has been instantiated. However, the
 class to which they belong is implicitly passed to the class methods as the
-first parameter:
+first :term:`parameter`:
 
 .. literalinclude:: circle_cm.py
     :language: python
@@ -149,7 +149,7 @@ first parameter:
 Line 23
     The ``@classmethod`` decorator is used before the ``def`` method.
 Line 24
-    The class parameter is traditionally ``cls``.
+    The class :term:`parameter` is traditionally ``cls``.
 Line 27
     You can use ``cls`` instead of ``self.__class__``.