## Introduction

**Intersection** of sets involves **extracting common elements** from sets, resulting in a new set that contains only those shared values. In Python, **set intersection** can be accomplished with the `intersection()`

instance method, the `intersection()`

class method, and the union operator, `&`

, i.e. the ampersand character. Each of these options provides a slightly different capability and convenience. They work in a similar way to the options provided for the set union, and familiarity with those makes learning about intersection very easy.

## Using the *intersection()* Instance Method

The `intersection()`

instance method of a set object extracts the common elements between the set and one or more iterables, creating a new set that contains only those shared values.

**Example:**

set1 = {1, 2, 3} set2 = {1, 2, 4} lst1= [1, 2, 5] intersection_set = set1.intersection(set2, lst1) print(intersection_set)

**Output:**

{1, 2}

In this example, the `intersection()`

method is used to find the common elements among the sets `set1`

and `set2`

, and the list, `lst1`

, resulting in a new set, `intersection_set`

, containing the values `1`

and `2`

.

## Using the Python Set Intersection Operator *&*

The set intersection operator, `&`

, can be used to find the common elements between two or more sets. Like the `intersection()`

method, it creates a new set that contains only the shared values. However, it can only be used with proper set objects and not any other iterable type. Using `&`

with iterable objects that are not sets results in an error.

**Example:**

set1 = {1, 2, 3} set2 = {1, 2, 4} set3 = {1, 2, 5} intersection_set = set1 & set2 & set3 print(intersection_set)

**Output:**

{1, 2}

In this example, the intersection of three sets, `set1`

, `set2`

, and `set3`

, is generated using the `&` operators between them.

## Using the *intersection()* Class Method

You can also use the `intersection()`

class method to find the intersection of a set and multiple iterable objects.

This method is a class method of the `set`

class, and you call it with a `set.`

prefix.

The difference between the `intersection()`

instance method and `intersection()`

class method is that the instance method is called on a specific set, whereas the class method includes the set as its first parameter. Following the first argument, which must be a set, the rest of the arguments can be objects of any iterable type.

**Example:**

set1 = {1, 2, 3} set2 = {1, 2, 4} lst1 = [1, 2, 5] intersection_set = set.intersection(set1, set2, lst1) print(intersection_set)

**Output:**

{1, 2}

The above example finds common elements of the sets, `set1`

and `set2`

, and the list, `lst1`

using the `intersection()`

class method.

## Set Intersection with Mutable Sets

Similar to set union, set intersection operations do not modify the original set. Instead, they create a new set containing the intersection. If you want to modify the original set variable to contain the intersection result, you should do it explicitly by assigning the result back to it.

**Example:**

my_set = {1, 2, 3} another_set = {3, 4, 5} my_set = my_set.intersection(another_set) print(my_set)

**Output:**

{3}

After this operation, the original set, `my_set`

, contains the resulting intersection, `{3}`

.

## Summary & Reference for Python Set Intersection

Set intersection is a fundamental set operation in Python for extracting common elements from two or more sets and other iterables into a new set.

The `intersection()`

instance method extracts common elements among a set object and other iterable objects, creating a new set.

set1 = {1, 2, 3} set2 = {1, 2, 4} lst1= [1, 2, 5] intersection_set = set1.intersection(set2, lst1) print(intersection_set) # --> {1, 2}

The set intersection operator, `&`

, allows you to find common elements between two or more proper sets. It creates a new set containing only the shared values.

set1 = {1, 2, 3} set2 = {1, 2, 4} set3 = {1, 2, 5} intersection_set = set1 & set2 & set3 # intersection_set --> {1, 2}

The `intersection()`

class method of the `set`

class lets you find common elements among a set object, given as the first argument, and other iterable objects, given as subsequent arguments.

set1 = {1, 2, 3} set2 = {1, 2, 4} lst1 = [1, 2, 5] intersection_set = set.intersection(set1, set2, lst1) # intersection_set --> {1, 2}

Set intersection operations don’t modify the original sets but create new sets. If you want to modify one of the original set variables with the intersection result, you should assign the result back explicitly.

my_set = {1, 2, 3} another_set = {3, 4, 5} my_set = my_set.intersection(another_set) # my_set --> {3}