{"id":344,"date":"2021-05-18T12:30:57","date_gmt":"2021-05-18T11:30:57","guid":{"rendered":"https:\/\/glennrowe.net\/programmingpages\/?p=344"},"modified":"2021-05-31T12:14:33","modified_gmt":"2021-05-31T11:14:33","slug":"sets","status":"publish","type":"post","link":"https:\/\/glennrowe.net\/programmingpages\/2021\/05\/18\/sets\/","title":{"rendered":"Sets"},"content":{"rendered":"

The set<\/code> data type in Python implements most of the operations from mathematical sets. The most common representation of sets in mathematics uses Venn diagrams (overlapping circles) which I’m assuming are familiar.<\/p>\n

In Python, a set<\/code> is a collection data type which is\u00a0mutable<\/em> (can be altered), but whose elements must be\u00a0immutable<\/em> data types, such as primitive numeric data types, strings and tuples. A set cannot contain duplicate values.<\/p>\n

The elements in a set are\u00a0unordered<\/em>, which means they may not appear in the same order every time when a set is used as an iterator, for example, in a for loop. Because of this, it is not possible to access members of sets using numerical indexes or slicing (such as you would use to access members of lists and tuples).<\/p>\n

Creating sets<\/h2>\n

A set can be created by listing its elements in braces (curly brackets):<\/p>\n

mySet = {1, 2, 'wibble', 3.14}<\/pre>\n
As usual in Python, we can mix data types in a set.<\/p>\n
A set may also be created from a preexisting list or tuple by using the set constructor, as in:<\/p>\n
a = [1, 2, 3, 4]\r\nsetA = set(a)\r\nb = 'x', 'y', 'z'\r\nsetB = set(b)<\/pre>\n
If you print out setA<\/code> and setB<\/code>, you may find that the order of the elements is not the same as in the original list or tuple; this is because sets are unordered.<\/p>\n
As mentioned above, the elements of a set must be immutable data types. This means we can create a set of primitive data types like ints, floats, strings and complex numbers. As tuples are immutable, we can also create a set of tuples. However, we cannot create a set of lists, as lists are mutable (their elements can be changed, and they can be extended or contracted by adding or deleting elements).<\/p>\n
As we saw in the last example, however, you\u00a0can<\/em> create a set\u00a0from<\/em> the elements in a list, provided that the list elements are immutable. The list elements are extracted and inserted into the set.<\/p>\n
Adding and deleting set elements<\/h2>\n
You can add an element to a set using the add()<\/code> function, as in setA.add(44)<\/code>. For setA<\/code> as defined above, the new contents of setA<\/code> are now {1, 2, 3, 4, 44}.<\/p>\n
You can add multiple elements to a set using update()<\/code>. The argument to update()<\/code> can be an iterable type such as a list or tuple, but\u00a0cannot<\/em> be a primitive type. Thus setA.update([45, 53, 77])<\/code> (adding a list) and setA.update((45, 53, 77))<\/code> (adding a tuple; note the double parentheses) are allowed, but setA.update(45, 53, 77)<\/code> is not. The argument to update()<\/code> can also be another set, so we can have setA.update({45, 53, 77})<\/code>. This latter option is equivalent to forming the union of setA<\/code> with the set in the update function, and storing the result back in setA<\/code>.<\/p>\n
An element can be removed from a set using either discard()<\/code> or remove()<\/code>, both of which take a single argument which is the element to be discarded or removed. The two methods are equivalent if their argument is present in the set. If the argument is\u00a0not<\/em> present, discard()<\/code> will silently do nothing, while remove()<\/code> will generate an error.<\/p>\n
Set operations<\/h2>\n
The usual mathematical set operations are supported. Set union can be done using either the |<\/code> (logical OR) operator or with the method union()<\/code>, as in setA.union(setB)<\/code>. If we want the union of setA<\/code> and setB<\/code> above, we can write either setC = setA | setB<\/code> or setC = setA.union(setB)<\/code>. Note that if the same element occurs in both setA<\/code> and setB<\/code>, it appears only once in setC<\/code> because sets do not store duplicates. The union operation returns a new set that is the union of its two arguments, so the two original sets are not changed.<\/p>\n
Intersection can be done using either the &<\/code> (logical AND) operator or with the intersection()<\/code> method. Thus we can have either setD = setA & setB<\/code> or setD = setA.intersection(setB)<\/code>.<\/p>\n
The difference between setA<\/code> and setB<\/code> (that is, the set of element in setA<\/code> but not in setB<\/code>) is done using either the – (minus) operator or with the method difference()<\/code>.<\/p>\n
The symmetric difference (elements in setA<\/code> or setB<\/code> but not in both) can be done using the ^ (logical XOR) operator or with the method symmetric_difference()<\/code>.<\/p>\n
There are various methods that return a boolean value. The methods isdisjoint()<\/code>, issubset()<\/code> and issuperset()<\/code> test to see if a set is disjoint (as in setA.isdisjoint(setB)<\/code> has no elements in common), is a subset (all the elements of the first set are also in the second set) or is a superset(all the elements of the second set are also in the first set).<\/p>\n
Exercise<\/h2>\n
Write a program that asks the user to enter some details about several people, including their name, age, salary and gender, where name and gender are strings, age is an int and salary is a decimal<\/a>. Store the details for each person in a namedtuple<\/a>, and add each namedtuple to a set.<\/p>\n
From this master set, construct sets containing each of the following. Use list comprehension<\/a> where appropriate to specify the elements of some of the sets.<\/p>\n