Alexis Kestler
Sets are an often overlooked but extremely powerful built-in data structure within Python. In my 10+ years as a data analyst and Python developer, I have come to rely on sets for a wide range of critical tasks:
- Removing duplicate entries
- Blazingly fast membership testing
- Identifying shared and distinct elements
- Applying useful mathematical set theory concepts and operations
- Performing analytics on dataset properties
- And much more!
While seemingly simple on the surface, mastering Python sets enables you to write simpler, faster and more Pythonic code.
My goal in this guide is to lift the veil on sets through clear explanations, visuals, 19 code examples and tips gleaned from years of applying sets in complex data projects.
We have a lot to cover, so let‘s get started!
Sets in Python: An Intuitive Yet Technical Explanation
Let‘s kick things off by properly defining what exactly a set is:
A set is an unordered collection of unique, immutable objects.
Now what does this actually mean? Let me break it down piece by piece:
First, a set is a collection just like other data structures – it stores elements that relate to one another in some way.
However, sets have two key properties that distinguish them from the likes of lists and dictionaries:
1. Sets contain only distinct objects – no repetitions allowed. Adding the same element twice has no effect. I often describe sets as a bag of marbles – while you can have an unlimited number of colors, there is only one of each color marble.
2. Sets are unordered, meaning elements aren‘t indexed or stored sequentially. Without positional ordering, you can‘t access items by index like my_set[0].
Beyond these two main attributes, set elements also share two additional characteristics:
3. Sets can only contain immutable object types – like numbers, strings, tuples. Lists and dicts can‘t exist in a set since they are mutable. I remember this by thinking "a set solidifies immutable elements".
4. Sets themselves are mutable – you can freely add and remove elements from an existing set without restriction. Sets strike a nice balance between having locked-down elements but dynamic structure.
Visualizing sets really etches these unique properties in!
Here is how I picture a Python set:
- Unordered bag of elements
- Unique values only
- Mutable overall
- Made up of immutable pieces like numbers, strings, tuples
With those fundamentals down, you now have an intuitive yet technical grasp of what makes sets tick! Next up, let‘s see sets in action…
3 Ways to Initialize a Set in Python
While sets have special properties, you initialize them similarly to other data structures in Python.
There are three common ways to instantiate a set – I‘ll walk through each with examples:
1. Set Literal
My personal favorite way is using a set literal enclosed in curly braces {}. This allows directly declaring a set with elements separated by commas:
prime_numbers = {2, 3, 5, 7, 11}
print(type(prime_numbers)) # <set>Note: Using just {} alone creates a dict not a set! I tripped over this for longer than I‘d like to admit…
2. Built-in set() function
You can convert other iterables like lists into a set using the set() constructor function:
new_set = set([1, 1, 2, 2, 3]) # set removes dupes
print(new_set) # {1, 2, 3} Casting other structures into a set is perfect for de-duping elements!
3. Empty set()
Initialize an empty set then .add() elements one by one:
empty_set = set() # Initialize empty set
empty_set.add(1) # Insert first element
print(len(empty_set)) # 1And that‘s really all there is to getting started with Python sets!
Now that you know how to create sets, let‘s move on to dynamically modifying them…
Modifying Python Sets: Add, Remove, Pop, Discard & More
While immutable internally, sets themselves are mutable – you can freely grow, shrink and reshape them!
Understanding how to properly modify sets empowers you to model complex domains and drive efficiencies.
Let me demonstrate common ways to alter set contents:
Add Elements
.add() inserts a single element if not already present:
numbers = {1, 2}
numbers.add(3)
print(numbers) # {1, 2, 3}While .update() merges multiple elements through another iterable:
numbers.update([3, 4, 5, 6])
print(numbers) # {1, 2, 3, 4, 5, 6}Think .add() to insert a single element vs .update() to merge collections.
Remove Elements
.remove() deletes the specified element:
primes = {2, 3, 5, 7, 11}
primes.remove(7)
print(primes) # {2, 3, 5, 11}But beware – attempting to .remove() a non-existent element triggers a KeyError!
.discard() also deletes an element if present, but ignores missing values rather than erroring:
primes.discard(13) # No 13, so no issue!
print(primes) # {2, 3, 5, 11} Prefer .discard() over .remove() if you expect potential missing elements.
Pop random Element
Feeling lucky? .pop() randomly extracts an element from the set:
languages = {‘Python‘, ‘SQL‘, ‘R‘, ‘Java‘}
print(languages.pop()) # ‘SQL‘ - changes each run!Give it a try when you need a surprise pick from your set!
We‘ve added, removed and extracted set elements – now let‘s revisit accessing them.
Accessing Elements: Membership and Loops
With no ordering or keys, you can‘t access set elements by index position like lists or dictionaries.
So then how do you interact with set contents?
There are two common approaches…
Loop Over Elements
A basic for loop prints all elements (order varies run to run!):
colors = {‘red‘, ‘green‘, ‘blue‘}
for color in colors:
print(color)
# red
# blue
# greenQuick yet effective way to operate on the entire set!
Membership Testing
Check if a value is contained with O(1) speed using in:
print(‘purple‘ in colors) # False
print(‘red‘ in colors) # True in delivers blazing fast lookup capability!
Leverage loops and membership testing to access set internals and unlock their potential.
Now that you can store, modify and access set elements, let‘s explore some advanced set concepts and operations…
Set Operations Visually Explained with Python Examples
While already powerful, Python sets truly shine through their implementation of core mathematical set theory concepts.
These advanced operations enable you to derive insights by examining relationships between multiple sets.
I‘ll walk through (with diagrams!) the most useful set methods for analyzing connections:
- Union: Combine sets
- Intersection: Find common elements
- Difference: Unique elements missing from other
- Symmetric Difference: In either set but NOT both
- Subset vs Superset: Contains vs contained by
Understanding these visually really cements key theory you can apply immediately in your code!
Visualizing Python Set Union
The set union operation merges two sets into a single unified one containing elements from both inputs without duplicate values.
Set A and Set B combine through the union into a new Set C containing elements from A, B or both without duplicates.
For example:
colors1 = {‘blue‘, ‘green‘}
colors2 = {‘red‘, ‘purple‘}
print(colors1 | colors2) # Union -> {‘blue‘, ‘green‘, ‘red‘, ‘purple‘}
print(colors1.union(colors2)) # Identical method The pipe | operator or .union() method both derive the set union in Python.
Picturing the unification helps cement the merging concept!
Intersecting Python Sets
While union combines, intersection finds common elements across multiple sets.
The intersection forms a new set containing only shared elements from the inputs.
Set A and Set B intersect to create Set C with only the common elements 3.
For example finding overlap between two sets:
names1 = {‘Mary‘, ‘Juan‘, ‘Ahmed‘}
names2 = {‘Cindy‘, ‘Juan‘, ‘Ahmed‘}
print(names1 & names2) # Intersection -> {‘Juan‘,‘Ahmed‘}
print(names1.intersection(names2))The ampersand & character intersects two sets in Python.
Set Difference: Unique Missing Elements
We looked at combining and overlapping – now let‘s find distinct elements missing from other sets using set difference.
Set A relative to Set B gives elements in A missing in B.
Set B relative to Set A gives elements in B missing in A.
Here is this directional difference in Python:
A = {1, 3, 5}
B = {2, 3, 4}
print(A - B) # In A but not B -> {1, 5}
print(B - A) # In B but not A -> {2, 4} The minus - operator derives the set difference.
Make sense how it finds distinct elements from one set lacking in the other?
Symmetric Difference Between Python Sets
While set difference is directional, symmetric difference finds distinct elements present in exactly ONE set.
Set A and Set B each contain elements not contained by the other, given by the symmetric difference.
Symmetric difference implemented in Python:
A = {1, 3, 5}
B = {2, 3, 4}
print(A ^ B) # In A or B but NOT both -> {1, 2, 4, 5}We use the caret ^ operator to derive elements unique to each set separately.
Make sense why the shared element 3 is left out?
Python Subsets and Supersets
The last pair of important set operations deal with containment relationships:
Set A contains all elements of Set B, so B is a subset of the superset A.
This allows you to model hierarchies within your sets.
Here is how to check subsets and supersets in Python:
animals = {‘dog‘,‘cat‘,‘bird‘}
pets = {‘dog‘,‘cat‘}
print(pets.issubset(animals)) # True - pets subset of animals
print(animals.issuperset(pets)) # True - animals superset of pets The issubset() and issuperset() methods test these hierarchical set relationships.
Hopefully visualizing these set operations sticks the concepts with you! You can now apply core theory through Python.
We covered a ton of functionality – let‘s recap…
Summary: Why Learn Python Sets?
We started this journey by introducing some key Python set properties:
- Unordered
- Unique elements
- Mutable overall
- Made of immutable pieces
You then learned foundations like initialization and modifying elements.
But where sets really demonstrated value was enabling core mathematical operations:
- Unions to merge
- Intersections to find commonalities
- Differences to find distinct elements
- Symmetric differences for one-set uniqueness
- Subset vs superset containment relationships
These methods form an incredibly versatile toolbox to analyze multi-dataset interactions.
While sets may seem simplistic at first glance, I hope you now truly grasp their capabilities!
Let‘s wrap up with my advice on intelligently applying sets…
Python Sets in Practice: When to Use & Alternatives
From years of technical programming and data analytics, here are my rules of thumb for leveraging sets most effectively:
Sets Shine When…
Break out sets when you need:
- Distinct values for analytics/modeling
- Membership testing with lightning speed
- Implement set math theory and operations
- Remove duplicate entries across data
- Temporarily store elements before later use
- Interact with other sets through methods called
Consider Lists or Dicts When…
While powerful, sets have limitations to consider:
Lists are better when requiring:
- Strict element ordering
- Accessing items by index
- Allowing duplicates if needed
Dictionaries superior for:
- Key-to-value mapping
- Attaching additional data to elements
- Accessing elements through keys vs positions
Had I grasped these guidelines earlier, I could have avoided misapplying sets in some cases!
Conclusion: Master Python Sets
We covered a ton of ground here today my friend!
You started with an intuitive explanation of what sets represent in Python – an unordered bag of unique yet mutable objects.
We built up key learnings step-by-step:
- Initializing sets three different ways
- Mutating sets by adding and removing elements
- Accessing elements with memberships tests and loops
- Implementing math set theory through operations like unions and intersections
- And finally knowing when to reach for sets vs other data structures
Collectively, these topics equip you with deep knowledge of Python sets together with where, when and how to apply them effectively.
I hope you feel empowered to improve your code and stand apart from those who merely use sets vs deeply understanding them.
You now have no excuse for not mastering this unsung hero of a data structure! Please drop me a line if you have any other questions.
Happy programming my friend!
