Python Sets – Operations and Examples

Python Sets Operations

If you're new to programming, particularly Python, you'll soon come across the concept of sets. Sets are a fundamental Python data structure that allows you to store unique and unordered elements. In this post, we'll look into Python sets and the many operations you can do on them. So gather your coding supplies and let's begin!

Python Sets Operations,,Project In Python

Table of Contents

    1. Introduction to Python Sets
    2. Creating Sets
    3. Adding and Removing Elements
    4. Set Operations
      • Union
      • Intersection
      • Difference
      • Symmetric Difference
    5. Subset and Superset
    6. Modifying Sets In-Place
    7. Iterating Through Sets
    8. Built-in Methods for Sets
    9. Frozensets
    10. Applications of Sets
    11. Performance Considerations
    12. Comparing Sets and Lists
    13. Sets vs. Dictionaries
    14. Tips for Effective Set Usage

1. Introduction to Python Sets

In Python, a set is an unordered collection of unique elements. This means that a set can't contain duplicate values, making it ideal for tasks like storing unique identifiers or eliminating duplicate data.

2. Creating Sets

Creating a set in Python is a breeze. You can either use curly braces {} or the built-in set() function. For example: Copy Text Button
# Creating an empty set empty_set = set() # Creating a set with elements my_set = {1, 2, 3, 4, 5} # Note that duplicate elements are automatically removed duplicate_set = {1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5} # You can also create a set from a list my_list = [1, 2, 3, 4, 5] set_from_list = set(my_list)

3. Adding and Removing Elements

Adding elements to a set is done using the add() method, while removal is accomplished with remove() or discard(). Unlike remove(), discard() won't raise an error if the element isn't found.

4. Set Operations

1. Union:
The union of two sets contains all the distinct elements from both sets. You can use the union() method or the | operator.

2. Intersection:
The intersection of sets contains the elements that are common to both sets. You can use the intersection() method or the & operator.

3. Difference:
The difference between two sets includes elements that exist in the first set but not in the second. The - operator or the difference() method can be used.

4. Symmetric Difference:
The symmetric difference is the set of elements that are in either of the sets, but not in their intersection. It can be obtained using the symmetric_difference() method or the ^ operator.

5. Subset and Superset

You can check if one set is a subset or superset of another using the issubset() and issuperset() methods, respectively.

1. Subset:
Set A is said to be a subset of Set B if all the elements of Set A are also present in Set B. In other words, set A is contained inside Set B. Example: If set A has {1, 2 ,3} and set B has {1, 2, 3 ,4 ,5}, then A is the subset of B because elements of A are also present in set B. it is denoted as A ⊆ B. Copy Text Button
set_A = {1, 2, 3} set_B = {1, 2, 3, 4, 5} is_subset = set_A.issubset(set_B) print(is_subset) # Output: True

2. Superset
In set theory, set A is considered as the superset of B, if all the elements of set B are the elements of set A. For example, if set A = {1, 2, 3, 4, 5} and set B = {1, 3, 4}, we can say that set A is the superset of is denoted as A ⊇ B. Copy Text Button
set_A = {1, 2, 3, 4, 5} set_B = {1, 3, 4} is_superset = set_A.issuperset(set_B) print(is_superset) # Output: True

6. Modifying Sets In-Place

Python allows you to modify sets in-place using various methods like update(), intersection_update(), and difference_update().

1. update() Method:
The update() method provides the means to incorporate elements from other iterable objects into a set. This operation adjusts the set by introducing new elements, all the while preserving their distinctiveness.

2. intersection_update() Method:
Through the intersection_update() method, a set is modified to retain only those elements that are common between the set itself and another iterable. Elements not shared with the other iterable are removed.

3. difference_update() Method:
The difference_update() method brings about changes to a set by eliminating elements that are shared with another iterable. The end result is a set that exclusively contains elements unique to its original state.

7. Iterating Through Sets

You can iterate through a set, which holds distinct elements, using a loop in a manner similar to how you would with other collection types like lists or arrays. Within each cycle of the loop, the process will navigate through the set's elements sequentially. This enables you to execute specific tasks or computations on each individual element within the set. The distinctiveness of the elements in sets guarantees that each element is accessed only once during the iteration process.

8. Built-in Methods for Sets

Python offers a range of built-in functions for sets, which are collections of distinct elements. These functions allow for easy manipulation and handling of sets. Some commonly used built-in methods for sets include:
    1. add(element): This method appends a specific element to the set, provided it's not already present.
    2. remove(element): Eliminates the specified element from the set. If the element is absent, it raises a KeyError.
    3. discard(element): Removes the indicated element from the set if it exists. Unlike remove(), it won't raise an error if the element is missing.
    4. pop(): Extracts and returns an arbitrary element from the set. As sets are unordered, the removed element isn't deterministic.
    5. clear(): Wipes out all elements from the set, leaving it empty.
    6. copy(): Generates a shallow duplicate of the set. Modifications to the copy don't affect the original set, and vice versa.
    7. update(iterable): Appends elements from an iterable (like a list, tuple, or another set) to the current set.
    8. intersection_update(iterable): Alters the set to include only elements found in both the set and the provided iterable.
    9. difference_update(iterable): Removes elements from the set that are also found in the given iterable.
    10. symmetric_difference_update(iterable): Modifies the set to include elements present in either the set or the iterable, but not in both.
    11. union(iterable): Yields a fresh set containing all elements from both the current set and the iterable.
    12. intersection(iterable): Provides a new set holding only elements present in both the current set and the iterable.
    13. difference(iterable): Creates a new set with elements from the set that aren't in the provided iterable.
    14. symmetric_difference(iterable): Generates a new set containing elements present either in the set or the iterable, but not in both.
    15. issubset(other_set): Verifies whether the current set is a subset of another set.
    16. issuperset(other_set): Verifies whether the current set is a superset of another set.
    17. isdisjoint(other_set): Determines if there are no common elements between the current set and another set.
These functions enable efficient manipulation and diverse operations on sets in Python, simplifying the management of collections with unique elements.

9. Frozensets

A frozenset in Python is an immutable collection of unique elements, similar to a set, but with the key distinction that its elements cannot be changed after creation. This immutability makes frozensets suitable for situations where you need to use a set as a dictionary key or store it within another set, list, or tuple.

Here are some key points to understand about frozensets:

1. Immutability: 
Once a frozenset is created, you cannot modify its contents by adding or removing elements. This property makes frozensets hashable, which is a requirement for using them as dictionary keys or elements of other sets.

2. Uniqueness: 
Like sets, frozensets also enforce the uniqueness of their elements. Duplicate elements are automatically eliminated.

3. Methods: 
Frozensets support several methods for set operations, such as intersection, union, difference, and more. However, these methods return new frozensets rather than modifying the existing one.

4. Creation: 
You can create a frozenset by passing an iterable (like a list, tuple, or another set) to the frozenset() constructor.

10. Applications of Sets

Sets find applications in various domains, including mathematical computations, membership testing, duplicate removal, network programming, database operations, data analysis and statistics, graph theory and security and access control.

1. Mathematics and Computation: 
Sets hold a pivotal role in mathematics, serving as the cornerstone for numerous concepts and theories. They underpin fundamental operations like union, intersection, and difference, integral in set theory and mathematical logic. Sets are also instrumental in defining functions, relations, and mappings between diverse mathematical entities. In computational sciences, sets are harnessed in algorithms for tasks such as sorting, searching, and data manipulation.

2. Membership Testing: 
A prevalent use of sets lies in membership testing. Given a set and an element, swift determination of the element's presence or absence within the set is facilitated. This proves beneficial in programming scenarios where prompt validation of an item's existence within a collection is essential, without necessitating exhaustive searches.

3. Duplicate Removal: 
Sets find utility in eliminating duplicates from collections. By transforming a collection (e.g., a list) into a set, duplicates are automatically eradicated due to the unique nature of sets, which precludes duplicate elements. This technique proves efficient for refining data and enhancing the efficiency of diverse operations.

4. Network Programming: 
Sets are instrumental in managing and analyzing various network-related data within computer networking. For instance, in routing algorithms, sets can be employed to track visited nodes or sustain a list of reachable destinations. Sets are also effective in overseeing connections, monitoring open sockets, and ensuring distinctness in network-oriented data structures.

5. Database Operations: 
Sets play a substantial role within database management systems. They enable operations like intersection, union, and difference to be performed between tables and sets of records. These operations are pivotal for database querying, data filtration, and deriving meaningful insights from voluminous datasets.

6. Data Analysis and Statistics: 
Sets are integral to a plethora of statistical and data analysis techniques. They are employed to establish and manipulate sample spaces in probability theory. Sets also find application in partitioning data for tasks like clustering and classification, where data is grouped based on shared attributes.

7. Graph Theory: 
In graph theory, sets are pivotal for defining the vertices and edges of a graph. They facilitate the representation of relationships between different entities and enable analysis of graph properties. For instance, sets can depict the set of neighbors of a vertex within a graph.

8. Security and Access Control:
Sets are pivotal in security and access control systems, used for managing permissions and access privileges. They aid in defining roles, user groups, and the resources accessible by various users or groups. Sets also determine whether a user possesses the required permissions for specific actions.

11. Performance Considerations

Sets and lists are essential data structures in computer science used to store collections of elements, each with distinct performance characteristics affecting their efficiency in various operations.

1. Membership Checking: 
Sets utilize a hashing mechanism, employing a hash table that enables rapid membership checking. Through a hash function, elements are mapped to specific memory locations, allowing quick determination of an element's presence in the set. As a result, sets offer constant time complexity (O(1)) for membership checks. Conversely, lists necessitate traversing the entire list to ascertain membership, resulting in a linear time complexity (O(n)).

2. Insertion and Deletion: 
Sets excel in insertion and deletion operations due to their hash table structure. When inserting an element, the hash function determines the optimal position, yielding an average constant time complexity (O(1)). Deleting an element is similarly efficient. Lists, however, may require repositioning elements during insertions or deletions, leading to a worst-case linear time complexity (O(n)).

3. Ordering: 
Sets store elements without a guaranteed order, contributing to their efficiency in specific operations. Lists maintain element order, potentially impacting performance due to necessary order maintenance during insertions and deletions.

4. Memory Overhead: 
Sets offer rapid membership checks but involve some memory overhead due to the hash table. Each element consumes extra memory for hash table entries. Lists possess a simpler memory layout, directly linking elements without additional hash table entries.

12. Comparing Sets and Lists

Sets and lists have their own strengths and weaknesses. Choosing between them depends on your specific use case.

Sets Advantages:

  1. Distinct Elements: Sets exclusively accommodate unique elements, disallowing any duplicates within the set.
  2. Swift Retrieval: Fundamental operations like addition, removal, and membership checks in sets boast an average time complexity of O(1), rendering them exceptionally efficient for managing extensive datasets.
  3. Mathematical Operations: Sets support various operations such as union, intersection, and difference, which prove invaluable in a variety of applications.
  4. Hashing: The implementation of sets relies on hash tables, enabling rapid access to elements contained within.
  5. Membership Testing: Sets are well-suited for confirming the presence of a particular element within the collection.

Sets Disadvantages:

  1. Lack of Order: Sets do not uphold the sequence of elements as they were inserted. Consequently, if element order preservation is crucial, sets may not be the optimal choice.
  2. Mutable Nature: Sets are mutable, permitting changes subsequent to their creation. This characteristic demands caution to prevent unintended consequences.

Lists Advantages:

  1. Sequence Preservation: Lists maintain the sequence of elements, ensuring retrieval in the same order they were added.
  2. Versatility: Lists can contain duplicate elements and a diverse array of data types.
  3. Flexibility: Being mutable, lists readily allow alterations, additions, and removals of elements.
  4. Index-Based Access: Elements within a list can be accessed using their corresponding indices, a feature beneficial for specific use cases.

Lists Disadvantages:

  1. Slower Retrieval: Common operations like membership checks (O(n)) and element removal (O(n)) in lists have a slower time complexity when compared to sets.
  2. Inefficiency with Large Data: As lists expand in size, specific operations may experience decreased efficiency due to the need to shift elements.
  3. Permitting Duplicates: Lists accommodate duplicate elements, which may be undesirable in certain scenarios.

Choosing Between Sets and Lists:

Opt for a set when necessitating storage for unique elements and swift membership tests, especially if element order isn't a priority. Opt for a list when preserving element order, allowing duplicates, and requiring the capability to modify data are paramount.

13. Sets vs. Dictionaries

Sets and dictionaries share some similarities, but they serve different purposes. Dictionaries store key-value pairs, while sets only store distinct elements.


A set is an unordered collection of distinct elements. In programming, sets are primarily used when the order of elements is irrelevant, and only the uniqueness of values matters. Each element in a set is unique, meaning that duplicate values are automatically eliminated.

Features and Use Cases of Sets:

1. Uniqueness: Sets excel at storing a collection of items while ensuring that no duplicates are present. This makes them ideal for scenarios where maintaining uniqueness is crucial.
2. Membership Testing: Sets offer efficient membership testing. Checking whether an element exists in a set is faster compared to other data structures like lists or arrays.
3. Mathematical Operations: Sets support common set operations such as union, intersection, and difference. This makes them valuable in applications involving data comparison, filtering, and manipulation.


A dictionary is a collection of key-value pairs; each key in a dictionary is unique and corresponds to a matching value. Dictionaries are designed to efficiently retrieve values based on their associated keys.

Features and Use Cases of Dictionaries:

1. Key-Value Mapping: Dictionaries excel at associating keys with values. They are widely used when quick access to data based on unique identifiers (keys) is crucial.
2. Data Retrieval: Using a key to retrieve values from a dictionary is faster than iterating over a list to find a specific value.
3. Labeling and Categorization: Dictionaries are ideal for categorizing and labeling data, making them useful in circumstances such as data indexing, configuration settings, and others.


Purpose: Sets prioritize uniqueness of elements, while dictionaries focus on efficient key-value association and retrieval.
Data Retrieval: Sets do not allow direct access to individual elements based on an index or key, unlike dictionaries.
Operations: Sets support set-specific operations like union, intersection, and difference, while dictionaries do not.
Key Uniqueness: In dictionaries, key uniqueness is enforced, whereas sets inherently ensure uniqueness of elements.
Performance: Sets typically have slightly faster membership testing due to their hashing mechanism, while dictionary key retrieval is optimized for efficiency.

14. Tips for Effective Set Usage

    1. Uniqueness: Sets store only unique elements. Use them when you need to ensure that each element appears only once in a collection.
    2. Fast Membership Testing: Sets offer quick membership testing. Checking if an element is in a set is much faster compared to lists or other data structures.
    3. No Order: Sets don't maintain order. If you don't need to keep elements in a specific sequence, sets are a good choice.
    4. Creating Sets: Use the set() constructor or curly braces {} to create sets. For example: my_set = {1, 2, 3}.
    5. Adding Elements: Add elements using the add() method. Example: my_set.add(4).
    6. Removing Elements: Remove elements using the remove() method. Check for existence using discard() to avoid errors if the element is not present.
    7. Set Operations: Sets support common set operations like union, intersection, and difference. Use union(), intersection(), and difference() methods.
    8. Clearing a Set: Use clear() method to remove all elements from a set.
    9. Copying Sets: Create a shallow copy using the copy() method or by using the set() constructor with an existing set.
    10. Set Comprehensions: Create sets using set comprehensions, similar to list comprehensions.


Sets are a versatile and strong Python feature that can assist you with a range of programming challenges. They are an essential part of every programmer's arsenal due to their capacity to keep unique components as well as the broad number of actions they provide.


Q: Can sets contain duplicate elements?
A: No, sets in Python only store unique elements.

Q: How do I add a set element?
A: Easily insert a new element using Python's .add() function: my_set.add(new_element).

Q: What's the difference between remove() and discard() for sets?
A: With remove(), no element means an error; with discard(), no element means no problem – it carries on smoothly.

Q: Can I modify a set in-place?
A: Yes, Python provides various methods to modify sets in-place, such as update() and intersection_update().

Q: What's the advantage of using frozensets?
A: Frozensets are immutable, making them suitable for situations where you need an unchangeable set, like using a set as a dictionary key.

Post a Comment