🎨 Rearrange glossaries

veit · veit · commit 5843de484d0c · 2025-01-09T17:27:52.000+01:00
diff --git a/docs/appendix/glossary.rst b/docs/appendix/glossary.rst
diff --git a/docs/appendix/index.rst b/docs/appendix/index.rst
@@ -4,4 +4,5 @@ Appendix
 .. toctree::
    :titlesonly:
 
+   glossary
    checks
diff --git a/docs/control-flow/exceptions.rst b/docs/control-flow/exceptions.rst
@@ -1,10 +1,10 @@
 Exceptions
 ==========
 
-This section deals with exceptions, which are language functions that
-specifically handle unusual circumstances during the execution of a programme.
-The most common exception is error handling, but they can also be used
-effectively for many other purposes. Python provides a comprehensive set of
+This section deals with :term:`exceptions <exception>`, which are language
+functions that specifically handle unusual circumstances during the execution of
+a programme. The most common exception is error handling, but they can also be
+used effectively for many other purposes. Python provides a comprehensive set of
 exceptions, and you can define new exceptions for your own purposes.
 
 An exception is an object that is automatically created by Python functions with
@@ -90,14 +90,13 @@ Line 19
    The way Python handles error situations in general differs from some other
    languages, such as Java. These languages check possible errors as far as
    possible before they occur, as handling exceptions after they occur is
-   costly. This is sometimes referred to as the :abbr:`LBYL (Look before you
-   leap)` approach.
+   costly. This is sometimes referred to as the :term:`LBYL` approach.
 
    Python, on the other hand, relies more on exceptions to handle errors after
    they occur. Although this reliance may seem risky, when exceptions are used
    correctly, the code is less cumbersome and easier to read, and errors are
    only handled when they occur. This Pythonic approach to error handling is
-   often described as :abbr:`EAFP (easier to ask forgiveness than permission)`.
+   often described as :term:`EAFP`.
 
 Checks
 ------
@@ -117,5 +116,4 @@ Checks
   the variable ``x`` is greater or less than ``3``?
 
 * Is the check whether an object is a list (:ref:`Check: list <check-list>`)
-  programming in the style of :abbr:`LBYL (look before you leap)` or
-  :abbr:`EAFP (easier to ask forgiveness than permission)`?
+  programming in the style of :term:`LBYL` or :term:`EAFP`?
diff --git a/docs/control-flow/index.rst b/docs/control-flow/index.rst
@@ -1,8 +1,8 @@
 Control flow
 ============
 
-Python has a whole range of structures for controlling code execution and
-programme flow, including common branches and loops:
+Python has a whole range of :term:`control flows <Control flow>` to control code
+execution and programme flow, including common branches and loops:
 
 :doc:`boolean`
     check values and identity and allow links between the two.
diff --git a/docs/functions/params.rst b/docs/functions/params.rst
@@ -1,7 +1,8 @@
 Parameters
 ==========
 
-Python offers flexible mechanisms for passing arguments to functions:
+Python offers flexible mechanisms for passing :term:`arguments <argument>` to
+:term:`functions <function>`:
 
 .. code-block:: pycon
     :linenos:
diff --git a/docs/oop/methods.rst b/docs/oop/methods.rst
@@ -101,6 +101,8 @@ normal function call by applying the following rules:
    ``instance.method(arg1, arg2, …)`` becomes
    ``class.method(instance, arg1, arg2, …)``.
 
+.. _staticmethod:
+
 Static methods
 --------------
 
@@ -128,6 +130,8 @@ Line 14
     >>> circle.Circle.circumferences()
     12.56636
 
+.. _classmethod:
+
 Class methods
 -------------
 
diff --git a/docs/oop/types.rst b/docs/oop/types.rst
@@ -119,13 +119,13 @@ Duck typing
 The use of :class:`python3:type`, :func:`python3:isinstance` and
 :func:`python3:issubclass` makes it fairly easy to correctly determine the
 inheritance hierarchy of an object or class. However, Python also has a feature
-that makes using objects even easier: duck typing – *„If it walks like a duck
-and it quacks like a duck, then it must be a duck“*. This refers to Python’s way
-of determining whether an object is the required type for an operation, focusing
-on the interface of an object. In short, in Python you don’t have to worry about
-type-checking function or method arguments and the like, but instead rely on
-readable and documented code in conjunction with tests to ensure that an object
-„quacks like a duck when needed.“
+that makes using objects even easier: duck typing – *‘If it looks like a duck,
+swims like a duck, and quacks like a duck, then it probably is a duck.’*. This
+refers to Python’s way of determining whether an object is the required type for
+an operation, focusing on the interface of an object. In short, in Python you
+don’t have to worry about type-checking function or method arguments and the
+like, but instead rely on readable and documented code in conjunction with tests
+to ensure that an object ‘quacks like a duck when needed’.
 
 Duck typing can increase the flexibility of well-written code and, in
 combination with advanced object-oriented functions, gives you the ability to
diff --git a/docs/test/glossary.rst b/docs/test/glossary.rst
diff --git a/docs/test/index.rst b/docs/test/index.rst
@@ -5,40 +5,9 @@ Basically, a distinction is made between static and dynamic test procedures.
 
 .. glossary::
 
-   Static test procedures
-    are used to check the source code, but it’s not executed. They are divided
-    into
-
-    * :ref:`reviews <code_reviews>` and
-    * `static program analysis
-      <https://en.wikipedia.org/wiki/Static_program_analysis>`_
-
-      There are several Python packages that can help you with static program
-      analysis, including :doc:`Python4DataScience:productive/qa/flake8`,
-      :doc:`Python4DataScience:productive/qa/pysa` and
-      :doc:`Python4DataScience:productive/qa/wily`.
-
-   Dynamic testing
-    are used to find errors when executing the source code. A distinction is
-    made between whitebox and backbox tests.
-
-    Whitebox tests
-        are developed with knowledge of the source code and the software
-        structure. In Python, various modules are available:
-
-        :doc:`unittest`
-            supports you in automating tests.
-        :doc:`mock`
-            allows you to create and use mock objects.
-        :doc:`../document/doctest`
-            allows you to test tests written in Python docstrings.
-        :doc:`tox`
-            allows you to test in different environments.
-
-    Blackbox tests
-        are developed without knowledge of the source code. In addition to
-        :doc:`unittest`, :doc:`hypothesis` can also be used in Python for such
-        tests.
+.. include:: ../appendix/glossary.rst
+   :start-after: start-test-procedures:
+   :end-before: end-test-procedures:
 
 .. tip::
    `cusy seminar: Efficient testing with Python
@@ -57,4 +26,3 @@ Basically, a distinction is made between static and dynamic test procedures.
    mock
    hypothesis
    tox
-   glossary
diff --git a/docs/test/pytest/functions.rst b/docs/test/pytest/functions.rst
@@ -154,6 +154,8 @@ If we now run the test with Python, we get the following result:
 That doesn’t tell us much. The pytest output gives us much more information
 about why our assumptions failed.
 
+.. _pytest_fail:
+
 Failing with ``pytest.fail()`` and exceptions
 ---------------------------------------------
 
diff --git a/docs/types/dicts.rst b/docs/types/dicts.rst
@@ -21,9 +21,9 @@ Values can be any type of object, including mutable types such as
    >>> dict["2022-02-03"] = -0.268295
 
 If you try to access the value of a key that is not contained in the dictionary,
-a ``KeyError`` exception is thrown. To avoid this error, the dictionary method
-``get`` optionally returns a user-defined value if a key is not contained in a
-dictionary.
+a ``KeyError`` :doc:`/control-flow/exceptions` is thrown. To avoid this error,
+the dictionary method ``get`` optionally returns a user-defined value if a key
+is not contained in a dictionary.
 
 .. code-block:: pycon
 
diff --git a/docs/types/sequences-sets/lists.rst b/docs/types/sequences-sets/lists.rst
@@ -268,7 +268,7 @@ list are to be sorted.
 
 However, the standard key method used by :meth:`python3:list.sort` requires that
 all elements in the list are of comparable type. In a list that contains both
-numbers and strings, an :class:`python3:Exception` is therefore thrown:
+numbers and strings, an :term:`Exception` is therefore thrown:
 
 .. code-block:: pycon
 
diff --git a/docs/types/strings/print.rst b/docs/types/strings/print.rst
@@ -21,6 +21,8 @@ types can easily be converted into strings and formatted, for example:
    ... )
    Pi is 3.141592653589793 and the circumference with a diameter of 28 inches is 87.96459430051421 inches.
 
+.. _f-strings:
+
 F-Strings
 ---------
 
