Python Sets

A set is an unordered collection of unique elements in Python. It is a built-in data type that is commonly used in various programming tasks, such as data processing, searching, and filtering. Here are some key points to remember about Python sets:

• Sets are defined by enclosing a comma-separated sequence of items in curly braces ({}) or by using the set() function.
• Sets are unordered, meaning the elements are not stored in any particular order.
• Sets can only contain unique elements, which means that duplicate items are automatically removed.
• Sets are mutable, so you can add or remove elements after they are created.
• Sets support various operations such as union, intersection, difference, and symmetric difference.
• Sets are iterable, meaning you can loop over them and perform operations on each element.
• Sets can be used to remove duplicates from a list or other sequence data type.

In summary, Python sets are a useful tool for working with unique, unordered collections of data. They provide a variety of useful operations for manipulating and processing data, and they can be used in a variety of contexts, from simple data cleaning tasks to complex algorithmic problems.

How to create Python Sets

There are two ways to create a set in Python:

1. Using curly braces {}: You can create a set by enclosing a comma-separated sequence of items inside curly braces. For example:

my_set = {1, 2, 3, 4, 5}
print(my_set)

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

2. Using the set() constructor: You can also create a set using the set() constructor function. The constructor takes an iterable as an argument and returns a new set object. For example:

my_set = set([1, 2, 3, 4, 5])
print(my_set)

Output:

{1, 2, 3, 4, 5}

Note that you can also create an empty set using the set() constructor:

empty_set = set()
print(empty_set)

The properties of Python sets:

1. Unordered: Sets are unordered, meaning the elements are not stored in any particular order.

2. Unique elements: Sets can only contain unique elements, which means that duplicate items are automatically removed.

3. Mutable: Sets are mutable, so you can add or remove elements after they are created.

4. Iterable: Sets are iterable, meaning you can loop over them and perform operations on each element.

5. Mathematical operations: Sets support various operations such as union, intersection, difference, and symmetric difference.

6. Hashable elements: Set elements must be hashable, which means that they must have a hash value that does not change during their lifetime.

7. Not indexable: Sets are not indexable, meaning you cannot access elements by their position in the set.

8. No duplicates: If you try to add a duplicate element to a set, it will not be added because sets only contain unique elements.

9. No order: If you try to access an element by its index in a set, you will get a TypeError because sets are unordered.

Overall, sets are a useful data structure in Python for storing and manipulating unique, unordered collections of data. They have many built-in operations that can be used to perform set operations, and they are efficient for many common use cases.

Here are some examples to illustrate the properties of Python sets:

Unordered:

my_set = {3, 1, 4, 1, 5} # Create a set with unordered elements
print(my_set)
# Output: {1, 3, 4, 5}

Note that the order of the elements in the set is not the same as the order they were defined in.

Unique elements:

Example:

my_set = {3, 1, 4, 1, 5} # Create a set with duplicate elements
print(my_set)
# Output: {1, 3, 4, 5}

Note that the duplicate element “1” was automatically removed from the set.

Mutable:

Example:

my_set = {1, 2, 3}
my_set.add(4) # Add an element to the set
print(my_set)
# Output: {1, 2, 3, 4}

my_set.remove(2) # Remove an element from the set
print(my_set)
# Output: {1, 3, 4}

Note that you can add and remove elements from the set after it is created.

Iterable:

Example:

my_set = {1, 2, 3, 4}
for element in my_set:
print(element)
# Output: 1 2 3 4

How you can loop over the elements of a set using a for loop.

Example:

my_set = {‘apple’, ‘banana’, ‘orange’, ‘pear’}
for element in my_set:
print(element)
# Output: ‘orange’, ‘apple’, ‘pear’, ‘banana’

Note that you can loop over the elements of a set using a for loop.

Mathematical operations with python sets:

Example:

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

print(set1.union(set2)) # Union of set1 and set2
# Output: {1, 2, 3, 4, 5, 6}

print(set1.intersection(set2)) # Intersection of set1 and set2
# Output: {3, 4}

print(set1.difference(set2)) # Difference between set1 and set2
# Output: {1, 2}

print(set1.symmetric_difference(set2)) # Symmetric difference between set1 and set2
# Output: {1, 2, 5, 6}

Note that sets have built-in methods for performing common set operations, such as union, intersection, difference, and symmetric difference.

 

Hashable elements:

Example:

my_set = {(1, 2), “hello”, 3.14} # Create a set with hashable elements
print(my_set)
# Output: {(1, 2), ‘hello’, 3.14}

Note that the elements of a set must be hashable, which means they must have a hash value that does not change during their lifetime.

Immutable objects like tuples, strings, and numbers are hashable.

Not indexable:

my_set = {1, 2, 3}
print(my_set[0]) # Try to access an element by index
# Output: TypeError: ‘set’ object is not subscriptable

Note that if you try to add a duplicate element to a set, it will not be added because sets only contain unique elements.

Example:

my_set = {‘apple’, ‘banana’, ‘orange’}
print(my_set[0]) # Try to access an element by index
# Output: TypeError: ‘set’ object is not subscriptable

Note that sets are not indexable, meaning you cannot access elements by their position in the set.

Unordered:

my_set = {‘banana’, ‘apple’, ‘orange’, ‘pear’}
print(my_set)
# Output: {‘orange’, ‘apple’, ‘pear’, ‘banana’}

Note that the order of the elements in the set is not the same as the order they were defined in.

Unique elements:

my_set = {‘apple’, ‘banana’, ‘orange’, ‘banana’}
print(my_set)
# Output: {‘apple’, ‘banana’, ‘orange’}

Note that the duplicate element “banana” was automatically removed from the set.

No duplicates:

my_set = {‘apple’, ‘banana’, ‘orange’}
my_set.add(‘banana’)
print(my_set)
# Output: {‘apple’, ‘banana’, ‘orange’}

Note that if you try to add a duplicate element to a set, it will not be added because sets only contain unique elements.

Uses of python sets

Python sets have many uses in programming. Here are some common use cases:

1. Removing duplicates: Sets are particularly useful for removing duplicate elements from a list or other iterable. You can simply convert the iterable to a set and then convert it back to a list to remove the duplicates. For example:

my_list = [1, 2, 2, 3, 3, 3]
my_set = set(my_list)
new_list = list(my_set)
print(new_list) # Output: [1, 2, 3]

2. Membership testing: Sets are very efficient for checking if an element is present in a collection. They use hash tables to store the elements, which means that testing for membership is very fast even for large sets. For example:

my_set = {‘apple’, ‘banana’, ‘orange’}
print(‘banana’ in my_set) # Output: True
print(‘pear’ in my_set) # Output: False

3. Set operations: Sets have built-in methods for performing common set operations, such as union, intersection, difference, and symmetric difference. These operations can be used to combine, compare, or filter collections. For example:

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

print(set1.union(set2)) # Union of set1 and set2
# Output: {1, 2, 3, 4, 5, 6}

print(set1.intersection(set2)) # Intersection of set1 and set2
# Output: {3, 4}

print(set1.difference(set2)) # Difference between set1 and set2
# Output: {1, 2}

print(set1.symmetric_difference(set2)) # Symmetric difference between set1 and set2
# Output: {1, 2, 5, 6}

4. Counting unique elements: Sets can be used to count the number of unique elements in a collection. For example:

my_list = [1, 2, 2, 3, 3, 3]
unique_count = len(set(my_list))
print(unique_count) # Output: 3

5. Filtering with set comprehension: Sets can be used with set comprehension to filter elements based on a certain condition. For example:

numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_numbers = {x for x in numbers if x % 2 == 0}
print(even_numbers) # Output: {2, 4, 6, 8, 10}

Here we use set comprehension to create a new set even_numbers that contains only the even numbers from the numbers set.

6. Finding common elements: Sets can be used to find common elements between multiple collections. For example:

set1 = {1, 2, 3}
set2 = {2, 3, 4}
set3 = {3, 4, 5}

common_elements = set1.intersection(set2, set3)
print(common_elements) # Output: {3}

Here we use the intersection() method to find the common elements between sets set1, set2, and set3.

7. Checking for subset or superset: Sets can be used to check if one set is a subset or superset of another set. For example

set1 = {1, 2, 3}
set2 = {2, 3}
set3 = {2, 3, 4}

print(set2.issubset(set1)) # Output: True
print(set3.issuperset(set2)) # Output: True

Here we use the issubset() method to check if set2 is a subset of set1 and the issuperset() method to check if set3 is a superset of set2.

8. Caching values: Sets can be used to cache values to avoid recomputing them. For example, consider the following function that computes the factorial of a number:

def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)

This function can be slow for large values of n, so we can use a set to cache the previously computed values:

factorial_cache = {0: 1}

def factorial(n):
if n in factorial_cache:
return factorial_cache[n]
else:
result = n * factorial(n-1)
factorial_cache[n] = result
return result

Here we use a dictionary (which is similar to a set) factorial_cache to store the previously computed factorial values. When computing the factorial of a new value, we first check if the value is already in the cache. If it is, we simply return the cached value. Otherwise, we compute the value and store it in the cache for future use.

9. Finding unique elements across multiple lists: Sets can be used to find unique elements across multiple lists. For example:

list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]
list3 = [4, 5, 6, 7]

unique_elements = set(list1 + list2 + list3)
print(unique_elements) # Output: {1, 2, 3, 4, 5, 6, 7}

Here we combine the three lists into one using the + operator, and then convert the resulting list to a set to get the unique elements.