In this article, we’ll talk about the Python set intersection methods, and of course, to help you understand it better, we’ve included some output-filled illustrations and examples.

Set in Python is one of the fundamental data structures that store sequential elements. It is represented by curly brackets and separates every element with a comma. Sets are mutable and unordered, which means that indexing in a set is not accurate.

Also, you can also read other articles on Python that will enhance your knowledge of Python.

## What is Python set intersection?

The **set intersection in Python** can be described as the production of a new set composed of the elements shared by both sets. In simple words, it returns a set that contains elements that are common to all the sets.

Additional information from the Python official documentation, set

returns a new set with elements common to the set and all others.`intersection()`

**Example:**

```
Set1 = {1, 2, 3, 4, 5}
Set2 = {4, 5, 6, 7, 8, 9, 10}
# compute intersection between Set1 and Set2
print(Set1.intersection(Set2))
```

**Illustration of the above example:**

**Output:**

**{4, 5}**

## Syntax of set intersection()

Below is the syntax of the Python set

:`intersection()`

**set1.intersection(set2, set3, set4...)**

## Parameters of set intersection()

Set

accepts an arbitrary number of arguments.`intersection()`

## Return value from set intersection()

Set

returns a new set that contains the common to all the given sets.`intersection()`

There are **two methods** to perform an intersection in a set:

- The
`intersection()`

method - The
`&`

method.

## Python set intersection() method:

Using the set

operator in Python.`intersection()`

**Example 1: Working with two sets intersection()**

The intersection of two sets using string elements.

```
Set1 = {"P", "R", "I", "N", "C", "E"}
Set2 = {"C", "E", "S", "A", "R"}
print(Set1.intersection(Set2))
```

**Illustration of the above example program:**

**Output:**

**{'E', 'C', 'R'}**

**Example 2: Working with three sets intersection()**

The calculation of the intersection of three sets.

```
Set1 = {1, 2, 3, 4, 5, 6}
Set2 = {2, 4, 6, 8, 10, 12}
Set3 = {3, 6, 9, 12, 15, 18}
# intersection between set 1 and set 2
print(Set1.intersection(Set2))
# intersection between set 2 and set 3
print(Set2.intersection(Set3))
# intersection between set 3 and set 1
print(Set3.intersection(Set1))
# intersection of all the sets
print("Intersection of All sets:",Set1.intersection(Set2,Set3))
```

**Illustration of the above example program:**

**Output:**

**Set1 and Set2: {2, 4, 6}
Set2 and Set3: {12, 6}
Set3 and Set1: {3, 6}
Intersection of All sets: {6}**

**Example 3: Working with four sets intersection()**

The calculation of the intersection of four sets.

```
Set1 = {1, 2, 3, 4, 5, 6}
Set2 = {2, 4, 6, 8, 10, 12}
Set3 = {3, 6, 9, 12, 15, 18}
Set4 = {4, 8, 12, 16, 20, 24}
print(Set1.intersection(Set4))
print(Set2.intersection(Set4))
print(Set3.intersection(Set4))
print(Set1.intersection(Set2, Set3, Set4))
```

**Illustration of the above example program:**

**Output:**

**{4}
{8, 4, 12}
{12}
set()**

## Python set intersection using & operator method

You can also find the intersection of sets using

operator.`&`

**Example:**

```
Set1 = {1, 2, 3, 4, 5, 6}
Set2 = {2, 4, 6, 8, 10, 12}
Set3 = {3, 6, 9, 12, 15, 18}
Set4 = {4, 8, 12, 16, 20, 24}
print(Set1 & Set3)
print(Set1 & Set4)
print(Set1 & Set2 & Set3)
print(Set1 & Set2 & Set3 & Set4)
```

**Illustration of the above example program:**

**Output:**

**{3, 6}
{4}
{6}
set()**

## How do you calculate the intersection between two sets in Python?

To calculate the intersection between the two sets in Python, we have to use the

method.`len()`

**Example:**

```
set1 = {1, 2, 3}
set2 = {3, 4, 5}
result = len(set(set1 & set2))
print("The number of common elements in both sets:",result)
```

**Output:**

**The number of common elements in both sets: 1**

## Python set intersection complexity

Tested the time complexity of the set intersection, according to them, The runtime complexity of the

method on a set with `set.intersection()`

**n** elements and a set argument with **m** elements is **O(min(n, m))** because you need to check for the smaller set whether each of its elements is a member of the larger set. Checking membership is **O(1)**, so the runtime complexity is **O(min(n, m)) * O(1) = O(min(n, m))**.

## Summary

After reading this article, we should now have a good understanding of how to use the Python

method and set intersection `intersection()`

operator method. You are now ready to use it in an actual program.`&`

If you found the information in this article useful, please consider sharing it with others who may find it useful as well.