Are you ready to embark on a Pythonic journey into the world of sets? Python sets are a fundamental data structure that every Python programmer should be well-acquainted with.
In this comprehensive guide, we’ll walk you through everything you need to know about Python sets, from the basics to advanced techniques, in a way that even a 10-year-old can understand.
What are Python Sets?
Let’s start with the basics. A Python set is an unordered collection of unique elements. It is similar to a list or tuple, but unlike those data structures, sets do not allow duplicate values. This makes sets an excellent choice when you need to work with a collection of distinct items.
Why Use Python Sets?
Python sets are incredibly useful for various tasks. Here are some common use cases:
- Removing Duplicates: If you have a list with duplicate elements and you want to eliminate them, converting it to a set will do the trick.
- Membership Testing: Sets are perfect for checking whether an item exists in a collection due to their efficient lookup times.
- Mathematical Operations: Sets support mathematical operations like union, intersection, and difference, which can be handy for solving a wide range of problems.
Python Set
Sets are used to store multiple items in a single variable.
Set is one of 4 built-in data types in Python used to store collections of data, the other 3 are List, Tuple, and Dictionary, all with different qualities and usage.
A set is a collection that is unordered, unchangeable*, and unindexed. Now that we understand the basics let’s delve deeper into Python sets.
Getting Started with Python Sets
Creating a Set
To create a Python set, you can use either curly braces {} or the built-in set() constructor.
Here’s an example:
my_set = {1, 2, 3}Adding and Removing Elements
You can add elements to a set using the add() method and remove them with remove() or discard(). Be careful with remove() as it raises an error if the element is not present, while discard() does not.
my_set.add(4)
my_set.remove(2)Set Operations
Python sets support a variety of operations, including:
- Union
- Intersection
- Difference
- Symmetric Difference
These operations allow you to manipulate sets to suit your needs.
Iterating Through a Set
You can easily loop through the elements of a set using a for loop.
for item in my_set:
print(item)
Advanced Python Set Techniques
Now that we’ve covered the basics, let’s explore some advanced techniques for working with Python sets.
Frozen sets
A frozen set is an immutable version of a set, meaning its elements cannot be changed after creation. This can be useful in situations where you need a hashable, unchangeable collection.
frozen_set = frozenset([1, 2, 3])Set Comprehensions
Similar to list comprehensions, you can create sets using set comprehensions, which are concise and efficient.
squared_set = {x ** 2 for x in range(1, 6)}Examples of Python sets Collection
Here! Some Examples of Python Sets Collection for Better Practice
Python – Access Set Items
You can’t access items in a set by referring to an index or a key.
Example Code!
thisset = {"apple", "banana", "cherry"}
for x in thisset:
print(x)Try it by yourself
thisset = {"apple", "banana", "cherry"}
print("banana" in thisset)Python – Add Set Items
one item to a set use the add() method.
thisset = {"apple", "banana", "cherry"}
thisset.add("orange")
print(thisset)Add Sets
thisset = {"apple", "banana", "cherry"}
tropical = {"pineapple", "mango", "papaya"}
thisset.update(tropical)
print(thisset)Add Any Iterable
The object in the update() method does not have to be a set, it can be any iterable object (tuples, lists, dictionaries, etc.).
thisset = {"apple", "banana", "cherry"}
mylist = ["kiwi", "orange"]
thisset.update(mylist)
print(thisset)Python – Remove Set Items
To remove an item in a set, use the remove(), or the discard() method.
# Remove "banana" by using the remove() method:
thisset = {"apple", "banana", "cherry"}
thisset.remove("banana")
print(thisset)#Remove "banana" by using the discard() method:
thisset = {"apple", "banana", "cherry"}
thisset.discard("banana")
print(thisset)You can also use the pop() method to remove an item, but this method will remove a random item, so you cannot be sure what item that gets removed.
The return value of the pop() method is the removed item.
#Remove a random item by using the pop() method:
thisset = {"apple", "banana", "cherry"}
x = thisset.pop()
print(x)
print(thisset)
# ----------------------------
# The del keyword will delete the set completely:
thisset = {"apple", "banana", "cherry"}
del thisset
print(thisset)
Python – Loop Sets
You can loop through the set items by using a for loop:
thisset = {"apple", "banana", "cherry"}
for x in thisset:
print(x)Python – Join Sets
Join Two Sets
There are several ways to join two or more sets in Python.
You can use the union() method that returns a new set containing all items from both sets or the update() method that inserts all the items from one set into another:
#The union() method returns a new set with all items from both sets:
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set3 = set1.union(set2)
print(set3)# The update() method inserts the items in set2 into set1:
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set1.update(set2)
print(set1)
Keep ONLY the Duplicates
The intersection_update() method will keep only the items that are present in both sets.
# Keep the items that exist in both set x, and set y:
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
x.intersection_update(y)
print(x)
# ------------------
# Return a set that contains the items that exist in both set x, and set y:
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.intersection(y)
print(z)Python – Set Methods
| Method | Returns whether two sets have an intersection or not |
|---|---|
| add() | Adds an element to the set |
| clear() | Removes all the elements from the set |
| copy() | Returns a copy of the set |
| difference() | Returns a set containing the difference between two or more sets |
| difference_update() | Removes the items in this set that are also included in another, specified set |
| discard() | Remove the specified item |
| intersection() | Returns a set, that is the intersection of two other sets |
| intersection_update() | Removes the items in this set that are not present in other, specified set(s) |
| isdisjoint() | Returns whether two sets have a intersection or not |
| issubset() | Returns whether another set contains this set or not |
| issuperset() | Returns whether this set contains another set or not |
| pop() | Removes an element from the set |
| remove() | Removes the specified element |
| symmetric_difference() | Returns a set with the symmetric differences of two sets |
| symmetric_difference_update() | inserts the symmetric differences from this set and another |
| union() | Return a set containing the union of sets |
| update() | Update the set with the union of this set and others |
Python Programming Series
Frequently Asked Questions (FAQ)
Can sets contain duplicate elements?
No, sets in Python cannot contain duplicate elements. They are designed to store only unique values.
What is the difference between remove() discard() methods?
The remove() method raises an error if the specified element is not present in the set, while the discard() method does not raise an error and simply does nothing if the element is not found.
Conclusion
In this comprehensive guide, we’ve explored the world of Python sets, from the basics to advanced techniques. We’ve covered how to create sets, perform common operations, and even delved into advanced concepts like frozen sets and set comprehensions.
Python sets are a powerful tool in your programming arsenal, and mastering them will open up a world of possibilities for your Python projects. So, start practicing, experimenting, and incorporating sets into your code to become a more proficient Python programmer.
Python Data Structures (Collections)
Python offers a diverse range of data structures for managing information effectively:
- Lists: Lists are versatile collections in Python, known for their ordered nature and mutability. They permit the presence of duplicate elements.
- Tuples: Tuples are ordered collections that remain immutable once defined. They also allow duplicate elements.
- Sets: Sets are unordered and immutable collections that do not permit duplicates.
- Dictionaries: Dictionaries are ordered (in Python 3.7+) and mutable collections, suitable for storing key-value pairs. They ensure uniqueness in keys.
Remember, practice makes perfect, and Python sets are no exception.
Happy coding!
