✏️ Minor improvements

* Typos
* Wording
* Reformat pyproject.toml files
* Rearrange checks
* Measure times for cache decorator
* Do not use id for integer comparisons
* Add dict comprehension

Author: veit

docs/appendix/checks.rst

@@ -272,12 +272,12 @@ Checks
 
   .. code-block:: pycon
 
-     >>> sheet = {}
-     >>> sheet[("A", 0)] = 1
-     >>> sheet[("A", 1)] = 2
-     >>> sheet[("B", 0)] = 3
-     >>> sheet[("B", 1)] = 4
-     >>> print(sheet[("A", 1)])
+     >>> tabular = {}
+     >>> tabular[("A", 0)] = 1
+     >>> tabular[("A", 1)] = 2
+     >>> tabular[("B", 0)] = 3
+     >>> tabular[("B", 1)] = 4
+     >>> print(tabular[("A", 1)])
      2
 
 * How can you remove all duplicates from a list without changing the order of the
@@ -501,7 +501,7 @@ Checks
      >>> pos
      [0, 1, 2, 3]
 
-* How would you count the total number of negative numbers in the list ``[-[1,
+* How would you count the total number of negative numbers in the list ``[[-1,
   0, 1], [-1, 1, 3], [-2, 0, 2]]``?
 
   .. code-block:: pycon
@@ -621,15 +621,11 @@ Checks
 
   .. code-block:: pycon
 
-     >> def my_func(*params):
-     ...     for i in reversed(params):
-     ...         print(i)
-     ...
-     >>> my_func(1, 2, 3, 4)
-     4
-     3
-     2
-     1
+     >>> values = input("Values separated by commas: ")
+     Values separated by commas: 1,3,2,4
+     >>> value_list = values.split(",")
+     >>> reverse(value_list)
+     ['4', '3', '2', '1']
 
 :doc:`/functions/variables`
 ---------------------------

docs/control-flow/boolean.rst

@@ -18,19 +18,49 @@ considered ``True``.
        >>> x == y
        True
 
-    However, you should never compare calculated floating point numbers with
-    each other:
+    .. warning::
+       However, you should never directly compare calculated floating point
+       numbers:
 
-    .. code-block:: pycon
+       .. code-block:: pycon
 
-       >>> u = 0.6 * 7
-       >>> v = 0.7 * 6
-       >>> u == v
-       False
-       >>> u
-       4.2
-       >>> v
-       4.199999999999999
+          >>> u = 0.6 * 7
+          >>> v = 0.7 * 6
+          >>> u == v
+          False
+          >>> u
+          4.2
+          >>> v
+          4.199999999999999
+
+       Instead, you can use :func:`math.isclose`:
+
+       .. code-block:: pycon
+
+          >>> import math
+          >>> math.isclose(u, v)
+          True
+
+       Alternatively, you can also use :func:`round`:
+
+       .. code-block:: pycon
+
+          >>> round(u, 2) == round(v, 2)
+          True
+
+    .. warning::
+       Integers smaller than -5 or larger than 256 are recreated each time, but
+       integers in between are pre-instantiated by the interpreter and reused.
+       Therefore, :py:func:`id` should not be used for comparisons of integers:
+
+       .. code-block:: pycon
+
+          >>> x = 256
+          >>> y = 257
+          >>> id(x) == id(256)
+          True
+          >>> id(y) == id(257)
+          False
 
 ``is``, ``is not``, ``in``, ``not in``
     checks the identity:

docs/control-flow/loops.rst

@@ -85,8 +85,8 @@ flow control is continued with ``x`` being set to the next entry in the list.
 After the first matching integer is found, the loop is terminated with the
 ``break`` statement.
 
-Loops with an index
--------------------
+``for`` Loops with an index
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 You can also output the index in a ``for`` loop, for example with
 :py:func:`enumerate()`:
@@ -102,7 +102,7 @@ You can also output the index in a ``for`` loop, for example with
    2 Lists
 
 List Comprehensions
--------------------
+~~~~~~~~~~~~~~~~~~~
 
 A list is usually generated as follows:
 
@@ -153,14 +153,65 @@ appended to the end of the expression:
    >>> squares
    [16, 25, 36, 49]
 
+Dict Comprehensions
+~~~~~~~~~~~~~~~~~~~
+
+:doc:`../types/sequences-sets/lists` can be converted into :doc:`../types/dicts`
+as follows:
+
+.. code-block:: pycon
+
+   >>> toc = {}
+   >>> for index, title in enumerate(data_types):
+   ...     toc[index] = title
+   ...
+   >>> toc
+   {0: 'Data types', 1: 'Numbers', 2: 'Lists'}
+
+Mit Dict Comprehensions vereinfacht sich dies:
+
+.. code-block:: pycon
+
+   >>> toc = {index: value for index, value in enumerate(data_types)}
+   >>> toc
+   {0: 'Data types', 1: 'Numbers', 2: 'Lists'}
+
+Das allgemeine Format für Dict Comprehensions ist:
+
+:samp:`{NEW_DICT} = \{{EXPRESSION}, {MEMBER} in {ITERABLE}\}`
+
+Change a ``Collection``
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Modifying a ``collection`` while iterating over it can be difficult. Therefore,
+a copy of the ``collection`` is often modified instead:
+
+.. code-block:: pycon
+
+   >>> for index, title in data_types.items():
+   ...     if index == 0:
+   ...         del data_types[index]
+   ...
+   Traceback (most recent call last):
+     File "<python-input-2>", line 1, in <module>
+       for index, title in data_types.items():
+                           ~~~~~~~~~~~~~~~~^^
+   RuntimeError: dictionary changed size during iteration
+   >>> for index, title in data_types.copy().items():
+   ...     if index == 0:
+   ...         del data_types[index]
+   ...
+   >>> data_types
+   {1: 'Numbers', 2: 'Lists'}
+
 Checks
 ------
 
 * Removes all negative numbers from the list ``x = [ -2, -1, 0, 1, 2, 3]``.
 
 * Which list comprehension would you use to achieve the same result?
 
-* How would you count the total number of negative numbers in the list ``[-[1,
+* How would you count the total number of negative numbers in the list ``[[-1,
   0, 1], [-1, 1, 3], [-2, 0, 2]]``?
 
 * Creates a generator that only returns odd numbers from 1 to 10.

docs/explore.rst

@@ -4,28 +4,41 @@ Exploring Python
 Whether you use :ref:`idle` or the :ref:`interactive_shell`, there are some
 useful functions to explore Python.
 
+.. code-block:: pycon
+
+   >>> x = 4.2
+
+``type()``
+----------
+
+With :py:func:`type`, you can display the object type, for example:
+
+.. code-block:: pycon
+
+   >>> type(x)
+   <class 'float'>
+
 .. _help:
 
 ``help()``
 ----------
 
-``help()`` has two different modes. When you type ``help()``, you call the help
-system, which you can use to get information about modules, keywords, and other
-topics. When you are in the help system, you will see a prompt with ``help>``.
-You can now enter a module name, for example ``float``, to search the `Python
-documentation <https://docs.python.org/>`_ for that type.
+:py:func:`help` has two different modes. When you type :func:`help`, you call
+the help system, which you can use to get information about modules, keywords,
+and other topics. When you are in the help system, you will see a prompt with
+``help>``. You can now enter a module name, for example ``float``, to search the
+`Python documentation <https://docs.python.org/>`_ for that type.
 
-``help()`` is part of the :doc:`pydoc <python3:library/pydoc>` library, which
+:func:`help` is part of the :doc:`pydoc <python3:library/pydoc>` library, which
 provides access to the documentation built into Python libraries. Since every
 Python installation comes with full documentation, you have all the
 documentation at your fingertips even offline.
 
-Alternatively, you can use ``help()`` more specifically by passing a type or
+Alternatively, you can use :func:`help` more specifically by passing a type or
 variable name as a parameter, for example:
 
 .. code-block:: pycon
 
-    >>> x = 4.2
     >>> help(x)
     Help on float object:
 
@@ -39,14 +52,27 @@ variable name as a parameter, for example:
      |  __abs__(self, /)
      |      abs(self)
     ...
+    |  is_integer(self, /)
+    |      Return True if the float is an integer.
+    ...
 
 For example, you will learn that ``x`` is of type ``float`` and has a function
-:func:`__add__` that you can use with dot notation:
+ :func:`is_integer` that you can use with dot notation:
+
+.. code-block:: pycon
+
+   >>> x.is_integer()
+   False
+
+``id()``
+--------
+
+:py:func:`id` specifies the identification number of an object, for example:
 
 .. code-block:: pycon
 
-   >>> x.__add__(1)
-   5.2
+   >>> id(x)
+   4304262800
 
 ``dir()``
 ---------

docs/functions/decorators.rst

@@ -78,21 +78,25 @@ as decorators, such as:
     .. code-block:: pycon
        :linenos:
 
-       >>> from functools import cache
-       >>> @cache
+       >>> import timeit
+       ... from functools import cache
+       ... @cache
        ... def factorial(n):
        ...     return n * factorial(n - 1) if n else 1
-       ...
-       >>> factorial(8)
-       40320
-       >>> factorial(10)
-       3628800
-
-    Line 6
-        Since there is no previously stored result, nine recursive calls are
-        made.
-    Line 8
-        makes only two new calls, as the other results come from the cache.
+       ... timeit.timeit("factorial(8)", globals=globals())
+       0.02631620899774134
+
+    Line 1
+        imports the :mod:`timeit` module for measuring execution time.
+    Line 2
+        imports :func:`functools.cache`.
+    Line 5
+        The ``@cache`` decorator is used to store intermediate results, which
+        can then be reused. In our case, the execution speed is increased
+        approximately tenfold.
+    Line 10
+        :func:`timeit.timeit` measures the time of a call. Unless otherwise
+        specified, the call is made one million times.
 
 :func:`functools.wraps`
     This decorator makes the wrapper function look like the original function

docs/functions/params.rst

@@ -24,8 +24,8 @@ Python offers flexible mechanisms for passing :term:`arguments <argument>` to
     ...
     >>> func2(5, w=6)
     45
-    >>> def func3(u, v=1, w=1, *tup):
-    ...     print((u, v, w) + tup)
+    >>> def func3(u, v=1, w=1, *args):
+    ...     print((u, v, w) + args)
     ...
     >>> func3(7)
     (7, 1, 1)