ultimatepython/data_structures/set.py

"""
Sets are an unordered collection of unique values that can be modified at
runtime. This module shows how sets are created, iterated, accessed,
extended and shortened.
"""


def main():
    # Let's define one `set` for starters
    simple_set = {0, 1, 2}

    # A set is dynamic like a `list` and `tuple`
    simple_set.add(3)
    simple_set.remove(0)
    assert simple_set == {1, 2, 3}

    # Unlike a `list and `tuple`, it is not an ordered sequence as it
    # does not allow duplicates to be added
    for _ in range(5):
        simple_set.add(0)
        simple_set.add(4)
    assert simple_set == {0, 1, 2, 3, 4}

    # Use `pop` return any random element from a set
    random_element = simple_set.pop()
    assert random_element in {0, 1, 2, 3, 4}
    assert random_element not in simple_set

    # Now let's define two new `set` collections
    multiples_two = set()
    multiples_four = set()

    # Fill sensible values into the set using `add`
    for i in range(10):
        multiples_two.add(i * 2)
        multiples_four.add(i * 4)

    # As we can see, both sets have similarities and differences
    assert multiples_two == {0, 2, 4, 6, 8, 10, 12, 14, 16, 18}
    assert multiples_four == {0, 4, 8, 12, 16, 20, 24, 28, 32, 36}

    # We cannot decide in which order the numbers come out - so let's
    # look for fundamental truths instead, such as divisibility against
    # 2 and 4. We do this by checking whether the modulus of 2 and 4
    # yields 0 (i.e. no remainder from performing a division). We can
    # also use `&` to perform set intersection
    multiples_common = multiples_two.intersection(multiples_four)
    multiples_common_shorthand = multiples_two & multiples_four

    for number in multiples_common:
        assert number % 2 == 0 and number % 4 == 0

    for number in multiples_common_shorthand:
        assert number % 2 == 0 and number % 4 == 0

    # We can compute exclusive multiples. We can also use `-` to perform
    # set difference
    multiples_two_exclusive = multiples_two.difference(multiples_four)
    multiples_two_exclusive_shorthand = multiples_two - multiples_four
    multiples_four_exclusive = multiples_four.difference(multiples_two)
    assert len(multiples_two_exclusive) > 0
    assert len(multiples_four_exclusive) > 0
    assert len(multiples_two_exclusive_shorthand) > 0

    # Numbers in this bracket are greater than 2 * 9 and less than 4 * 10
    for number in multiples_four_exclusive:
        assert 18 < number < 40

    # By computing a set union against the two sets, we have all integers
    # in this program. We can also use `|` to perform set union
    multiples_all = multiples_two.union(multiples_four)
    multiples_all_shorthand = multiples_two | multiples_four

    # Check if set A is a subset of set B
    assert multiples_four_exclusive.issubset(multiples_four)
    assert multiples_four.issubset(multiples_all)

    # Check if set A is a subset and superset of itself
    assert multiples_all.issubset(multiples_all)
    assert multiples_all.issuperset(multiples_all)
    assert multiples_all_shorthand.issuperset(multiples_all_shorthand)

    # Check if set A is a superset of set B
    assert multiples_all.issuperset(multiples_two)
    assert multiples_two.issuperset(multiples_two_exclusive)


if __name__ == "__main__":
    main()