# Python Set

A Python set is the collection of the unordered items. Each element in the set must be unique, immutable, and the sets remove the duplicate elements. Sets are mutable which means we can modify it after its creation.

Unlike other collections in Python, there is no index attached to the elements of the set, i.e., we cannot directly access any element of the set by the index. However, we can print them all together, or we can get the list of elements by looping through the set.

## Creating a set

The set can be created by enclosing the comma-separated immutable items with the curly braces {}. Python also provides the set() method, which can be used to create the set by the passed sequence.

### Example 1: Using curly braces

Output:

```{'Friday', 'Tuesday', 'Monday', 'Saturday', 'Thursday', 'Sunday', 'Wednesday'}
<class 'set'>
looping through the set elements ...
Friday
Tuesday
Monday
Saturday
Thursday
Sunday
Wednesday
```

### Example 2: Using set() method

Output:

```{'Friday', 'Wednesday', 'Thursday', 'Saturday', 'Monday', 'Tuesday', 'Sunday'}
<class 'set'>
looping through the set elements ...
Friday
Wednesday
Thursday
Saturday
Monday
Tuesday
Sunday
```

It can contain any type of element such as integer, float, tuple etc. But mutable elements (list, dictionary, set) can't be a member of set. Consider the following example.

Output:

```<class 'set'>

Traceback (most recent call last)
<ipython-input-5-9605bb6fbc68> in <module>
4
5 #Creating a set which holds mutable elements
----> 6 set2 = {1,2,3,["Javatpoint",4]}
7 print(type(set2))

TypeError: unhashable type: 'list'
```

In the above code, we have created two sets, the set set1 have immutable elements and set2 have one mutable element as a list. While checking the type of set2, it raised an error, which means set can contain only immutable elements.

Creating an empty set is a bit different because empty curly {} braces are also used to create a dictionary as well. So Python provides the set() method used without an argument to create an empty set.

Output:

```<class 'dict'>
<class 'set'>
```

Let's see what happened if we provide the duplicate element to the set.

Output:

```Return set with unique elements: {1, 2, 4, 5, 8, 9, 10}
```

In the above code, we can see that set5 consisted of multiple duplicate elements when we printed it remove the duplicity from the set.

## Adding items to the set

Python provides the add() method and update() method which can be used to add some particular item to the set. The add() method is used to add a single element whereas the update() method is used to add multiple elements to the set. Consider the following example.

### Example: 1 - Using add() method

Output:

```printing the original set ...
{'February', 'May', 'April', 'March', 'June', 'January'}

Adding other months to the set...

Printing the modified set...
{'February', 'July', 'May', 'April', 'March', 'August', 'June', 'January'}

looping through the set elements ...
February
July
May
April
March
August
June
January
```

To add more than one item in the set, Python provides the update() method. It accepts iterable as an argument.

Consider the following example.

### Example - 2 Using update() function

Output:

```printing the original set ...
{'January', 'February', 'April', 'May', 'June', 'March'}

updating the original set ...
printing the modified set ...
{'January', 'February', 'April', 'August', 'October', 'May', 'June', 'July', 'September', 'March'}
```

## Removing items from the set

Python provides the discard() method and remove() method which can be used to remove the items from the set. The difference between these function, using discard() function if the item does not exist in the set then the set remain unchanged whereas remove() method will through an error.

Consider the following example.

Output:

```printing the original set ...
{'February', 'January', 'March', 'April', 'June', 'May'}

Removing some months from the set...

Printing the modified set...
{'February', 'March', 'April', 'June'}

looping through the set elements ...
February
March
April
June
```

Python provides also the remove() method to remove the item from the set. Consider the following example to remove the items using remove() method.

### Example-2 Using remove() function

Output:

```printing the original set ...
{'February', 'June', 'April', 'May', 'January', 'March'}

Removing some months from the set...

Printing the modified set...
{'February', 'June', 'April', 'March'}
```

We can also use the pop() method to remove the item. Generally, the pop() method will always remove the last item but the set is unordered, we can't determine which element will be popped from set.

Consider the following example to remove the item from the set using pop() method.

Output:

```printing the original set ...
{'June', 'January', 'May', 'April', 'February', 'March'}

Removing some months from the set...

Printing the modified set...
{'May', 'April', 'February', 'March'}
```

In the above code, the last element of the Month set is March but the pop() method removed the June and January because the set is unordered and the pop() method could not determine the last element of the set.

Python provides the clear() method to remove all the items from the set.

Consider the following example.

Output:

```printing the original set ...
{'January', 'May', 'June', 'April', 'March', 'February'}

Removing all the items from the set...

Printing the modified set...
set()
```

## Difference between discard() and remove()

Despite the fact that discard() and remove() method both perform the same task, There is one main difference between discard() and remove().

If the key to be deleted from the set using discard() doesn't exist in the set, the Python will not give the error. The program maintains its control flow.

On the other hand, if the item to be deleted from the set using remove() doesn't exist in the set, the Python will raise an error.

Consider the following example.

### Example-

Output:

```printing the original set ...
{'March', 'January', 'April', 'June', 'February', 'May'}

printing the modified set...
{'March', 'January', 'April', 'June', 'February', 'May'}

Removing items through remove() method...
Traceback (most recent call last):
File "set.py", line 9, in
Months.remove("Jan")
KeyError: 'Jan'
```

## Python Set Operations

Set can be performed mathematical operation such as union, intersection, difference, and symmetric difference. Python provides the facility to carry out these operations with operators or methods. We describe these operations as follows.

### Union of two Sets

To combine two or more sets into one set in Python, use the union() function. All of the distinctive characteristics from each combined set are present in the final set. As parameters, one or more sets may be passed to the union() function. The function returns a copy of the set supplied as the lone parameter if there is just one set. The method returns a new set containing all the different items from all the arguments if more than one set is supplied as an argument.

Consider the following example to calculate the union of two sets.

Example 1: using union | operator

Output:

```{'Friday', 'Sunday', 'Saturday', 'Tuesday', 'Wednesday', 'Monday', 'Thursday'}
```

Python also provides the union() method which can also be used to calculate the union of two sets. Consider the following example.

Example 2: using union() method

Output:

```{'Friday', 'Monday', 'Tuesday', 'Thursday', 'Wednesday', 'Sunday', 'Saturday'}
```

Now, we can also make the union of more than two sets using the union() function, for example:

Program:

Output:

```{1, 2, 3, 4, 5}
```

### The intersection of two sets

To discover what is common between two or more sets in Python, apply the intersection() function. Only the items in all sets being compared are included in the final set. One or more sets can also be used as the intersection() function parameters. The function returns a copy of the set supplied as the lone parameter if there is just one set. The method returns a new set that only contains the elements in all the compared sets if multiple sets are supplied as arguments.

The intersection of two sets can be performed by the and & operator or the intersection() function. The intersection of the two sets is given as the set of the elements that common in both sets.

Consider the following example.

Example 1: Using & operator

Output:

```{'Monday', 'Tuesday'}
```

Example 2: Using intersection() method

Output:

```{'Martin', 'David'}
```

Example 3:

Output:

```{1,2,5}
```

Similarly, as the same as union function, we can perform the intersection of more than two sets at a time,

For Example:

Program

Output:

```{3}
```

## The intersection_update() method

The intersection_update() method removes the items from the original set that are not present in both the sets (all the sets if more than one are specified).

The intersection_update() method is different from the intersection() method since it modifies the original set by removing the unwanted items, on the other hand, the intersection() method returns a new set.

Consider the following example.

Output:

```{'castle'}
```

## Difference between the two sets

The difference of two sets can be calculated by using the subtraction (-) operator or intersection() method. Suppose there are two sets A and B, and the difference is A-B that denotes the resulting set will be obtained that element of A, which is not present in the set B.

Consider the following example.

Example 1 : Using subtraction ( - ) operator

Output:

```{'Thursday', 'Wednesday'}
```

Example 2 : Using difference() method

Output:

```{'Thursday', 'Wednesday'}
```

## Symmetric Difference of two sets

In Python, the symmetric Difference between set1 and set2 is the set of elements present in one set or the other but not in both sets. In other words, the set of elements is in set1 or set2 but not in their intersection.

The Symmetric Difference of two sets can be computed using Python's symmetric_difference() method. This method returns a new set containing all the elements in either but not in both. Consider the following example:

Example - 1: Using ^ operator

Output:

```{3, 4, 5, 6, 8, 9, 10}
```

Example - 2: Using symmetric_difference() method

Output:

```{3, 4, 5, 6, 8, 9, 10}
```

## Set comparisons

In Python, you can compare sets to check if they are equal, if one set is a subset or superset of another, or if two sets have elements in common.

Here are the set comparison operators available in Python:

• ==: checks if two sets have the same elements, regardless of their order.
• !=: checks if two sets are not equal.
• <: checks if the left set is a proper subset of the right set (i.e., all elements in the left set are also in the right set, but the right set has additional elements).
• <=: checks if the left set is a subset of the right set (i.e., all elements in the left set are also in the right set).
• >: checks if the left set is a proper superset of the right set (i.e., all elements in the right set are also in the left set, but the left set has additional elements).
• >=: checks if the left set is a superset of the right set (i.e., all elements in the right set are also in the left).

Consider the following example.

Output:

```True
False
False
```

## FrozenSets

In Python, a frozen set is an immutable version of the built-in set data type. It is similar to a set, but its contents cannot be changed once a frozen set is created.

Frozen set objects are unordered collections of unique elements, just like sets. They can be used the same way as sets, except they cannot be modified. Because they are immutable, frozen set objects can be used as elements of other sets or dictionary keys, while standard sets cannot.

One of the main advantages of using frozen set objects is that they are hashable, meaning they can be used as keys in dictionaries or as elements of other sets. Their contents cannot change, so their hash values remain constant. Standard sets are not hashable because they can be modified, so their hash values can change.

Frozen set objects support many of the assets of the same operation, such as union, intersection, Difference, and symmetric Difference. They also support operations that do not modify the frozen set, such as len(), min(), max(), and in.

Consider the following example to create the frozen set.

Output:

```<class 'frozenset'>

printing the content of frozen set...
1
2
3
4
5
Traceback (most recent call last):
File "set.py", line 6, in <module>
Frozenset.add(6) #gives an error since we can change the content of Frozenset after creation
AttributeError: 'frozenset' object has no attribute 'add'
```

## Frozenset for the dictionary

If we pass the dictionary as the sequence inside the frozenset() method, it will take only the keys from the dictionary and returns a frozenset that contains the key of the dictionary as its elements.

Consider the following example.

Output:

```<class 'dict'>
<class 'frozenset'>
Name
Country
ID
```

### Set Programming Example

Example - 1: Write a program to remove the given number from the set.

Output:

```Enter the number you want to remove:12
After Removing: {1, 2, 3, 4, 5, 6, 24}
```

Example - 2: Write a program to add multiple elements to the set.

Output:

```{1, 2, 4, 'Apple', 'John', 'CS', 'Mango', 'Grapes'}
```

Example - 3: Write a program to find the union between two set.

Output:

```{96, 65, 2, 'Joseph', 1, 'Peter', 59}
```

Example- 4: Write a program to find the intersection between two sets.

Output:

```{56, 23}
```

Example - 5: Write the program to add element to the frozenset.

Output:

```TypeError: 'frozenset' object does not support item assignment
```

Above code raised an error because frozensets are immutable and can't be changed after creation.

Example - 6: Write the program to find the issuperset, issubset and superset.

Output:

```False
False
True
True
```

## Python Built-in set methods

Python contains the following methods to be used with the sets.

SN Method Description
1 add(item) It adds an item to the set. It has no effect if the item is already present in the set.
2 clear() It deletes all the items from the set.
3 copy() It returns a shallow copy of the set.
4 difference_update(....) It modifies this set by removing all the items that are also present in the specified sets.
5 discard(item) It removes the specified item from the set.
6 intersection() It returns a new set that contains only the common elements of both the sets. (all the sets if more than two are specified).
7 intersection_update(....) It removes the items from the original set that are not present in both the sets (all the sets if more than one are specified).
8 Isdisjoint(....) Return True if two sets have a null intersection.
9 Issubset(....) Report whether another set contains this set.
10 Issuperset(....) Report whether this set contains another set.
11 pop() Remove and return an arbitrary set element that is the last element of the set. Raises KeyError if the set is empty.
12 remove(item) Remove an element from a set; it must be a member. If the element is not a member, raise a KeyError.
13 symmetric_difference(....) Remove an element from a set; it must be a member. If the element is not a member, raise a KeyError.
14 symmetric_difference_update(....) Update a set with the symmetric difference of itself and another.
15 union(....) Return the union of sets as a new set.
(i.e. all elements that are in either set.)
16 update() Update a set with the union of itself and others.

Next TopicPython Dictionary