What is Python set() Function?

Python set() is a built-in function that empowers you to easily create sets, a fundamental data structure in Python. Whether you begin with an empty set or transform an iterable, this function is your gateway to a collection of unique elements, adept at removing duplicates. While sets are mutable, allowing you to modify their contents, they remain unordered, meaning you can’t access elements by index.

To get a better understanding , let’s imagine you’re at a glamorous party with a collection of distinct celebrities. Each celebrity brings their unique charm. The Python set() function is like your VIP invitation to this party—it creates a set, a collection of uncommon elements with no duplicates allowed. This function ensures that you’re surrounded by only the most exclusive members of the collection.

Now that you’ve grasped the fundamental concepts behind Python set() function, let’s progress and delve into its syntax and parameter, as these aspects hold significant importance when it comes to applying this function in practical, real-world scenarios.

Python set() Syntax and Parameter

Crafting a set with the syntax of Python set() function is a straightforward process. Simply invoke the function and provide it with an argument. Let’s investigate this further:


When it comes to parameters, the set() function keeps things simple. It expects just one argument—the iterable you want to convert into a set. This iterable can be a list, tuple, string, or any other iterable collection.

Now that you have a good grasp of the syntax and parameter of Python set(), let’s delve into its return values to gain insight into how this function operates in real-world examples.

Python set() Return Value

The return value of the Python set() function is a new set object. This set contains the individual elements from the sequence provided as an argument to the set() function, eliminating any repetitive elements. This returned set can be used for various set operations, including unions, intersections, additions, and removals, depending on your specific requirements in your Python program. Consider the below example:

Example Code
string_set = set(["Python", "React", "JAVA"]) print(string_set)

For this example, we are using Python to create a set called string_set. This set is formed by passing a list of three strings – Python, React, and JAVA – as an argument to the set() function. When we print out string_set, we’ll see the unique strings contained within it.

{‘React’, ‘JAVA’, ‘Python’}

This means any duplicates in the original list are automatically removed, and you’ll get the output as a set of distinct strings.

As mentioned above, that the set() is a non-primitive data type in the Python language, utilized for establishing sets within your code. Now, let’s take a closer look and explore the set() function in greater depth by delving into practical examples to enhance your understanding.

I. Creation of set() Object

Establishing a set() object in Python involves the initialization of a fresh set data structure. When an iterable is supplied as input, it assembles the distinct elements from the iterable. Sets in Python innately uphold the characteristic of exclusively housing uncommon elements and do not retain the initial sequence of elements. For example:

Example Code
empty_set = set() print("The empty set is: ",empty_set)

Here, we are creating an empty set using Python. We do this by calling the set() constructor with no arguments inside the parentheses. Then, we print the empty set using print(). So, when we run this code, it will display The empty set is:  followed by an empty set, which is represented by two curly braces: {}. This signifies that the set is empty, as it doesn’t contain any elements.

The empty set is: set()

As you can see, creating an empty set in Python is quite straightforward, using the set() constructor with no arguments, and it’s represented by a pair of curly braces when displayed.

II. Python set() with Float

In Python, when you utilize the set() function with a collection of floating-point numbers as input, it generates a set containing the unique floating-point values from your input collection, efficiently discarding any repetitive elements. To clarify, consider the following example:

Example Code
temperatures_celsius = (25.5, 30.2, 15.8, 25.5, 18.3, 30.2) unique_temperatures = set(temperatures_celsius) print("Unique temperatures in degrees Celsius:", unique_temperatures)

In this example, we have a tuple temperatures_celsius containing temperatures in degrees Celsius from different countries. We use the set() function to create a set called unique_temperatures, which will automatically remove any duplicate temperature values. Finally, we print out the unique temperatures, illustrating how sets can be used to collect and display distinct values, in this case, temperatures.

Unique temperatures in degrees Celsius: {25.5, 18.3, 30.2, 15.8}

As you observe in the preceding example, it’s evident that you can employ the set() function with floating-point numbers in a manner similar to using it with strings.

III. Set() with Unordered Data

You can utilize the set() function in Python when dealing with data that contains replicas and doesn’t adhere to a particular order, and it accomplishes two primary tasks. First, it automatically eliminates repetitive elements from the given data, guaranteeing that the resulting set exclusively holds individual elements.

Second, it’s essential to understand that Python sets inherently don’t retain the original sequence or arrangement of elements within them. This means that the arrangement of elements in the set doesn’t necessarily match the original order in the input data. To showcase this characteristic with unordered data, consider the following example:

Example Code
prime_numbers = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29) unique_primes_set = set(prime_numbers) print("Unique prime numbers:", unique_primes_set)

For this example, we have a tuple prime_numbers containing prime numbers in an unordered fashion. When we apply the set() function to prime_numbers, it automatically removes any duplicate prime numbers and creates a set named unique_primes_set. Finally, we print out the unique prime numbers from the set.

Unique prime numbers: {2, 3, 5, 7, 11, 13, 17, 19, 23, 29}

Clearly, employing the set() function proves to be a proficient method for gathering and presenting the distinct prime numbers found within an unorganized tuple.

IV. Python set() with Range

In Python, when you use the set() function with a range object, it creates a set containing a sequence of uncommon integer values generated by the range. This is particularly useful when you want to create a set of consecutive numbers within a specified range. Here’s an example:

Example Code
number_range = range(2, 8) squared_numbers_set = set(x * x for x in number_range) print(squared_numbers_set)

Here, we’re working with a group of numbers defined by the number_range variable. We’ve set number_range to be a range of numbers starting from 2 and ending just before 8 (so it includes 2, 3, 4, 5, 6, and 7).

Then, we create a set called squared_numbers_set. Inside this set, we use a generator expression. This expression takes each number x from the number_range, calculates its square by multiplying it by itself (i.e., x * x), and adds the result to the set. This way, we’re storing the squares of each number within the specified range in the set. Finally, when we print out squared_numbers_set, we will see the unique squares of the numbers in the number_range.

{4, 36, 9, 16, 49, 25}

So, using Python, you can efficiently calculate and display the squares of a range of numbers. This method allows you to evaluate and present the squares of a sequence of numbers with ease.

Now that you’ve seen how the Python set() function operates with integers, strings, and floating-point numbers, let’s progress and explore the set operations you can perform using the set() function. Let’s explore them.

Performing Set Operations with set()

Imagine yourself as a magician, wielding the power of the set() function as your magical wand. With it, you can easily create unions, intersections, and differences, performing astonishing feats. Let’s explore a few scenarios:

I. Python set() Union Operation

Python’s set() function, in your hands, performs a union operation by merging two sets to create a new set that contains all the unique elements from both sets. It efficiently gathers and combines elements from both sets while ensuring that any duplicate values are automatically removed. Consider below illustration:

Example Code
set1 = {1, 2, 3, 4} set2 = {3.3, 4.12, 5, 6} union_result = set1.union(set2) print("Union of set1 and set2:", union_result)

In this example, we’re working with two sets, set1 and set2, as a group. set1 contains the elements 1, 2, 3, and 4, while set2 contains the elements 3.3, 4.12, 5, and 6. Next, we perform a union operation using the union() method on these sets, creating a new set called union_result. This union_result set now contains all the unique elements found in both set1 and set2. Finally, we print out the result, displaying the union of set1 and set2, which ensures that any duplicate values are automatically removed.

Union of set1 and set2: {1, 2, 3, 4, 3.3, 4.12, 5, 6}

By employing the method outlined above, you can easily perform a union operation with sets, allowing you to seamlessly merge two sets into one.

II. Python set() Intersection Operation

Employing the set() intersection operation enables you to identify the shared elements within two sets. This process is commonly executed using either the & operator or the intersection() method. For instance, when dealing with two sets, set cities_set1 and set cities_set2, you can evaluate their intersection using the following approach.

Example Code
cities_set1 = {"New York", "Los Angeles", "Chicago", "Houston"} cities_set2 = {"Los Angeles", "San Francisco", "Chicago", "Miami"} intersection_result = cities_set1.intersection(cities_set2) print("Intersection of cities_set1 and cities_set2:", intersection_result)

For this example, we have two sets, cities_set1 and cities_set2, each containing city names. We use the intersection() method to perform the intersection operation between these sets. The result, stored in intersection_result, will be a new set that contains the city names common to both cities_set1 and cities_set2. When you print intersection_result, it will display the intersection of these two sets, showing the city names that are shared between them.

Intersection of cities_set1 and cities_set2: {‘Los Angeles’, ‘Chicago’}

So, you’ll see the intersection of city names between cities_set1 and cities_set2 when you run this code, highlighting the cities that are common to both sets.

III. Python set() Difference Operation

You can use the Python set() difference operation to find the elements that exist in one set but not in another. Specifically, it calculates the difference between two sets and returns a new set containing elements from the first set that are not present in the second set. This operation allows you to identify and isolate elements unique to one set when compared to another. For example:

Example Code
even_numbers_set = {2, 4, 6, 8, 10} odd_numbers_set = {1, 3, 5, 7, 9} difference_result = even_numbers_set.difference(odd_numbers_set) print("Difference between even_numbers_set and odd_numbers_set:", difference_result)

Here, we have two sets, even_numbers_set and odd_numbers_set, each containing even and odd numbers, respectively. We use the difference() method to perform the difference operation between these sets. The result, stored in difference_result, will be a new set that contains the even numbers that are not present in the odd_numbers_set. When you print difference_result, it will display the difference between these two sets, showing the even numbers unique to even_numbers_set.

Difference between even_numbers_set and odd_numbers_set: {2, 4, 6, 8, 10}

As you execute this above example, you’ll notice the contrast between even and odd numbers, specifically highlighting those even numbers that belong exclusively to the set of even_numbers_set.

Python set Advanced Examples

In the following section, we will examine several advanced examples of Python set() function, highlighting its flexibility and wide range of applications.

I. Python set() with While Loop

Python set() can be used with a while loop to iteratively collect and store unique values in a set. This combination allows you to create a set dynamically while iterating through a sequence of data or until a specific condition is met. You can use the add() method to add elements to the set inside the while loop, ensuring that repetitive elements are automatically removed, as sets only contain unique elements. For instance:

Example Code
unique_factorials = set() current_number = 1 factorial = 1 max_factorial = 10 while current_number <= max_factorial: factorial *= current_number unique_factorials.add(factorial) current_number += 1 print("Unique factorials up to", max_factorial, "are:", unique_factorials)

In this example, we, are accomplishing several tasks. Firstly, we create an empty set called unique_factorials to store unique factorial values. We initialize two variables, current_number and factorial, both set to 1. We also define max_factorial, which represents the highest factorial value we want to calculate, set to 10 in this case.

Now, here comes the core of the code. We use a while loop to iteratively calculate factorials. As long as current_number is less than or equal to max_factorial, we continue looping. Within each iteration, we multiply the current factorial by current_number, and then we add this result to the unique_factorials set. This ensures that we’re only collecting unique factorial values. Finally, after the loop completes, we print out the unique factorials up to the specified maximum value, which in this case is 10.

Unique factorials up to 10 are: {40320, 1, 2, 362880, 3628800, 6, 720, 5040, 24, 120}

This above example showcase how to dynamically calculate and store unique factorial values using a set and a while loop.

II. Python set() with Dictionary

Python set() function can also be employed with dictionaries, much like with lists and tuples. When applied to a dictionary, it allows you to extract and organize uncommon elements, depending on your specific requirements. For instance, invoking set(dictionary) enables you to create a set comprising the dictionary’s unique keys.

To obtain a set of distinct values from the dictionary, you can first convert the values into a list and then utilize set(list(dictionary.values())). Furthermore, set(dictionary.items()) permits the creation of a set containing unique key-value pairs (items). Consider the below example.

Example Code
def extract_unique_keys(dictionary): unique_keys = set(dictionary) return unique_keys car_dict = {'Tesla': 'Model S', 'Ford': 'Mustang', 'Chevrolet': 'Corvette', 'Tesla': 'Model 3', 'Porsche': '911'} unique_car_makers = extract_unique_keys(car_dict) print("Unique car manufacturers in the dictionary:", unique_car_makers)

For this example, we’ve defined the extract_unique_keys function, which takes a dictionary as its argument. The sample dictionary car_dict contains famous car manufacturers as keys. When we call the function extract_unique_keys with this dictionary, it extracts and returns the unique car manufacturers (keys), even if there are duplicates in the original dictionary. Finally, we print the result, displaying the unique car manufacturers present in the dictionary.

Unique car manufacturers in the dictionary: {‘Porsche’, ‘Chevrolet’, ‘Tesla’, ‘Ford’}

So, by using this approach, you’ll see the unique car manufacturers from the dictionary, emphasizing the capability of the set() function to handle duplicates and extract distinct keys.

III. Create set() for a Custom Iterable Object

Creating a set for a custom iterable object in Python involves using the set() constructor to transform the iterable into a set data structure.

For instance, if you have a custom iterable object like a list, tuple, or any other iterable, you can pass it as an argument to the set() constructor to convert it into a set. This can be useful when you want to deduplicate the elements within the iterable or when you need to perform set operations with the custom iterable. The resulting set will contain all the distinct elements from the original iterable, preserving their order if the iterable maintains order. For instance.

Example Code
def fibonacci(n): fib_series = [] a, b = 0, 1 while len(fib_series) < n: fib_series.append(a) a, b = b, a + b return fib_series fibonacci_set = set(fibonacci(20)) print("Set created from the custom iterable (Fibonacci series):", fibonacci_set)

Here, we define a custom iterable fibonacci(n) that generates the first n terms of the Fibonacci series. We then create a set fibonacci_set from this iterable to automatically remove any common values. You can change the value 20 to generate a different number of Fibonacci terms, and when you print fibonacci_set, it will display the unique Fibonacci numbers in the set.

Set created from the custom iterable (Fibonacci series): {0, 1, 2, 3, 5, 8, 13, 144, 21, 2584, 34, 55, 1597, 4181, 89, 987, 610, 233, 377}

Upon running this code, you’ll see a set that holds unique Fibonacci numbers derived from the custom iterable.

IV. Managing Exceptions and Errors with set()

Managing exceptions and errors with set() in Python is essential for ensuring the robustness and reliability of your code. You may encounter exceptions like ValueError when trying to create a set from an iterable with unshushable items, AttributeError if you use invalid methods or attributes with sets, KeyError when attempting to access non-existent elements, or TypeError when performing unsupported operations.

To maintain code stability, it’s crucial to utilize try-except blocks and other error-handling techniques to gracefully handle these situations. This approach prevents unexpected program termination and enhances the overall resilience of your code when working with sets. Consider below illustration.

Example Code
class SetManager: def __init__(self): self.my_set = set() def add_element(self, element): try: self.my_set.add(element) except TypeError as e: print(f"Error: {e}") except ValueError as e: print(f"Error: {e}") def display_set(self): print("Current Set:", self.my_set) set_manager = SetManager() set_manager.add_element(1) set_manager.add_element(2) set_manager.add_element([3, 4]) set_manager.add_element(1) set_manager.display_set()

In this example, we’ve created a SetManager class that encapsulates a set named my_set. The add_element method attempts to add elements to the set but includes exception handling for TypeError and ValueError. When an exception occurs, it prints an error message. After adding elements and potentially encountering exceptions, the display_set method displays the current set. When you run this code, you’ll see how the class handles exceptions and maintains the set.

Error: unhashable type: ‘list’
Current Set: {1, 2}

As you can see in the example, employing these exception-handling techniques allows you to safeguard your code efficiently against potential errors.

Having gained a solid understanding of Python’s set() function, its flexible and convenient applications, and adaptability in different scenarios, you’ve built a sturdy knowledge base. To further enhance your grasp of this topic, let’s delve into some theoretical concepts that will greatly support your journey through Python programming.

Practical Usage of set() Function

Here are some practical ways you can use Python set() function in your programming journey:

I. Removing Duplicates

You can use set() to quickly eliminate duplicate elements from a list or other iterable, ensuring that your data remains unique.

II. Membership Testing

Sets are highly efficient for membership testing. You can use them to check if an element exists in a collection without needing to iterate through the entire collection.

III. Set Operations

Sets allow you to perform set operations like union, intersection, and difference efficiently, making them valuable for tasks like finding common elements between multiple datasets.

Exploring Unique Use Cases of set()

Here are a variety of distinctive applications for the set() function that you can incorporate into your programming endeavors:

I. Network Graph Analysis

In your Python projects, you can utilize sets to represent nodes or edges in a network graph. This approach proves helpful when you need to identify connected components or detect cycles within your network structures, enhancing your ability to work with graphs efficiently.

II. Simulating Probabilistic Events

Sets can simulate probabilistic events by randomly sampling elements, useful for Monte Carlo simulations or statistical modeling.

III. Dealing with Sparse Data

Sets are efficient for handling sparse data structures, where many elements are missing, as they naturally eliminate duplicates.

Congratulations! You’ve embarked on a journey to discover the power of Python set() function. It’s your key to creating sets, a fundamental data structure in Python that gathers unique elements, eliminating duplicates. Think of it like a VIP invitation to a glamorous party, ensuring you’re surrounded only by the most exclusive members.

In this fascinating article, you’ve delved deep into the capabilities of Python’s set() function across various contexts. You’ve witnessed how set() seamlessly handles integers, strings, and floating-point numbers, adapting to unordered data easily. Additionally, you’ve discovered its flexibility and convenience, as it interacts harmoniously with dictionaries, lists, and tuples.

Set operations serve as the real showstoppers. Just like a magician with their tricks, you’ve harnessed set() to easily conjure unions, intersections, and differences between sets. You’ve also embarked on advanced adventures, crafting sets dynamically with while loops and navigating custom iterable objects like the Fibonacci series. Moreover, sets have proven their worth in the realm of error management, safeguarding your code with graceful exception handling, ensuring its robustness.

As you continue your Python journey, these practical and unique applications of set() will prove invaluable. You’ll use sets to remove duplicates, test for membership efficiently, and perform set operations like a pro. Plus, you’ll unlock its potential in network graph analysis, probabilistic simulations, and handling sparse data. So keep exploring, and may your Python adventures be filled with elegant solutions and unique discoveries!

Scroll to Top