# Mathematical Set Operations in Python

### Mathematical Set Operations in Python

Python’s `set` is an unordered collection in Python. It can be used to compute standard math operations, such as intersection, union, difference, and symmetric difference. `Other` collections — like list, tuple, and dictionary — don’t support set operations. `Dict` view objects are set-like, which allows set operations. Refer to my story on Python sets.

This article will explore the mathematical operations supported by set objects in detail.

### Let’s Look at the Mathematical Operations Supported by the Set Object

• `union()`
• `update()`
• `intersection()`
• `intersection_update()`
• `difference()`
• `difference_update()`
• `symmetric_difference()`
• `symmetric_difference_update()`
• `isdisjoint()`
• `issubset()`
• `issuperset()`

Set operations can be done in two ways. By using the method or by using an operator.

#### ‘union()’

Return a new set with elements from the set and the `other`. It’s performed by `union()` or by using the `|` operator

Syntax

`union(*others)`

`set | other | ...`

Example 1: Find the union of two sets — `A` and `B`

It’ll return a new set containing elements from set `A` and set `B`. But it won’t repeat elements. All elements in the set are unique.

```A={1,2,3,4,5}
B={2,4,6,8}
print (A.union(B))#Output:{1, 2, 3, 4, 5, 6, 8}
print (A|B)#Output:{1, 2, 3, 4, 5, 6, 8}```

Example 2: Find the union of more than two sets

```A={1,2,3,4,5}
B={2,4,6,8,10}
C={1,3,5,7,9}
print (A|B|C)#Output:{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
print (A.union(B,C))#Output:{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}```

Difference between the `union()` method and the `|` operator:

• `union()`: It’ll accept any iterable as an argument
• `|` operator: It’ll accept only a set as an argument. Otherwise, it’ll raise a `TypeError`.

Example 3: Giving `iterable` as an argument in the `union()` method

```A={1,2,3,4,5}
#iterable is given as list
print (A.union([2,4,6]))#Output:{1, 2, 3, 4, 5, 6}

#iterable is given as tuple
print (A.union((2,4,6)))#Output:{1, 2, 3, 4, 5, 6}

#iterable is given as range object
print (A.union(range(5,10)))#Output:{1, 2, 3, 4, 5, 6, 7, 8, 9}

#iterable is given as a dictionary
print (A.union({'a':6,'b':7}))#Output:{1, 2, 3, 4, 5, 'b', 'a'}```

Example 4: Giving `iterable` as an argument for the`|` operator

```A={1,2,3,4,5}
B=[1,2,3]
print (A|B)
#Output:TypeError: unsupported operand type(s) for |: 'set' and 'list'```

#### ‘update()’

It updates the set, adding elements from the `other`. But it won’t repeat elements. All elements in the set are unique. It’s performed by using `update() `or by using the `|=` operator. The return type is `None`. It’ll modify the original set itself.

Syntax

`update(*others)`

`set |= other | ...`

Example 1: Calling `update()` between two sets — `A` and `B`

It’ll update set `A` by adding elements found in both sets.

```#update()
A={1,2,3,4,5}
B={4,5,6,7,8}
print (A.update(B)) #Output: None
print (A) #Output: {1, 2, 3, 4, 5, 6, 7, 8}```
```A={1,2,3,4,5}
B={4,5,6,7,8}
A|=B
print (A) #Output: {1, 2, 3, 4, 5, 6, 7, 8}```

Example 2: Calling `update()` between more than two sets

```#update()
A={1,2,3}
B={3,4,5}
C={5,6,7}
print (A.update(B,C)) #Output: None
print (A) #Output: {1, 2, 3, 4, 5, 6, 7}

A={1,2,3}
B={3,4,5}
C={5,6,7}
A|=B|C
print (A) #Output: {1, 2, 3, 4, 5, 6, 7}```

Difference between the `update()` method and the `|=` operator:

• `update()`: It’ll accept any iterable as an argument
• `|=` operator: It’ll accept only a set as an argument. Otherwise, it’ll raise a `TypeError`.

Example 3: Giving `iterable` as an argument in the `update()` method

```A={1,2,3}
#iterable is given as list
print (A.update([2,3,4]))#Output:None
print (A)#Output:{1,2,3,4}

#iterable is given as tuple
A={1,2,3}
A.update((2,3,4))
print (A)#Output:{1,2,3,4}

#iterable is given as range object
A={1,2,3}
A.update(range(2,5))
print (A)#Output:{1,2,3,4}

#iterable is given as a dictionary
A={1,2,3}
A.update({2:'a',3:'b'})
print (A) #Output:{1, 2, 3}```

Example 4: Giving `iterable` as an argument for the `|=` operator

```#iterable is given as tuple
A={1,2,3}
B=(3,4)
A|=B
#Output:TypeError: unsupported operand type(s) for |=: 'set' and 'tuple'```

#### ‘intersection()’

Return a new set with elements common to the set and the `other`. It’s performed by `intersection()` or by using the `&`operator.

Syntax

`intersection(*others)`

`set & other & ...`

Example 1: Find the intersection of two sets — `A` and `B`

It’ll return a new set containing common elements from the set `A` and set `B`.

```A={1,2,3,4,5}
B={2,4,6,8}
#intersection is performed by intersection() method or & operator
print (A.intersection(B))#Output:{2,4}
print (A&B)#Output:{2,4}```

Example 2: Find the intersection of more than two sets

```A={1,2,3,4,5}
B={2,4,6,8,10}
C={2,4}
print (A&B&C)#Output:{2,4}
print (A.intersection(B,C))#Output:{2,4}```

Difference between the `intersection()` method and the `&` operator:

• `intersection()`: It’ll accept any iterable as an argument
• `&` operator: It’ll accept only a set as an argument. Otherwise, it’ll raise a `TypeError`.

Example 3: Giving `iterable` as an argument in the `intersection()` method

```A={1,2,3,4,5}
#iterable is given as list
print (A.intersection([1,4,6]))#Output:{1,4}

#iterable is given as tuple
print (A.intersection((2,4,6)))#Output:{2,4}

#iterable is given as range object
print (A.intersection(range(5,10)))#Output:{5}

#iterable is given as a dictionary
print (A.intersection({1:'a','b':7}))#Output:{1}```

Example 4: Giving `iterable` as an argument for the `&` operator

```A={1,2,3,4,5}
B=[1,2,3]
print (A&B)
#Output:TypeError: unsupported operand type(s) for &: 'set' and 'list'```

#### ’intersection_update()’

It updates the set, keeping only elements found in it and the `other`. It’s performed by using` intersection_update()` or by using the`&=` operator. The return type is `None`. It’ll modify the original set itself.

Syntax

`intersection_update(*others)`

`set &= other & …`

Example 1: Find the `intersection_update()` between two sets — `A` and `B`

It’ll update set `A` by keeping only the elements found in both of the sets.

```#intersection_update()
A={1,2,3,4,5}
B={4,5,6,7,8}
print (A.intersection_update(B)) #Output: None
print (A) #Output: {4,5}```
```A={1,2,3,4,5}
B={4,5,6,7,8}
A&=B
print (A) #Output: {4,5}```

#### ‘difference()’

Returns a new set with elements in the set that aren’t in the `other`. It’s performed by `difference()` or by using the `-`operator.

Syntax

`difference(*others)`

`set - other - ...`

Example 1: Find the difference between two sets — `A` and `B`

It’ll return a new set containing elements from set `A` not in set B.

```A={1,2,3,4,5}
B={2,4,6,8}

print (A.difference(B))#Output:{1,3,5}
print (A-B)#Output:{1,3,5}```

Example 2: Find the difference between more than two sets

```A={1,2,3,4,5}
B={2,4,6,8,10}
C={2,3}
print (A-B-C)#Output:{1,5}
print (A.difference(B,C))#Output:{1,5}```

Difference between the `difference()` method and the `-`operator:

• `difference()`: It’ll accept any iterable as an argument
• `-` operator: It’ll accept only a set as an argument. Otherwise, it’ll raise a `TypeError`.

Example 3: Giving `iterable` as an argument in the `difference()` method

```A={1,2,3,4,5}
#iterable is given as list
print (A.difference([1,2,3]))#Output:{4,5}

#iterable is given as tuple
print (A.difference((1,2,3)))#Output:{4,5}

#iterable is given as range object
print (A.difference(range(1,4)))#Output:{4,5}

#iterable is given as a dictionary
print (A.difference({1:'a',2:'b',3:'c'}))#Output:{4,5}```

Example 4: Giving `iterable` as an argument for the `-` operator

```A={1,2,3,4,5}
B=[1,2,3]
print (A-B)
#Output:TypeError: unsupported operand type(s) for -: 'set' and 'list'```

#### ‘difference_update()’

Removes the element from the set that’s also present in the `other` set. It’s performed by using the `-= `operator or by using the `difference_update() `method. The return type is `None`. It’ll modify the original set itself.

Syntax

`difference_update(*others)`

`set -= other | ...`

Example 1: Find the `difference_update()` between two sets — `A` and `B`

It’ll update set `A` by removing elements that are also present in set `B`.

```A={1,2,3,4,5}
B={2,4,6}
#Return type is None.
print (A.difference_update(B))#Output:None
#It will update the original set
print (A) #Output: {1,3,5}

# difference_update by using -= operator
A-=(B)
print (A) #Output: {1,3,5}```

Example 2: Find the `difference_update` between more than two sets

```#difference_update() will modify the original set.
A={1,2,3}
B={1}
C={2}
#Return type is None.
print (A.difference_update(B,C))#Output:None
#It will update the original set
print (A) #Output: {3}

# difference_update by using -= operator
A={1,2,3}
B={1}
C={2}
A-=B|C
print (A) #Output: {3}```

Difference between the `difference_update()` method and the
` -=` operator:

• `difference_update()`: It’ll accept any iterable as an argument
• `-= operator`: It’ll accept only a set as an argument. Otherwise, it’ll raise a `TypeError`.

Example 3: Giving `iterable` as an argument in the `difference_update()` method

```#iterable is given as list
A={1,2,3}
B=
print (A.difference_update(B))#Output:None
print (A)#Output:{2,3}```

Example 4: Giving `iterable` as an argument for `-=`operator

```A={1,2,3}
B=
A-=B
print (A)
#Output: TypeError: unsupported operand type(s) for -=: 'set' and 'list'```

#### ‘symmetric_difference()’

Return a new set with elements in either the set or `other` but not both. It’s performed by `symmetric_difference()` or by using the `^` operator.

Syntax

`symmetric_difference(other)`

`set ^ other`

Example 1: Find the `symmetric_difference` between two sets — `A` and `B`

It’ll return a new set containing elements from either set `A` and set `B` but not elements found in both sets.

```A={1,2}
B={2,3}

print (A.symmetric_difference(B))#Output:{1,3}
print (A^B)#Output:{1,3}```

Example 2: `symmetric_difference` is only performed between two sets

The `symmetric_difference() method` isn’t supported by multiple sets. If more than two sets are given, it’ll raise a `TypeError`.

```A={1,2}
B={2,3,5}
C={3,4}

print (A.symmetric_difference(B,C))#Output:TypeError: symmetric_difference() takes exactly one argument (2 given)```

But we can find the `symmetric_difference` of multiple sets using `^`.

```A={1,2}
B={2,3,5}
C={3,4}

print (A^B^C)#Output:{1,4,5}```

The difference between the `symmetric_difference` method and the`&` operator:

• `symmetric_difference()`: It’ll accept any iterable as an argument. This method doesn’t allow for multiple sets.
• `^` operator: It’ll accept only a set as an argument. Otherwise, it’ll raise a `TypeError`. By using the `^` operator, you can find the `symmetric_difference` between multiple sets.

Example 3: Giving `iterable` as an argument in the `symmetric_difference` method

```#iterable is given as list
A={1,2,3}
B=
print (A.symmetric_difference(B))#Output:{2,3}

#iterable is given as tuple
A={1,2,3}
B=(1,)
print (A.symmetric_difference(B))#Output:{2,3}

#iterable is given as range object
A={1,2,3}
B=range(2)
print (A.symmetric_difference(B))#Output:{2,3}```

Example 4: Giving `iterable` as an argument for the `^` operator

```A={1,2,3}
B=
A^B
print (A) #Output: TypeError: unsupported operand type(s) for ^: 'set' and 'list'```

#### ‘symmetric_difference_update()’

Updates the set, keeping only elements found in either set but not in both. It’s performed by using `symmetric_difference_update()` or by using the `^=` operator. The return type is `None`. It’ll modify the original set itself.

Syntax

`symmetric_difference_update(other)`

`set ^= other`

Example 1: Find the `symmetric_difference_update()` between two sets — A and B

It will update set `A` by keeping only elements found in either set but not in both.

```#symmetric_difference_update()
A={1,2,3,4,5}
B={4,5,6,7,8}
print (A.symmetric_difference_update(B)) #Output: None
print (A) #Output: {1, 2, 3, 6, 7, 8}

A={1,2,3,4,5}
B={4,5,6,7,8}
A^=B
print (A) #Output: {1, 2, 3, 6, 7, 8}```

#### ‘isdisjoint()’

Returns `True` if the set has no elements in common with the `other`. Sets are disjointed if and only if their intersection is the empty set.

Syntax

`isdisjoint(other)`

Example

```#Set A and Set B containing common elements
A={1,2,3,4,5}
B={4,5,6,7,8}
print (A.isdisjoint(B))#Output:False

#Set A and Set B not containing common elements
A={1,2}
B={3,4}
print (A.isdisjoint(B))#Output:True```

#### ‘issubset()’

Test whether every element in the set is in `other`.

Syntax:

`issubset(other)`

`set <= other`

Example: Check whether set `A` is a subset of `B`

Can be done by the `issubset()`method or by using the `≤` operator.

```A={1,2,3,4,5}
B={4,5,6,7,8}
print (A.issubset(B)) #Output: False
print (A<=B)#Output: False

A={1,2,3}
B={1,2,3,4,5}
print (A.issubset(B)) #Output: True
print (A<=B)#Output: False```

Proper subset

Test whether the set is a proper subset of `other` — that is, `set <= other and set != other`.

Syntax

`set < other`

Example: Check whether set `A` is a proper subset of `B`

If both sets are equal, this means` A.issubsetset(B) `returns `True`. But the proper subset `A<B` will return `False`.

```A={1,2,3,4,5}
B={4,5,6,7,8}
print (A<B)#Output: False

A={1,2,3,4,5}
B={1,2,3,4,5}
print (A<B)#Output: False

A={1,2,3}
B={1,2,3,4,5}
print (A<B)#Output: True```

#### ‘issuperset()’

Test whether every element in `other` is in the set.

Syntax

`issuperset(other)`

`set >= other`

Example: Check whether set `A` is a superset of `B`

Can be done by the`issuperset()` method or by using the `≥`operator.

```A={1,2,3,4,5}
B={4,5,6,7,8}
print (A.issuperset(B)) #Output: False
print (A>=B)#Output:True

A={1,2,3,4,5}
B={1,2,3}
print (A.issuperset(B)) #Output: True
print (A>=B)#Output:True```

Proper superset

Test whether the set is a proper superset of `other`— that is, `set >= other and set != other`.

Syntax

`set > other`

Example: Check whether set `A` is a proper superset of `B`.

If both sets are equal, it means `A.issuperset(B)` returns `True`. But the proper superset `A>B` will return `False`.

```A={1,2,3,4,5}
B={4,5}
print (A>B)#Output: True

A={1,2,3,4,5}
B={1,2,3,4,5}
print (A>B)#Output: False

A={1,2,3}
B={1,2,3,4,5}
print (A>B)#Output: True```

### Note

All update methods are not supported by `frozenset`. The `frozenset` type is immutable and hashable — its contents can’t be altered after it’s created. Since all update methods modify the original set, it’s not supported by `frozenset`.

### Conclusion

Mathematical set operations can be performed in two ways: by using an operator or by using a method.

The difference is if we use methods, they’ll accept `iterable` as an argument. But for operators, arguments should be set only. If not, it’ll raise a `TypeError`. All update methods will update the original set, and it’s not supported in `frozenset`. Other than update methods, all other methods return a new set.

### Resources

One-Time
Monthly
Yearly

#### Make a yearly donation

Choose an amount

\$5.00
\$15.00
\$100.00
\$5.00
\$15.00
\$100.00
\$5.00
\$15.00
\$100.00

Or enter a custom amount

\$