Set

A set is a mutable sequence with no duplicates. So we can modify the elements of a set but we can not an element appear more than once. Just like a list, but with no duplicates. A set is delimited by open and close curly brackets, {}.

Structure of a set

# empty list
empty_list = set()  # not {}, this is a `dict`

# set structure
sample_set = {1, 2, 3}

# returns only the unique elements
unique_set = {1, 2, 3, 3, 4}
# {1, 2, 3, 4}

Casting

We may cast any sequence to a set by passing the sequence as an argument to set() . This returns unique elements of the sequence.

# str to set
name = "Gangliona Messian"
set_str = set(name)

print(set_str)
# output-> 
# {'e', 'o', 'i', 'l', 'M', 'g', 'n', ' ', 's', 'a', 'G'}

my_list = [1, 2, 3]
my_set = set(my_list)

print(my_set)
# output-> {1, 2, 3}

Set operations and functions

Assume we have two sets, A and B.
| Operator | Function | description |
| :------- | :------: | ----------: |
| & | intersection | returns elements in both sets |
| \| | union | returns elements in either set |
| - | difference | returns elements in set A that are not in B |
| ^ | symmetric_difference | returns elements that are not in both sets |
| >= | issuperset | returns True if A is a superset of B, else False |
| <= | issubset | returns True if A is a subset set of B, else False |
| | isdisjoint | returns True if both sets have nothing in common |
| | add | adds an element to the set, just like append in list |
| | update | adds a sequence to the set, just like extend in list |
| | discard | removes an element from the list |
| | remove | just like discard but returns an error when the element doesn't exist |

Examples

# Let our two sets be
set_a = {1, 2, 3, 6}
set_b = {3, 4, 5, 6}

# intersection -> {3, 6}
fintersec_ab = set_a.intersection(set_b)
ointersec_ab = set_a & set_b

print('intesection: ', fintersec_ab == ointersec_ab)

# union -> {1, 2, 3, 4, 5, 6}
funion_ab = set_a.union(set_b)
ounion_ab = set_a | set_b

print('union: ', funion_ab == ounion_ab)

# difference
fdiff_ab = set_a.difference(set_b)  # output-> {1, 2}
odiff_ab = set_a - set_b  # output-> {1, 2}

fdiff_ba = set_b.difference(set_a)  # output-> {4, 5}
odiff_ba = set_b - set_a  # output-> {4, 5}

# symmetric difference
symm_diff = set_a.symmetric_difference(set_b)
print(symm_diff)  # output-> {1, 2, 4, 5}

# upperset and subset
is_a_super_set = set_a.issuperset(set_b) == (set_a >= set_b)
print(is_a_super_set)  # False

is_a_subset_set = set_a.issubset(set_b) == (set_a <= set_b)
print(is_a_subset_set)  # False

# isdisjoint
set_a.isdisjoint(set_b)  # output-> False

# add
set_a.add(8)
print(set_a)  #output-> {1, 2, 3, 6, 8}

# update
update_ab = set_a.update(set_b)  # output-> {1, 2, 3, 4, 5, 6, 8}

# discard
set_a.discard(1)  # output-> {2, 3, 4, 5, 6, 8}
set_a.discard(10)  # output-> {2, 3, 4, 5, 6, 8}

# remove
set_a.remove(2)  # output-> {3, 4, 5, 6, 8}
set_a.remove(2)  # error-> KeyError

Practicals

Implement a custom version of

- Intersection
- Union
- difference
- symmetric_difference
- delete like discard or remove ( ignore the KeyError thing)
- update
- isset - it checks if a sequence has no duplicate ( remember `count` )

make use of all that we've learnt.

Summary

A set is just more like a list but with no duplicates
Sample set, my_set = {1,3,4}
cast a sequence to a set, set(sequence)

Python3 Programming - Exercise 16 - Set

Set