Introduction: Python Set Comprehension
Creating a set often requires looping through data, filtering values, or transforming elements. Python set comprehension helps perform these tasks in a shorter and more readable way.
Definition: Set comprehension is a compact syntax used to create a set by iterating over an iterable and optionally filtering values within a single expression.
It is commonly used when generating sets from existing data while keeping the code concise and easy to maintain.
You can see a quick example to understand how set comprehension works.
You can also explore the common use cases to learn where set comprehension is used in Python programs.
Take your understanding further with the complete Python Sets tutorial covering fundamentals through advanced concepts.
Why Use Set Comprehension
Python set comprehension provides a concise way to create sets and often makes code shorter, cleaner, and easier to read.
It is commonly used when:
- Only unique values are required.
- Filtering data based on specific conditions.
- Creating sets from loops, ranges, or other iterables.
- Transforming values while automatically removing duplicates.
- Writing more concise and readable code.
Before exploring examples and use cases, let us first understand the syntax and components of Python set comprehension.
Syntax & Components: Python Set Comprehension
Before using Python set comprehension in real programs, it is helpful to understand its basic syntax and the components used to create a set.
Syntax
Set comprehension uses curly braces {} along with a loop expression to create a set.
{expression for item in iterable}Syntax with Condition
An optional condition can be added to include only specific values in the resulting set.
{expression for item in iterable if condition}Syntax Components
| Component | Description |
|---|---|
| expression | The value or expression that will be added to the set. |
| item | A variable that represents each element from the iterable. |
| iterable | The collection being traversed. |
| condition | An optional filter that determines which values are included. |
Quick Example
The following example creates a set using set comprehension.
numbers = {x * x for x in range(1, 6)}
print(numbers)
# Output (Order may vary):
{1, 4, 9, 16, 25}
The comprehension loops through the values from 1 to 5, squares each value, and stores the results in a set.
Note: Sets are unordered collections, so the order of elements in the output may vary.
Examples: Python Set Comprehension
The following simple examples show how set comprehension works with numbers, conditions and basic text values.
Note: The order of elements displayed in set outputs is not guaranteed and may vary.
Simple Level Examples
Example 1: Create a Set of Numbers
numbers = {x for x in range(5)}
print(numbers)
# Output (order may vary):
{0, 1, 2, 3, 4}Explanation: This creates a set containing numbers from 0 to 4 using range(5).
Example 2: Create a Set of Even Numbers
even_numbers = {x for x in range(10) if x % 2 == 0}
print(even_numbers)
# Output (order may vary):
{0, 2, 4, 6, 8}Explanation: The condition keeps only even numbers from the given range before adding them to the set.
Example 3: Square Numbers in a Set
squares = {x * x for x in range(1, 6)}
print(squares)
# Output (order may vary):
{1, 4, 9, 16, 25}Explanation: Each number is squared and then stored as a unique value in the set, creating a set of square values.
Example 4: Remove Duplicate Characters from a String
letters = {char for char in "programming"}
print(letters)
#Output (order may vary):
{'p', 'r', 'o', 'g', 'a', 'm', 'i', 'n'}
Explanation: The set stores only unique characters from the word, so repeated letters are removed automatically.
These examples show how set comprehension can also be used with strings, lists, and simple transformations.
Medium Level Examples
Example 5: Convert List to Unique Lowercase Words
words = ["Python", "JAVA", "python", "C++"]
unique_words = {word.lower() for word in words}
print(unique_words)
#Output (order may vary):
{'python', 'java', 'c++'}Explanation: Each word is converted to lowercase, and duplicate values are automatically removed by the set.
Example 6: Get Length of Each Word
words = ["apple", "banana", "kiwi"]
word_lengths = {len(word) for word in words}
print(word_lengths)
# Output (order may vary):
{4, 5, 6}Explanation: The len() function calculates the length of each word and the results are stored as unique values in the set.
Advanced Level Examples
Example 7: Filter Numbers Greater Than 50
numbers = [10, 25, 60, 75, 90]
large_numbers = {x for x in numbers if x > 50}
print(large_numbers)
#Output (order may vary):
{90, 75, 60}Explanation: Only numbers greater than 50 are added to the new set.
Example 8: Unique Vowels from a Sentence
sentence = "Python is easy to learn"
vowels = {char.lower() for char in sentence if char.lower() in "aeiou"}
print(vowels)
#Output (order may vary):
{'a', 'e', 'i', 'o'}Explanation: The condition filters only vowel characters, while the set keeps each vowel only once.
Example 9: Remove Duplicate Email Domains
emails = [
"john@gmail.com",
"alice@yahoo.com",
"mike@gmail.com",
"emma@outlook.com"
]
domains = {email.split("@")[1] for email in emails}
print(domains)
#Output (order may vary):
{'gmail.com', 'yahoo.com', 'outlook.com'}Explanation: The domain part is extracted from each email address, and duplicate domains are removed automatically.
Use Cases: Set Comprehension
Below are some common situations where Python set comprehension can be useful:
- Removing duplicate values from lists
- Filtering specific values from data
- Creating unique character sets from strings
- Generating number patterns
- Converting and cleaning text data
- Building unique datasets for analysis
Key Takeaways: Set Comprehension
Before wrapping up, here are the key points to remember about Python set comprehension:
- Python set comprehension always creates and returns a set.
- Duplicate values are removed automatically because sets only store unique elements.
- Curly braces {} are used to write set comprehension syntax.
- Conditions can be added to filter values while creating the set.
- The order of elements in a set is not fixed or guaranteed.
- Set comprehension helps create shorter, cleaner, and more readable Python code.