If we want to represent a group of unique values as a single entity, then we should use a Set.

A Set is one of Python's built-in collection data types.

It automatically removes duplicate elements and stores only unique values.

A Set has the following characteristics:

• Duplicate elements are not allowed.
• Insertion order is not preserved.
• We can sort the elements.
• Indexing is not supported.
• Slicing is not supported.
• Heterogeneous elements are allowed.
• Set objects are mutable.
• Mathematical operations like Union, Intersection, Difference and Symmetric Difference are supported.

1. Duplicate Elements are Not Allowed

A Set stores only unique values.

If duplicate values are provided, Python automatically removes them.

2. Insertion Order is Not Preserved

A Set does not maintain the order in which elements are inserted.

Therefore, while printing a set, the output order may be different from the insertion order.

3. Heterogeneous Elements are Allowed

A Set can store different types of data together.

4. Set is Mutable

After creating a Set, we can add, remove and update elements.

5. Mathematical Operations are Supported

Python supports mathematical operations such as Union, Intersection, Difference and Symmetric Difference on Set objects.

The above Set contains different types of values:

• Integer
• String
• Float
• Boolean

Hence, heterogeneous elements are allowed in a Set.

A Set is represented using curly braces {}.

Each element is separated by a comma (,).

There are different ways to create a Set in Python.

If the elements are already known, we can create a Set directly using curly braces.

Since insertion order is not preserved, the output order may be different each time the program runs.

We can also create a Set by using the set() function.

The argument can be any iterable object such as a List, Tuple, Range or String.

The duplicate values (10 and 20) are removed automatically.

Only unique values are stored in the Set.

While creating an empty Set, we must use the set() function.

Using empty curly braces creates an empty Dictionary, not a Set.

The expression {} creates an empty Dictionary.

It does not create an empty Set.

Expression	Creates
{}	Empty Dictionary
set()	Empty Set

Topic	Description
Set	Collection of unique values
Duplicate Elements	Not Allowed
Insertion Order	Not Preserved
Heterogeneous Elements	Allowed
Mutable	Yes
Indexing	Not Supported
Slicing	Not Supported
Mathematical Operations	Supported
Representation	Curly Braces {}
Empty Set	Created using set()

• A Set stores only unique values.
• Duplicate elements are removed automatically.
• Insertion order is not preserved.
• Heterogeneous elements are allowed.
• Set objects are mutable.
• Mathematical operations such as Union, Intersection, Difference and Symmetric Difference are supported.
• Sets are represented using curly braces {}.
• The set() function creates a Set from any iterable object.
• {} creates an empty Dictionary.
• To create an empty Set, always use set().

Python provides several built-in methods to modify a Set.

In this part, we will learn the following methods:

• add()
• update()
• copy()
• pop()

The add() method is used to add a single element to a Set.

If the element already exists, Python does not add it again because duplicate values are not allowed.

The value 40 is added to the Set.

Since a Set does not preserve insertion order, the output order may be different.

The value 20 already exists in the Set.

Therefore, no duplicate element is added.

• Adds only one element.
• Duplicate elements are ignored automatically.
• The original Set is modified.

The update() method is used to add multiple elements to a Set.

The arguments passed to update() must be iterable objects.

Examples of iterable objects are:

• List
• Tuple
• Range
• Set
• String

The elements from the List and Range are added to the Set.

Duplicate values are removed automatically.

The display order may vary because Sets are unordered.

add()	update()
Adds one element.	Adds multiple elements.
Accepts only one argument.	Accepts one or more iterable objects.
The argument can be a single element.	Arguments must be iterable objects.

The copy() method returns a copy of the Set.

The copied Set is a new object containing the same elements.

The copy() method creates a new Set object.

The original Set remains unchanged.

The pop() method removes and returns a random element from the Set.

Since Sets do not preserve insertion order, we cannot predict which element will be removed.

The removed element is random.

Different executions may remove different elements because Sets are unordered.

• Removes one random element.
• Returns the removed element.
• The removed element is not fixed.
• The output may vary each time the program runs.

Method	Description
add(x)	Adds one element.
update(x, y...)	Adds elements from one or more iterable objects.
copy()	Returns a copy of the Set.
pop()	Removes and returns a random element.

• add() adds only one element.
• update() adds multiple elements from iterable objects.
• update() accepts only iterable objects.
• add() accepts only one argument.
• copy() creates a cloned copy of the Set.
• pop() removes and returns a random element.
• The order of elements in a Set may vary.
• Duplicate elements are ignored automatically while using add() and update().

In this part, we will learn the following Set methods:

• remove()
• discard()

Both methods are used to remove elements from a Set, but they behave differently when the specified element is not available.

The remove() method removes the specified element from a Set.

If the specified element is not present, Python raises a KeyError.

The element 10 is present in the Set.

Therefore, it is removed successfully.

Since Sets do not preserve insertion order, the output order may vary.

The element 40 is not available in the Set.

Therefore, Python raises a KeyError.

• Removes the specified element.
• Raises KeyError if the element is not present.
• Best when you are sure that the element exists in the Set.

The discard() method also removes the specified element from a Set.

If the element is not present, no exception is raised.

The specified element is removed successfully.

No value is returned by the discard() method.

The element 40 is not available in the Set.

The discard() method does nothing.

No exception is raised.

• Removes the specified element.
• If the element is not present, no error is raised.
• Best when you are not sure whether the element exists.

remove()	discard()
Removes the specified element.	Removes the specified element.
Raises KeyError if the element is not present.	Does not raise any error if the element is not present.
Best when the element definitely exists.	Best when the element may or may not exist.

Feature	remove()	discard()
Removes Element	Yes	Yes
Raises Error	Yes (KeyError)	No
Safe for Unknown Elements	No	Yes
Returns Value	No	No

These methods are commonly used in:

• Student attendance systems.
• Inventory management.
• User permission management.
• Removing duplicate records.
• Data cleaning applications.

• remove() removes the specified element.
• If the element is not present, remove() raises a KeyError.
• discard() also removes the specified element.
• If the element is not present, discard() does nothing.
• Use remove() when the element is guaranteed to exist.
• Use discard() when the element may or may not exist.
• Both methods modify the original Set.
• Neither method returns the removed element.

Method	Description
remove(x)	Removes the specified element. Raises KeyError if not found.
discard(x)	Removes the specified element. No error if not found.

The clear() method removes all elements from the Set.

After calling this method, the Set becomes empty.

The Set object still exists, but it contains no elements.

The clear() method removes every element from the Set.

The Set object is not deleted.

Only its contents are removed.

Even after using clear(), the variable still refers to a Set object.

Its length becomes 0.

• Removes all elements from the Set.
• The Set object is not deleted.
• Returns None.
• The resulting Set becomes empty.

Method	Purpose	Raises Error?
pop()	Removes one random element.	No
remove()	Removes a specified element.	Yes, if the element is not present.
discard()	Removes a specified element.	No
clear()	Removes all elements.	No

Method	Removes	Returns Value
pop()	One random element	Yes
remove()	Specified element	No
discard()	Specified element	No
clear()	All elements	No

Situation	Recommended Method
Remove any one element.	pop()
Remove a known element.	remove()
Remove an element that may or may not exist.	discard()
Remove all elements.	clear()

These methods are commonly used in:

• Removing inactive users.
• Clearing cache data.
• Inventory management systems.
• Attendance management.
• Data cleaning applications.

Method	Description
add(x)	Adds one element.
update(x)	Adds multiple elements.
copy()	Creates a copy of the Set.
pop()	Removes one random element.
remove(x)	Removes the specified element.
discard(x)	Removes the specified element without raising an error.
clear()	Removes all elements.

• clear() removes every element from the Set.
• The Set object still exists after calling clear().
• pop() removes a random element.
• remove() raises KeyError if the element does not exist.
• discard() does not raise an exception if the element does not exist.
• All these methods modify the original Set.
• Only pop() returns the removed element.
• clear() is useful when you want to reuse an empty Set.

Method	Purpose
pop()	Remove one random element.
remove()	Remove a specific element.
discard()	Remove a specific element safely.
clear()	Remove all elements.

One of the biggest advantages of a Set is that it supports mathematical set operations.

These operations are useful for comparing two or more sets and finding common or unique elements.

Python supports the following mathematical operations:

• union()
• intersection()
• difference()
• symmetric_difference()

The union() method returns a new Set containing all unique elements from both Sets.

Duplicate elements are automatically removed.

The original Sets are not modified.

• Returns a new Set.
• Duplicate elements are removed.
• The original Sets remain unchanged.

The intersection() method returns only the common elements available in both Sets.

• Returns only common elements.
• Returns a new Set.
• The original Sets are not modified.

The difference() method returns elements that are present in the first Set but not in the second Set.

• Returns elements present only in the first Set.
• The operation is not symmetric.
• The original Sets remain unchanged.

The symmetric_difference() method returns elements that are present in either Set but not in both.

• Returns elements that are not common.
• Common elements are removed.
• The original Sets remain unchanged.

Membership operators are used to check whether an element exists in a Set.

Python provides two membership operators:

• in
• not in

Method	Operator	Returns
union()	|	All unique elements
intersection()	&	Common elements
difference()	-	Elements only in first Set
symmetric_difference()	^	Non-common elements

Mathematical Set operations are commonly used in:

• Student attendance comparison.
• Database record matching.
• Product recommendation systems.
• Finding common friends in social networks.
• Data analysis and reporting.

• union() returns all unique elements.
• intersection() returns only common elements.
• difference() returns elements present only in the first Set.
• symmetric_difference() returns elements that are not common.
• The operators |, &, - and ^ perform the same operations as their respective methods.
• Membership operators in and not in are used to check the presence of elements.
• All mathematical operations return new Set objects.
• The original Sets remain unchanged.

Operation	Result
Union	All unique elements
Intersection	Common elements
Difference	Elements only in first Set
Symmetric Difference	Elements except common ones
Membership	Checks whether an element exists

Python supports Set Comprehension, which provides a short and simple way to create a Set.

It is similar to List Comprehension, but it creates a Set instead of a List.

Set Comprehension automatically removes duplicate values because a Set stores only unique elements.

• Requires less code.
• Easy to understand.
• Creates Sets quickly.
• Automatically removes duplicate values.
• Supports conditions using if.

Indexing depends on the position of elements.

Since a Set does not preserve insertion order, every element does not have a fixed position.

Therefore, indexing is not supported.

Slicing is based on indexes.

Since indexing is not available for Sets, slicing is also not supported.

Feature	List	Tuple	Set
Order Preserved	Yes	Yes	No
Duplicate Elements	Allowed	Allowed	Not Allowed
Mutable	Yes	No	Yes
Indexing	Supported	Supported	Not Supported
Slicing	Supported	Supported	Not Supported
Representation	[]	()	{}

Topic	Description
Set	Collection of unique values.
Duplicate Values	Automatically removed.
Insertion Order	Not preserved.
Mutable	Yes.
Indexing	Not supported.
Slicing	Not supported.
Mathematical Operations	Union, Intersection, Difference and Symmetric Difference.
Comprehension	Supported.
Representation	Curly braces {}
Best Use	Store unique values.

• Set stores only unique values.
• Duplicate elements are automatically removed.
• Insertion order is not preserved.
• Set objects are mutable.
• Indexing and slicing are not supported.
• Set Comprehension provides a simple way to create Sets.
• Conditions can be used inside Set Comprehension.
• Mathematical operations are supported.
• Membership operators in and not in are supported.
• Sets are best when only unique values are required.

Feature	Set
Duplicates	Not Allowed
Order	Not Preserved
Mutable	Yes
Indexing	No
Slicing	No
Mathematical Operations	Supported
Comprehension	Supported
Best For	Unique Values