{"id":1003,"date":"2026-01-21T06:03:40","date_gmt":"2026-01-21T06:03:40","guid":{"rendered":"https:\/\/www.askpython.com\/?p=1003"},"modified":"2026-01-25T15:03:18","modified_gmt":"2026-01-25T15:03:18","slug":"python-set","status":"publish","type":"post","link":"https:\/\/www.askpython.com\/python\/set\/python-set","title":{"rendered":"Python Set – Things You MUST Know"},"content":{"rendered":"
\n# Create a set\nnumbers = {1, 2, 3, 4, 5}\nempty_set = set()  # Not {}, that's a dictionary\nunique_items = set([1, 2, 2, 3, 3, 4])  # {1, 2, 3, 4}\n\n<\/pre><\/div>\n\n\n
Sets are Python’s built-in data structure for storing unique, unordered collections. <\/p>\n\n\n\n
They automatically eliminate duplicates and provide fast membership testing. If you’ve ever needed to remove duplicate entries from a list or check whether something exists in a collection without iterating through every item, sets solve that problem.<\/p>\n\n\n\n
Creating and initializing Python sets<\/h2>\n\n\n\n
You can create Python sets in three ways. The curly brace syntax works for non-empty sets, while the set()<\/code> constructor handles empty sets and conversions from other iterables.<\/p>\n\n\n
\n# Direct creation\nfruits = {'apple', 'banana', 'cherry'}\n\n# From a list (duplicates removed automatically)\nnumbers = set([1, 2, 2, 3, 3, 3, 4])\nprint(numbers)  # {1, 2, 3, 4}\n\n# From a string (each character becomes an element)\nletters = set('hello')\nprint(letters)  # {'h', 'e', 'l', 'o'}\n\n# Empty set (careful here)\nempty = set()  # Correct\nnot_empty = {}  # This creates a dictionary, not a set\n\n<\/pre><\/div>\n\n\n
The gotcha that trips up newcomers is the empty set syntax. You can’t use {}<\/code> because Python reserves that for dictionaries. This makes sense once you know that sets came later to the language than dictionaries, so the bracket notation was already taken.<\/p>\n\n\n\n
Basic operations with Python sets that actually matter<\/h2>\n\n\n\n
Sets shine when you need to add, remove, or check for items. The operations are straightforward and perform better than equivalent list operations.<\/p>\n\n\n
\nanimals = {'cat', 'dog', 'bird'}\n\n# Adding items\nanimals.add('fish')\nprint(animals)  # {'cat', 'dog', 'bird', 'fish'}\n\n# Adding won't duplicate\nanimals.add('cat')\nprint(animals)  # Still {'cat', 'dog', 'bird', 'fish'}\n\n# Removing items (raises error if not found)\nanimals.remove('dog')\n\n# Safer removal (no error if missing)\nanimals.discard('elephant')  # Does nothing, no error\n\n# Remove and return arbitrary item\nrandom_animal = animals.pop()\n\n<\/pre><\/div>\n\n\n
The difference between remove()<\/code> and discard()<\/code> matters in production code. If you’re not certain an item exists, discard()<\/code> saves you from handling exceptions. I’ve seen codebases littered with try-except blocks around remove()<\/code> calls when discard()<\/code> would have been cleaner.<\/p>\n\n\n\n
Membership testing is why Python sets exist<\/h2>\n\n\n\n
This is where sets actually earn their keep. Checking if an item exists in a set is constant time, O(1), while lists require iterating through items, O(n).<\/p>\n\n\n
\n# Slow with lists\nitems_list = list(range(10000))\nprint(9999 in items_list)  # Has to check every item\n\n# Fast with sets\nitems_set = set(range(10000))\nprint(9999 in items_set)  # Direct lookup, instant\n\n<\/pre><\/div>\n\n\n
The performance difference isn’t academic. If you’re checking membership repeatedly in a loop, using a list instead of a set can turn a millisecond operation into minutes. I’ve optimized code from 30 seconds to under a second just by converting a membership check from a list to a set.<\/p>\n\n\n\n
Python set mathematics for practical problems<\/h2>\n\n\n\n
Sets implement mathematical operations that solve real problems. Union combines sets, intersection finds common elements, difference shows what’s unique to one set.<\/p>\n\n\n
\ndevelopers = {'Alice', 'Bob', 'Charlie'}\ndesigners = {'Bob', 'Diana', 'Eve'}\n\n# Union: everyone on both teams\nall_people = developers | designers\nprint(all_people)  # {'Alice', 'Bob', 'Charlie', 'Diana', 'Eve'}\n\n# Intersection: people on both teams\nboth_teams = developers & designers\nprint(both_teams)  # {'Bob'}\n\n# Difference: only developers\nonly_devs = developers - designers\nprint(only_devs)  # {'Alice', 'Charlie'}\n\n# Symmetric difference: people on exactly one team\none_team_only = developers ^ designers\nprint(one_team_only)  # {'Alice', 'Charlie', 'Diana', 'Eve'}\n\n<\/pre><\/div>\n\n\n
These operations have method equivalents that read more clearly in some contexts.<\/p>\n\n\n
\n# Method versions of the same operations\nall_people = developers.union(designers)\nboth_teams = developers.intersection(designers)\nonly_devs = developers.difference(designers)\none_team_only = developers.symmetric_difference(designers)\n\n<\/pre><\/div>\n\n\n
The method versions accept any iterable as an argument, not just sets. That flexibility helps when you’re working with mixed data types.<\/p>\n\n\n
\nnumbers = {1, 2, 3}\n# This works\nresult = numbers.union([4, 5, 6])\n# This doesn't\nresult = numbers | [4, 5, 6]  # TypeError\n\n<\/pre><\/div>\n\n\n
Practical use cases for Python sets that come up constantly<\/h2>\n\n\n\n
Sets solve specific problems better than any other data structure. Removing duplicates from user input, finding common elements between datasets, or tracking unique visitors all become simple with sets.<\/p>\n\n\n
\n# Remove duplicates from a list\nuser_ids = [101, 102, 101, 103, 102, 104]\nunique_ids = list(set(user_ids))\nprint(unique_ids)  # [101, 102, 103, 104]\n\n# Find common interests\nuser_a_interests = {'python', 'golang', 'rust', 'javascript'}\nuser_b_interests = {'python', 'java', 'javascript', 'c++'}\nshared_interests = user_a_interests & user_b_interests\nprint(shared_interests)  # {'python', 'javascript'}\n\n# Track unique visitors\nvisitors = set()\nvisitors.add('user_123')\nvisitors.add('user_456')\nvisitors.add('user_123')  # Duplicate, ignored\nprint(len(visitors))  # 2\n\n<\/pre><\/div>\n\n\n
One pattern I use constantly is filtering a large dataset based on a smaller set of valid identifiers. Converting the identifier list to a set makes the filtering operation dramatically faster.<\/p>\n\n\n
\n# Slow approach with lists\nvalid_ids = [1, 2, 3, 4, 5]\nrecords = [{'id': i, 'data': 'value'} for i in range(1000)]\nfiltered = [r for r in records if r['id'] in valid_ids]\n\n# Fast approach with sets\nvalid_ids_set = {1, 2, 3, 4, 5}\nrecords = [{'id': i, 'data': 'value'} for i in range(1000)]\nfiltered = [r for r in records if r['id'] in valid_ids_set]\n\n<\/pre><\/div>\n\n\n
Updating Python sets in place<\/h2>\n\n\n\n
Sets provide methods that modify the set directly rather than creating new ones. These operations are faster when you’re working with large datasets and don’t need to preserve the original.<\/p>\n\n\n
\ntags = {'python', 'programming'}\n\n# Add multiple items\ntags.update(['web', 'backend', 'api'])\nprint(tags)  # {'python', 'programming', 'web', 'backend', 'api'}\n\n# Intersection update (keep only common elements)\nallowed_tags = {'python', 'web', 'mobile'}\ntags.intersection_update(allowed_tags)\nprint(tags)  # {'python', 'web'}\n\n# Difference update (remove elements found in another set)\ntags = {'python', 'web', 'mobile', 'backend'}\ndeprecated = {'mobile', 'backend'}\ntags.difference_update(deprecated)\nprint(tags)  # {'python', 'web'}\n\n<\/pre><\/div>\n\n\n
The naming convention helps clarify what’s happening. Methods ending in _update<\/code> modify the set in place, while their counterparts without the suffix return new sets.<\/p>\n\n\n\n
Immutable Python sets with frozenset<\/h2>\n\n\n\n
Sometimes you need a set that can’t change. Frozen sets work as dictionary keys or elements in other sets, which regular sets can’t do because they’re mutable.<\/p>\n\n\n
\n# Create a frozen set\nimmutable = frozenset([1, 2, 3])\n\n# Can't modify it\n# immutable.add(4)  # AttributeError\n\n# Can use as dictionary key\ncache = {}\nkey = frozenset(['python', 'tutorial'])\ncache[key] = 'cached_result'\n\n# Can nest in other sets\nset_of_sets = {frozenset([1, 2]), frozenset([3, 4])}\nprint(set_of_sets)  # {frozenset({1, 2}), frozenset({3, 4})}\n\n<\/pre><\/div>\n\n\n
Frozen sets come up less often than regular sets, but they’re essential when you need hashable collections. Configuration data that shouldn’t change or building composite cache keys are the main use cases.<\/p>\n\n\n\n
Comprehensions for building Python sets<\/h2>\n\n\n\n
Set comprehensions follow the same syntax as list comprehensions but produce sets with automatic deduplication.<\/p>\n\n\n
\n# Create a set of squared numbers\nsquares = {x**2 for x in range(10)}\nprint(squares)  # {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}\n\n# Extract unique words from text\ntext = "the quick brown fox jumps over the lazy dog"\nunique_words = {word for word in text.split()}\nprint(unique_words)  # {'the', 'quick', 'brown', 'fox', 'jumps', 'over', 'lazy', 'dog'}\n\n# Filter and transform in one operation\nnumbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\neven_squares = {x**2 for x in numbers if x % 2 == 0}\nprint(even_squares)  # {4, 16, 36, 64, 100}\n\n<\/pre><\/div>\n\n\n
The deduplication happens automatically, which makes set comprehensions perfect for extracting unique transformed values from larger datasets.<\/p>\n\n\n\n
Performance characteristics that matter<\/h2>\n\n\n\n
Sets use hash tables internally, which gives them constant time operations for adding, removing, and checking membership. That’s the whole reason they exist. Lists can’t match that performance for these operations.<\/p>\n\n\n
\nimport time\n\n# Compare membership testing\nlarge_list = list(range(100000))\nlarge_set = set(range(100000))\n\n# Test with list\nstart = time.time()\nfor _ in range(1000):\n    99999 in large_list\nlist_time = time.time() - start\n\n# Test with set\nstart = time.time()\nfor _ in range(1000):\n    99999 in large_set\nset_time = time.time() - start\n\nprint(f"List: {list_time:.4f}s")\nprint(f"Set: {set_time:.4f}s")\n\n<\/pre><\/div>\n\n\n
The tradeoff is memory. Sets consume more memory per element than lists because of the hash table overhead. For small collections, the difference doesn’t matter. For millions of items, it adds up.<\/p>\n\n\n\n
When Python sets aren’t the answer<\/h2>\n\n\n\n
Sets lose ordering information. If you need to maintain the sequence of items, sets will frustrate you because they’re fundamentally unordered collections.<\/p>\n\n\n
\nnumbers = {5, 1, 3, 2, 4}\nprint(numbers)  # Order is unpredictable\n\n<\/pre><\/div>\n\n\n
Sets also only work with hashable types. You can’t store lists, dictionaries, or other sets as set elements because these types are mutable and therefore not hashable.<\/p>\n\n\n
\n# This fails\nbad_set = {[1, 2, 3]}  # TypeError: unhashable type: 'list'\n\n# This works\ngood_set = {(1, 2, 3)}  # Tuples are hashable\n\n<\/pre><\/div>\n\n\n
If you need both uniqueness and ordering, you have two options. Use a list and manually check for duplicates, or use Python 3.7+ dictionaries which maintain insertion order and can simulate sets through their keys.<\/p>\n\n\n
\n# Ordered unique collection\nordered_unique = list(dict.fromkeys([3, 1, 2, 1, 3, 2]))\nprint(ordered_unique)  # [3, 1, 2]\n\n<\/pre><\/div>\n\n\n
Sets are a specialized tool that excel at specific tasks. Understanding when to reach for them versus lists or dictionaries separates developers who write slow code from those who write fast code.<\/p>\n","protected":false},"excerpt":{"rendered":"
Sets are Python’s built-in data structure for storing unique, unordered collections. They automatically eliminate duplicates and provide fast membership testing. If you’ve ever needed to remove duplicate entries from a list or check whether something exists in a collection without iterating through every item, sets solve that problem. Creating and initializing Python sets You can […]<\/p>\n","protected":false},"author":6,"featured_media":65738,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[7],"tags":[478],"class_list":["post-1003","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-set","tag-python-set"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts\/1003","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/comments?post=1003"}],"version-history":[{"count":0,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts\/1003\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/media\/65738"}],"wp:attachment":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/media?parent=1003"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/categories?post=1003"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/tags?post=1003"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}