📝 Update types section

Author: veit

docs/appendix/checks.rst

@@ -280,6 +280,15 @@ Checks
      >>> print(sheet[("A", 1)])
      2
 
+* How can you remove all duplicates from a list without changing the order of the
+  elements in the list?
+
+  The keys of a :doc:`/types/dicts` can be used for this:
+
+  .. code-block:: pycon
+
+     >>> list(dict.fromkeys(l))
+
 :doc:`/types/strings/index`
 ---------------------------
 

docs/types/dicts.rst

@@ -137,3 +137,6 @@ Checks
 * You can use a :doc:`dictionary </types/dicts>`  and use it like a spreadsheet
   sheet by using :doc:`tuples </types/sequences-sets/tuples>` as key row and
   column values. Write sample code to add and retrieve values.
+
+* How can you remove all duplicates from a list without changing the order of the
+  elements in the list?

docs/types/sequences-sets/lists.rst

@@ -532,6 +532,8 @@ has any effect on the original list:
    >>> sup
    [[0], 1]
 
+.. _check-list:
+
 Checks
 ------
 
@@ -558,7 +560,5 @@ Checks
 * If you have a nested list ``ll``, how can you get a copy ``nll`` of this list
   in which you can change the elements without changing the contents of ``ll``?
 
-.. _check-list:
-
 * Make sure that the ``my_collection`` object is a list before you try to append
   data to it.

docs/types/sequences-sets/sets.rst

@@ -1,93 +1,143 @@
 Sets
 ====
 
-Sets in Python are an unordered collection of objects that are used in
-situations where membership and uniqueness to the set are the most important
-information of the object. The ``in`` operator runs faster with sets than with
-:doc:`lists`:
+Sets in Python are an unordered collection of objects used in situations where
+membership and uniqueness to the set are the most important information of the
+object. The ``in`` operator runs faster with sets than with :doc:`lists`:
 
 .. _set:
 
 ``set``
 -------
 
+Create sets
+~~~~~~~~~~~
+
+You can create sets by applying  :class:`set` to a sequence, for example to a
+:doc:`list <lists>`.
+
 .. code-block:: pycon
-   :linenos:
 
-   >>> x = set([1, 2, 3, 2, 4])
-   >>> x
-   {1, 2, 3, 4}
-   >>> 1 in x
+   >>> sequences = set(["list", "tuple", "tuple"])
+   >>> sequences
+   {'tuple', 'list'}
+
+If a sequence is made into a set, duplicates are removed, but the order is then
+also lost.
+
+Individual elements cannot be selected with slicing either:
+
+.. code-block:: pycon
+
+   >>> sequences[0]
+   Traceback (most recent call last):
+     File "<python-input-27>", line 1, in <module>
+       sequences[0]
+       ~~~~~~~~~^^^
+   TypeError: 'set' object is not subscriptable
+
+Check values
+~~~~~~~~~~~~
+
+The keyword ``in`` is used to check whether an object belongs to a set.
+
+.. code-block:: pycon
+
+   >>> "list" in sequences
    True
-   >>> 5 in x
+   >>> "set" in sequences
    False
-   >>> x.add(0)
-   >>> x
-   {0, 1, 2, 3, 4}
-   >>> x.remove(4)
-   >>> x
-   {0, 1, 2, 3}
-   >>> y = set([3, 4, 5])
-   >>> x | y
-   {0, 1, 2, 3, 4, 5}
-   >>> x & y
-   {3}
-   >>> x ^ y
-   {0, 1, 2, 4, 5}
-   >>> x.update(y)
-   >>> x
-   {0, 1, 2, 3, 4, 5}
-
-Line 1
-    You can create a set by applying ``set`` to a sequence, for example to a
-    :doc:`list <lists>`.
-Line 3
-    When a sequence is made into a set, duplicates are removed.
-Lines 4–7
-    The keyword ``in`` is used to check whether an object belongs to a set.
-Lines 8–13
-    With ``add`` and ``remove`` you can change the elements in set.
-Line 15
-    ``|`` is used to get the union or combination of two sets.
-Line 17
-    ``&`` is used to get the intersection.
-Line 19
-    ``^`` is used to find the symmetrical difference, meaning elements that are
-    contained in one or the other set, but not in both.
+
+Add and delete values
+~~~~~~~~~~~~~~~~~~~~~
+
+You can add and delete values with ``add`` and ``remove``.
+
+.. code-block:: pycon
+
+   >>> quantities = sequences.add("set")
+   >>> quantities
+   {'list', 'tuple', 'set'}
+   >>> quantities.remove("set")
+   >>> quantities
+   {'list', 'tuple'}
+
+The elements are unordered, which means that the values within a sequence can
+shift when new elements are added.
+
+Set formation
+~~~~~~~~~~~~~
+
+Union set
+   .. code-block:: pycon
+
+      x = {4, 2, 3, 2, 1}
+      y = {3, 4, 5}
+      >>> x.union(y)
+      {0, 1, 2, 3, 4, 5}
+
+Intersection
+   .. code-block:: pycon
+
+      >>> x.intersection(y)
+      {3}
+
+Difference or remainder set
+
+   .. code-block:: pycon
+
+      >>> x.difference(y)
+      {0, 1, 2}
 
 .. _frozenset:
 
 ``frozenset``
 -------------
 
-In addition to ``set``, there is also ``frozenset``, which is immutable. This
+In addition to ``set``, there is also ``frozenset``, an immutable data type. This
 means that they can also be members of other sets:
 
 .. code-block:: pycon
    :linenos:
 
-   >>> x = set([4, 2, 3, 2, 1])
-   >>> z = frozenset(x)
-   >>> z
-   frozenset({1, 2, 3, 4})
-   >>> z.add(5)
+   >>> sequences = frozenset(["list", "tuple", "set", "tuple"])
+   >>> sequences
+   frozenset({'list', 'tuple', 'set'})
+   >>> dicts = {"dict"}
+   >>> sequences.add(dicts)
    Traceback (most recent call last):
-     File "<stdin>", line 1, in <module>
+     File "<python-input-18>", line 1, in <module>
+       sequences.add(dicts)
+       ^^^^^^^^^^^^^
    AttributeError: 'frozenset' object has no attribute 'add'
-   >>> x.add(z)
-   >>> x
-   {1, 2, 3, 4, frozenset({1, 2, 3, 4})}
+   >>> dicts.add(sequences)
+   >>> dicts
+   {frozenset({'list', 'tuple', 'set'}), 'dict'}
+
+Performance
+-----------
+
+Sets are very fast when checking whether elements are contained in a set. The set
+arithmetic of sets is also well suited to finding common and unique values of two
+sets. For this purpose, it can be useful to convert :doc:`lists` or :doc:`tuples`
+into sets.
 
 Order
 -----
 
-However, the speed advantage also comes at a price: sets do not keep the
-elements in the correct order, whereas :doc:`lists` and :doc:`tuples` do. If the
-order is important to you, you should use a data structure that remembers the
-order.
+However, the speed advantage also comes at a price: sets do not keep the elements
+in the correct order, whereas :doc:`lists` and :doc:`tuples` do. If the order is
+important to you, you should only convert the elements into a set for certain
+operations, for example to check whether the elements of a list are unique with
+
+.. code-block:: pycon
+
+   >>> sequences = ["list", "tuple", "set", "tuple"]
+   >>> len(sequences) == len(set(sequences))
+   False
 
 Checks
 ------
 
-* How many elements does a set have if it is formed from the following list
-  ``[4, 2, 3, 2, 1]``?
+* How many elements does a set have if it is formed from the following list ``[4,
+  2, 3, 2, 1]``?