View All Products
Compute
Storage
Networking
Databases
Services
Developer Tools
Industries
Pricing
Community
Engage With Us

Getting Started with Python Sets and Python Set Operations

Published by Nathaniel Stickman
Traducciones al Español
Estamos traduciendo nuestros guías y tutoriales al Español. Es posible que usted esté viendo una traducción generada automáticamente. Estamos trabajando con traductores profesionales para verificar las traducciones de nuestro sitio web. Este proyecto es un trabajo en curso.
Create a Linode account to try this guide with a $ credit.
This credit will be applied to any valid services used during your first  days.

Pythons sets are unordered collections modeled on mathematical sets, in which elements are unique. Python sets support the logical operations of mathematical sets, like union, intersection, and difference. This example code declares a new set and adds the elements of a second set to it, showing that the updated set contains unique elements:

1
2
3
4
5

example_set = {1, 3, 5, 7}

example_set.update({1, 2, 3, 4})

print(example_set)
{1, 2, 3, 4, 5, 7}

This guide explains:

What Are Sets in Python?

In Python, a set is an unordered, mutable collection of unique elements. Mathematical set operations like union, intersection, and difference can be performed on them. Two different sets can be compared with the subset, superset, and disjoint relations.

This example set uses the set literal syntax and contains the even integers between 2 and 8:

{2, 4, 6, 8}

Sets can contain elements of different types. This set contains some integers and some strings:

{2, "hello", 4, "world"}

The members of a set must be hashable. Hashable objects are generally immutable. Hashable objects must implement the __eq__() method, so two different hashable objects and can be compared to check if they are equal in value to each other. For example, two string objects can be compared to check if they are the same string.

Note
Technically, a hashable object’s __hash__() function must always return the same value for the lifetime of the object, rather than the object itself being immutable. This blog post describes why, in practice, hashable objects used with sets are also immutable.

Integers and strings are built-in Python types that are hashable and can be stored in a set. Mutable container types like lists, dictionaries, and sets are not hashable, because their contents can change. A Python tuple is hashable if each of its values is hashable.

Create a Python Set

Python provides a few ways to create sets:

  • A Python set can be declared with the set literal syntax. A set literal consists of a comma-separated list of unique, hashable objects wrapped in curly braces.

    1

    example_set = {2, 4, 6, 8}

    An empty set cannot be expressed with the set literal syntax. An empty pair of curly braces {} represents an empty Python dictionary. Use the set() constructor (below) to create an empty set.

  • The set() constructor function accepts a Python list (or any other iterable object) as input and returns a set with unique values from the list. The items in the input list/iterable must be hashable.

    1
2

    example_set = set([2, 4, 6, 8, 8, 6, 4, 2])
print(example_set)
    {8, 2, 4, 6}

    If no argument is passed to the constructor function, an empty set is created:

    1
2

    example_set = set()
print(example_set)
    set()

  • Like the set() constructor function, the set comprehension syntax can be used to construct a set from another iterable. A set comprehension allows you to apply an expression to the elements of the iterable before they are added to the new set. A condition can also be enforced on the members of the iterable before they are included in the new set.

    The general syntax for using a set comprehension is:

    1

    { <element expression> for <element> in <iterable> if <condition> }

    This example creates a set of all the even numbers from a list of even and odd integers:

    1
2

    even_integers_set = { x for x in [1, 2, 3, 4, 5] if x % 2 == 0 }
print(even_integers_set)
    {2, 4}

    This example multiplies the even integers by 2 when adding them to the new set:

    1
2

    double_even_integers_set = { x*2 for x in [1, 2, 3, 4, 5,] if x % 2 == 0 }
print(double_even_integers_set)
    {8, 4}

Python Set Operations

The operations for Python sets differ from those available for lists and arrays. Lists and arrays are ordered collections, while the elements in a set are unordered. As a result, the methods for accessing elements and adding elements are different between sets and lists/arrays. As well, the mathematical operations of Python sets are not available for lists and arrays.

Note

The Linode docs library has guides for learning about Python lists and arrays:

Fetch from a Set

Because Python sets are unordered, elements cannot be accessed based on an index into the set. Instead, elements can be accessed using the pop method. This method returns an arbitrary value from the set while. Note that the returned item is removed from the set.

1
2
3
4
5

example_set = {"a", 2, "c", 4, "b", 6}

popped_element = example_set.pop()
print(popped_element)
print(example_set)
2
{'b', 4, 6, 'c', 'a'}

You can check if a value exists in a set by using Python’s in operator. Expressions with this operator return True if the provided value is found in the set:

1
2
3

example_set = {"a", 2, "c", 4, "b", 6}
if 4 in example_set:
    print("Match found!")
Match found!
Note
Python sets are implemented with a form of hash table, so checking if a value exists within a set is an efficient operation. In comparison, to check if an value exists in a list or array, the list/array must be looped through or sorted.

Like lists and arrays, Python sets can be looped through. Use a for loop to iterate through the elements in a set:

1
2
3

example_set = {"a", 2, "c", 4, "b", 6}
for item in example_set:
    print(item)
2
c
b
4
6
a

As an alternative to using the pop method, a for loop with a break statement can be used to retrieve an arbitrary value from a set. By doing this, the value is not removed from the set (unlike with the pop method, which does remove the value):

1
2
3
4
5
6

example_set = {"a", 2, "c", 4, "b", 6}
for value in example_set:
    break

print(value)
print(example_set)
2
{2, 'c', 'b', 4, 6, 'a'}

Modify a Set

Python sets are mutable, meaning items can be added to and removed from them as needed.

Add an Element to a Set

To add an element to a Python set, use the add method. The add method accepts a single new element to add to the set:

1
2
3

example_set = {"this", "is", "a"}
example_set.add("set")
print(example_set)
{'a', 'this', 'is', 'set'}

If the new element is already in the set, then the add method has no effect:

1
2
3
4

example_set = {"this", "is", "a", "set"}
print(example_set)
example_set.add("set")
print(example_set)
{'a', 'this', 'is', 'set'}
{'a', 'this', 'is', 'set'}

Add Multiple Elements to a Set

To add multiple values to a set at the same time, use the update method. The update method takes one (or more) Python iterables (lists, arrays, sets) as arguments. The update method adds any values that are not already in the set. Only unique values are added to the set.

This example adds elements from a list to a set:

1
2
3
4

example_set = {1, 3, 5, 7}
example_set.update([1, 2, 3, 4])

print(example_set)
{1, 2, 3, 4, 5, 7}

Multiple arguments can be passed to update. This example passes two arguments: a list and another set. The elements from the list and the other set are added to the original set:

1
2
3
4

example_set = {1, 3, 5, 7}
example_set.update([1, 2, 3, 4], {'a', 'b', 'c'})

print(example_set)
{1, 2, 3, 4, 5, 7, 'b', 'a', 'c'}

Individual new elements can also be passed as arguments. This example adds elements from a list and three individual elements to a set:

1
2
3
4

example_set = {1, 3, 5, 7}
example_set.update([1, 2, 3, 4], 'a', 'b', 'c')

print(example_set)
{1, 2, 3, 4, 5, 7, 'b', 'a', 'c'}

Remove an Element from a Set

In the Fetch from a Set section, the pop method was demonstrated, which removes an arbitrary element from a set. Python sets also have two methods for removing specific values:

The remove method accepts an element to be removed from the set:

1
2
3

example_set = {1, 3, 5, 7}
example_set.remove(3)
print(example_set)
{1, 5, 7}

If the value that is passed is not in the set, then a KeyError is thrown:

1
2

example_set = {1, 3, 5, 7}
example_set.remove(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 2

The discard method works like the remove method, but it does not throw an error when the passed value is missing from the set:

1
2
3
4
5

example_set = {1, 3, 5, 7}
example_set.discard(1)
example_set.discard(2) # no KeyError is thrown

print(example_set)
{3, 5, 7}

Combine Sets

One of the benefits of Python sets is their ability to use mathematical set operations like union, intersection, and difference. The next sections cover each of the logical operations available for Python sets. These operations can be implemented using either a method call or an operator, both of which are shown.

The examples that follow use two example sets:

1
2

mammal_set = {"wolves", "giraffes", "anteaters", "armadillos"}
insectivore_set = {"frogs", "lizards", "anteaters", "armadillos"}

mammal_set is a set of four mammals and insectivore_set is a set of four insectivores (animals that eat insects).

Python Set Union

The union of two different sets is a new set that includes all of the contents of the constituent sets.

In the Venn diagram below there are two overlapping circles, corresponding to the mammal_set and insectivore_set sets. The shaded green area represents the union of the mammal_set and insectivore_set sets.

Venn diagram of set union

The Python set union method is called on one set and takes another set as an argument. It returns the new union of those two sets:

1
2

mammals_and_insectivores_set = mammal_set.union(insectivore_set)
print(mammals_and_insectivores_set)
{'lizards', 'anteaters', 'giraffes', 'wolves', 'frogs', 'armadillos'}

Calling the union method on the insectivore_set set instead is equivalent to the previous example:

1
2

mammals_and_insectivores_set = insectivore_set.union(mammal_set)
print(mammals_and_insectivores_set)
{'lizards', 'anteaters', 'giraffes', 'wolves', 'frogs', 'armadillos'}

The union operator | also returns the union of two different sets. This is equivalent to using the union method:

1
2

mammals_and_insectivores_set = mammal_set | insectivore_set
print(mammals_and_insectivores_set)
{'lizards', 'anteaters', 'giraffes', 'wolves', 'frogs', 'armadillos'}

Python Set Intersection

The intersection between two sets includes the elements that are in both sets.

In the Venn diagram below there are two overlapping circles, corresponding to the mammal_set and insectivore_set sets. The shaded green area represents the intersection for the mammal_set and the insectivore_set set:

Venn diagram of set symmetric difference

The Python set intersection method is called on one set and takes another set as an argument. It returns the intersection between the two sets. This code creates a set of mammals that are insectivores, as in the diagram above. It excludes mammals that do not eat insects and non-mammals that do:

1
2

mammals_that_are_insectivores_set = mammal_set.intersection(insectivore_set)
print(mammals_that_are_insectivores_set)
{'anteaters', 'armadillos'}
Note
Changing which set is passed as an argument to intersection does not change the returned value.

The intersection operator & also returns the intersection between two sets. This is equivalent to using the intersection method:

1
2

mammals_that_are_insectivores_set = mammal_set & insectivore_set
print(mammals_that_are_insectivores_set)
{'anteaters', 'armadillos'}

Python Set Difference

The difference between two sets includes the elements from the first set that are not in the second set. The overlap between the two sets is excluded.

In the Venn diagram below there are two overlapping circles, corresponding to the mammal_set and insectivore_set sets. The shaded green area represents the difference between the mammal_set and the insectivore_set set:

Venn diagram of set difference, 1

There is also a second difference between the sets, where the second set’s elements are included instead of the first:

Venn diagram of set difference, 2

The Python set difference method is called on one set and takes another set as an argument. It returns the difference between the two sets, where the argument set is subtracted from the set that the method is called on. This code creates a set of mammals that are not insectivores, as in the diagram above:

1
2

mammals_that_are_not_insectivores_set = mammal_set.difference(insectivore_set)
print(mammals_that_are_not_insectivores_set)
{'wolves', 'giraffes'}

The order that the sets are listed in the code matters, and reversing the order produces a different result. The code below instead calls difference on the insectivore_set and passes mammal_set as the argument. The returned difference is the set of insectivores that are not mammals:

1
2

insectivores_that_are_not_mammals_set = insectivore_set.difference(mammal_set)
print(insectivores_that_are_not_mammals_set)
{'frogs', 'lizards'}

The difference operator - also returns the difference between two sets. This is equivalent to using the difference method:

1
2
3

# Same as mammal_set.difference(insectivore_set)
insectivores_that_are_not_mammals_set = mammal_set - insectivore_set
print(insectivores_that_are_not_mammals_set)
{'wolves', 'giraffes'}

Python Set Symmetric Difference

The symmetric difference between two sets includes the elements from either set that are not in both sets. In other words, the symmetric difference is the union of two sets, minus their intersection. It can also be thought of as the union of the two differences between the sets.

In the Venn diagram below there are two overlapping circles, corresponding to the mammal_set and insectivore_set sets. The shaded green area represents the symmetric difference for the mammal_set and the insectivore_set set:

Venn diagram of set symmetric difference

The Python set symmetric_difference method is called on one set and takes another set as an argument. It returns the symmetric difference between the two sets. This code creates a set of mammals that are not insectivores and insectivores that are not mammals, as in the diagram above:

1
2

symmetric_difference_mammal_insectivores = mammal_set.symmetric_difference(insectivore_set)
print(symmetric_difference_mammal_insectivores)
{'giraffes', 'frogs', 'lizards', 'wolves'}
Note
Changing which set is passed as an argument to symmetric_difference does not change the returned value.

The symmetric difference operator ^ also returns the symmetric difference between two sets. This is equivalent to using the symmetric_difference method:

1
2

symmetric_difference_mammal_insectivores = mammal_set ^ insectivore_set
print(symmetric_difference_mammal_insectivores)
{'giraffes', 'frogs', 'lizards', 'wolves'}

Checking Python Set Relationships

Another way that Python sets resemble mathematical sets is that they support the subset, superset, and disjoint comparative operations. Each of these operations allows you to check on the relationship between two sets.

Python Subset

A set is a subset of another set is a set if all the elements in the first set are also in the second set. The issubset method can be used to verify if a Python set is a subset of another set.

In this example, issubset is called on set_A, and set_B is passed as an argument. The method returns True because set_A is a subset of set_B:

1
2
3
4

set_A = {"a", "b", "c"}
set_B = {"a", "b", "c", "d", "e", "f", "g"}

set_A.issubset(set_B)
True

Python Superset

A set is a superset of another set is a set if the first set contains all the elements in the second set. The issuperset method can be used to verify if a Python set is a superset of another set.

In this example, issuperset is called on set_B, and set_A is passed as an argument. The method returns True because set_B is a superset of set_A:

1
2
3
4

set_A = {1, 2, 3, 4}
set_B = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}

set_B.issuperset(set_A)
True

Python Disjoint Sets

Two sets are disjoint if they share no elements in common. The isdisjoint method can be used to verify if a Python set is disjoint with another set.

In this example, isdisjoint is called on set_A, and set_B is passed as an argument. The method returns True because set_A does not contain any of the elements in set_B, and set_B does not contain any of the elements in set_A:

1
2
3
4

set_A = {"a", "b", "c", "d"}
set_B = {1, 2, 3, 4}

set_A.isdisjoint(set_B)
True

Conclusion

By following and referencing this guide, you can now get started using sets in your applications. Have more questions or want some help getting started? Consider searching for or asking your questions on the Linode Q&A forum.

More Information

You may wish to consult the following resources for additional information on this topic. While these are provided in the hope that they will be useful, please note that we cannot vouch for the accuracy or timeliness of externally hosted materials.

This page was originally published on

python

Your Feedback Is Important

Let us know if this guide was helpful to you.

Join the conversation.
Read other comments or post your own below. Comments must be respectful, constructive, and relevant to the topic of the guide. Do not post external links or advertisements. Before posting, consider if your comment would be better addressed by contacting our Support team or asking on our Community Site.
The Disqus commenting system for Linode Docs requires the acceptance of Functional Cookies, which allow us to analyze site usage so we can measure and improve performance. To view and create comments for this article, please update your Cookie Preferences on this website and refresh this web page. Please note: You must have JavaScript enabled in your browser.