Python provides several built-in set methods for adding, removing, updating, comparing, and combining elements in a set. These methods make it easier to perform common operations without manually implementing the required logic.
Some set methods modify the existing set, while others return a new set without changing the original one. Understanding this difference is important when working with sets in practical Python programs.

Table of Contents

---

What Are Set Methods?

Set methods are built-in methods provided by Python for working with set objects. They can be used to add or remove elements, perform set operations, check relationships between sets, and update an existing set.
Set methods are called using the dot notation.

Syntax:

set_name.method_name(arguments)

For example, the add() method can be used to add an element to a set.

numbers = {10, 20, 30}
numbers.add(40)
print(numbers)

Output:

{10, 20, 30, 40}

The add() method modifies the existing set by adding the specified element.
Note: The order in which elements appear when a set is displayed may vary because sets do not guarantee a particular iteration order.

Categories of Set Methods

Set methods can be grouped according to the type of operation they perform. This makes it easier to understand which method should be used for a particular task.

1. Adding methods: add() and update()
2. Removing methods: remove(), discard(), pop(), and clear()
3. Set operation methods: union(), intersection(), difference(), and symmetric_difference()
4. Relationship methods: issubset(), issuperset(), and isdisjoint()
5. In-place update methods: intersection_update(), difference_update(), and symmetric_difference_update()

add() Method

The add() method adds a single element to an existing set. If the element is already present, the set remains unchanged because sets contain unique elements.

Syntax:

set_name.add(element)

The following example adds a new element to a set.

numbers = {10, 20, 30}
numbers.add(40)
print(numbers)

Output:

{10, 20, 30, 40}

The element 40 is added to the existing set. The add() method changes the original set.

Adding an Existing Element

If an element already exists in a set, calling add() does not create another copy. The set continues to contain only one occurrence of that value.

numbers = {10, 20, 30}
numbers.add(20)
print(numbers)

Output:

{10, 20, 30}

This behavior follows the basic rule that sets contain unique elements.

update() Method

The update() method adds multiple elements to an existing set. It accepts one or more iterables and adds their elements to the set.

Syntax:

set_name.update(iterable)

The following example adds several elements from a list.

numbers = {10, 20}
numbers.update([30, 40, 50])
print(numbers)

Output:

{10, 20, 30, 40, 50}

The original set is modified by adding the elements from the list.

Updating from Multiple Iterables

The update() method can receive multiple iterables. Python adds the elements from each iterable to the existing set.

numbers = {1, 2}
numbers.update([3, 4], (5, 6), {7, 8})
print(numbers)

Output:

{1, 2, 3, 4, 5, 6, 7, 8}

Duplicate values, if any, are automatically ignored because the result remains a set.

remove() Method

The remove() method removes a specified element from a set. If the specified element does not exist, Python raises a KeyError.

Syntax:

set_name.remove(element)

The following example removes an existing element.

numbers = {10, 20, 30, 40}
numbers.remove(30)
print(numbers)

Output:

{10, 20, 40}

The element 30 is removed from the original set.

discard() Method

The discard() method removes a specified element from a set if that element exists. Unlike remove(), it does not raise an error when the element is absent.

Syntax:

set_name.discard(element)

numbers = {10, 20, 30}
numbers.discard(20)
numbers.discard(50)
print(numbers)

Output:

{10, 30}

The first call removes 20. The second call does nothing because 50 is not present.

pop() Method

The pop() method removes and returns an arbitrary element from a set. Because sets do not provide positional access, you cannot specify which element should be removed.

Syntax:

set_name.pop()

The following example removes one element and stores the returned value.

numbers = {10, 20, 30}
removed = numbers.pop()
print(removed)
print(numbers)

Output:

10
{20, 30}

The particular element returned by pop() should not be relied upon because set elements do not have a guaranteed positional order.

clear() Method

The clear() method removes all elements from a set. It modifies the existing set and leaves it empty.

Syntax:

set_name.clear()

numbers = {10, 20, 30}
numbers.clear()
print(numbers)

Output:

set()

The original set still exists, but it no longer contains any elements.

union() Method

The union() method returns a new set containing all unique elements from the sets and other iterables provided to it. It does not modify the original set.

Syntax:

set1.union(set2)

set1 = {1, 2, 3}
set2 = {3, 4, 5}
result = set1.union(set2)
print(result)
print(set1)

Output:

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

The result contains the combined unique elements, while set1 remains unchanged.

intersection() Method

The intersection() method returns a new set containing elements that are present in all specified sets or iterables. It does not modify the original set.

Syntax:

set1.intersection(set2)

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
result = set1.intersection(set2)
print(result)

Output:

{3, 4}

Only the elements common to both sets are returned.

difference() Method

The difference() method returns a new set containing elements that are present in the first set but not in the specified other sets.

Syntax:

set1.difference(set2)

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
result = set1.difference(set2)
print(result)

Output:

{1, 2}

The result contains elements belonging to set1 that are not present in set2.

symmetric_difference() Method

The symmetric_difference() method returns a new set containing elements that belong to either set but not to both. It excludes elements common to both sets.

Syntax:

set1.symmetric_difference(set2)

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
result = set1.symmetric_difference(set2)
print(result)

Output:

{1, 2, 5, 6}

The common elements 3 and 4 are excluded from the result.

issubset() Method

The issubset() method checks whether every element of one set is present in another set. It returns either True or False.

Syntax:

set1.issubset(set2)

set1 = {1, 2}
set2 = {1, 2, 3, 4}
print(set1.issubset(set2))
print(set2.issubset(set1))

Output:

True
False

set1 is a subset of set2 because every element in set1 is also present in set2.

issuperset() Method

The issuperset() method checks whether a set contains every element of another set. It returns True when the calling set contains all elements of the specified set.

Syntax:

set1.issuperset(set2)

set1 = {1, 2, 3, 4}
set2 = {1, 2}
print(set1.issuperset(set2))
print(set2.issuperset(set1))

Output:

True
False

set1 is a superset of set2 because it contains all elements of set2.

isdisjoint() Method

The isdisjoint() method checks whether two sets have no elements in common. It returns True when the sets have no common elements and False when they share at least one element.

Syntax:

set1.isdisjoint(set2)

set1 = {1, 2, 3}
set2 = {4, 5, 6}
set3 = {3, 4, 5}
print(set1.isdisjoint(set2))
print(set1.isdisjoint(set3))

Output:

True
False

The first pair has no common elements, while the second pair shares the element 3.

intersection_update() Method

The intersection_update() method updates the existing set so that it contains only elements common to the specified sets or iterables. Unlike intersection(), it modifies the original set.

Syntax:

set1.intersection_update(set2)

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set1.intersection_update(set2)
print(set1)

Output:

{3, 4}

The original set1 is changed so that only the common elements remain.

difference_update() Method

The difference_update() method removes elements from the existing set that are also present in the specified sets or iterables. It modifies the original set rather than creating a new one.

Syntax:

set1.difference_update(set2)

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set1.difference_update(set2)
print(set1)

Output:

{1, 2}

The elements 3 and 4 are removed from set1 because they are also present in set2.

symmetric_difference_update() Method

The symmetric_difference_update() method updates the existing set with the symmetric difference between the two sets. Common elements are removed, while elements found in only one of the sets are retained.

Syntax:

set1.symmetric_difference_update(set2)

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set1.symmetric_difference_update(set2)
print(set1)

Output:

{1, 2, 5, 6}

The original set1 is updated to contain only the elements that are not common to both sets.

Set Methods vs Set Operators

Python provides both methods and operators for several set operations. They often perform the same fundamental operation, but their syntax and accepted operands can differ.

Operation	Method	Operator
Union	set1.union(set2)	set1 | set2
Intersection	set1.intersection(set2)	set1 & set2
Difference	set1.difference(set2)	set1 - set2
Symmetric difference	set1.symmetric_difference(set2)	set1 ^ set2

The method forms are especially useful when working with other iterable objects because methods such as union() and intersection() can accept appropriate iterables.

remove() vs discard()

Both remove() and discard() are used to remove an element from a set. The important difference is what happens when the requested element does not exist.

Feature	remove()	discard()
Removes element	Yes	Yes
If element exists	Removes it	Removes it
If element does not exist	Raises KeyError	Does nothing

union() vs update()

Although both methods can combine elements from collections, they behave differently with respect to the original set. union() returns a new set, while update() modifies the existing set.

Feature	union()	update()
Purpose	Combines unique elements	Adds elements to an existing set
Modifies original set	No	Yes
Returns	New set	None

intersection() vs intersection_update()

Both methods find common elements, but only one modifies the original set. This distinction is important when the original data needs to be preserved.

Feature	intersection()	intersection_update()
Returns	New set	None
Modifies original set	No	Yes
Result	Common elements	Original set becomes common elements

difference() vs difference_update()

Both methods find the elements present in one set but not another. The difference is that difference() preserves the original set, while difference_update() changes it.

Feature	difference()	difference_update()
Returns	New set	None
Modifies original set	No	Yes
Original set preserved	Yes	No

symmetric_difference() vs symmetric_difference_update()

Both methods perform a symmetric difference operation. The first returns a new set, while the second updates the existing set.

Feature	symmetric_difference()	symmetric_difference_update()
Returns	New set	None
Modifies original set	No	Yes
Common elements	Excluded	Removed from original set

Methods That Modify the Set vs Return a New Set

One of the most important things to understand about set methods is whether a method changes the original set or returns another set. Confusing these behaviors can lead to unexpected results.

Method	Modifies Original Set?	Returns
add()	Yes	None
update()	Yes	None
remove()	Yes	None
discard()	Yes	None
pop()	Yes	Removed element
clear()	Yes	None
union()	No	New set
intersection()	No	New set
difference()	No	New set
symmetric_difference()	No	New set
issubset()	No	Boolean
issuperset()	No	Boolean
isdisjoint()	No	Boolean
intersection_update()	Yes	None
difference_update()	Yes	None
symmetric_difference_update()	Yes	None

Practical Examples of Set Methods

Set methods become easier to understand when they are applied to common programming situations. The following examples demonstrate how different methods can be used together.

1. Managing Course Enrollments

Suppose a program stores students enrolled in a course. The add(), update(), and discard() methods can be used to manage the collection.

students = {"A", "B", "C"}
students.add("D")
students.update(["E", "F"])
students.discard("B")
print(students)

Output:

{'A', 'C', 'D', 'E', 'F'}

The set first receives one student, then multiple students, and finally removes an existing student.

2. Comparing Two Groups

Methods such as intersection(), difference(), and union() can be used together when two groups need to be compared.

group_a = {"A", "B", "C", "D"}
group_b = {"C", "D", "E", "F"}
common = group_a.intersection(group_b)
only_a = group_a.difference(group_b)
all_members = group_a.union(group_b)
print(common)
print(only_a)
print(all_members)

Output:

{'C', 'D'}
{'A', 'B'}
{'A', 'B', 'C', 'D', 'E', 'F'}

These methods provide three different views of the relationship between the two groups.

3. Checking Set Relationships

Relationship methods can determine whether one set contains another set or whether two sets share any elements.

required = {"Python", "SQL"}
skills = {"Python", "SQL", "Java", "C++"}
other_skills = {"HTML", "CSS"}
print(required.issubset(skills))
print(skills.issuperset(required))
print(required.isdisjoint(other_skills))

Output:

True
True
True

The results show that required is a subset of skills, skills is a superset of required, and the two compared groups have no elements in common.

Edge Cases and Exceptions

Some set methods have special behavior when their arguments or target elements do not meet the expected conditions. Understanding these cases helps prevent unexpected errors.

• remove() raises a KeyError when the specified element does not exist.
• discard() does not raise an error when the specified element is absent.
• pop() raises a KeyError when called on an empty set.
• clear() can safely be called on an empty set.
• Methods such as add() and update() modify the existing set.
• Methods such as union() and intersection() return new sets.
• Relationship methods such as issubset() return Boolean values.

Common Mistakes

Set methods are straightforward once their return values and modification behavior are understood. The following mistakes are common when beginning to work with them.

• Expecting remove() to silently ignore a missing element.
• Using remove() when discard() is more appropriate for optional elements.
• Expecting pop() to remove a specific element.
• Assigning the result of add() or update() to a variable expecting a set.
• Confusing union() with update().
• Confusing methods that return a new set with methods that modify the original set.
• Forgetting that intersection_update(), difference_update(), and symmetric_difference_update() modify the original set.

Important Rules for Set Methods

The following rules summarize the most important behavior of Python set methods.

• add() adds one element.
• update() adds elements from one or more iterables.
• remove() raises KeyError when the element is absent.
• discard() does nothing when the element is absent.
• pop() removes and returns an arbitrary element.
• clear() removes all elements.
• union(), intersection(), difference(), and symmetric_difference() return new sets.
• issubset(), issuperset(), and isdisjoint() return Boolean values.
• intersection_update(), difference_update(), and symmetric_difference_update() modify the original set.
• Methods that modify a set generally return None, except methods such as pop() that return a removed element.

Quick Reference Table

The following table summarizes the main set methods, their purposes, and whether they modify the original set.

Method	Purpose	Modifies Set?	Returns
add()	Add one element	Yes	None
update()	Add multiple elements	Yes	None
remove()	Remove a specified element	Yes	None
discard()	Remove an element if present	Yes	None
pop()	Remove an arbitrary element	Yes	Element
clear()	Remove all elements	Yes	None
union()	Combine unique elements	No	New set
intersection()	Find common elements	No	New set
difference()	Find elements only in first set	No	New set
symmetric_difference()	Find elements in either set but not both	No	New set
issubset()	Check subset relationship	No	Boolean
issuperset()	Check superset relationship	No	Boolean
isdisjoint()	Check whether sets have no common elements	No	Boolean
intersection_update()	Keep only common elements	Yes	None
difference_update()	Remove common elements	Yes	None
symmetric_difference_update()	Update with symmetric difference	Yes	None

Conclusion

Python set methods provide convenient ways to add, remove, compare, combine, and update set elements. Understanding the purpose of each method makes it easier to select the appropriate operation for a particular programming task.
A particularly important distinction is whether a method modifies the original set or returns a new set. Methods such as add(), remove(), and update() modify the existing set, while methods such as union(), intersection(), and difference() return new sets.
Once these behaviors are understood, set methods can be used effectively for tasks such as managing unique data, comparing collections, and maintaining relationships between groups.

Frequently Asked Questions (FAQs)

Here are some common questions about Python set methods. These questions focus on the behavior and differences that are most useful when working with set methods.

1. What are set methods in Python?

Set methods are built-in methods used to perform operations on Python sets. They can add, remove, combine, compare, or update set elements.

2. What is the difference between add() and update()?

The add() method adds a single element to a set, while update() adds multiple elements from one or more iterables. Both methods modify the original set.

3. What is the difference between remove() and discard()?

Both methods remove an element from a set. The difference is that remove() raises a KeyError when the element is absent, while discard() does nothing.

4. What does the pop() method do in a set?

The pop() method removes and returns an arbitrary element from a set. You cannot specify which element should be removed.

5. Which set methods return a new set?

Methods such as union(), intersection(), difference(), and symmetric_difference() return new sets. They do not modify the original set.