Python Set Exercises: 30 Coding Problems with Solutions

Solution:

fruits = {"apple", "banana", "cherry"}

fruits.add("mango")
print("After add:", fruits)

fruits.remove("banana")
print("After remove:", fruits)

fruits.discard("grape")
print("After discard (element not present):", fruits)Code language: Python (python)

Explanation:

• {"apple", "banana", "cherry"}: Creates a set literal with three string elements. Sets are unordered and store only unique values.
• .add("mango"): Inserts "mango" into the set. If the element already exists, the set remains unchanged.
• .remove("banana"): Deletes "banana" from the set. If the element is absent, Python raises a KeyError, so use this only when you are certain the element exists.
• .discard("grape"): Attempts to remove "grape", but since it is not in the set, the operation is silently ignored with no error raised. This makes discard() the safer choice for uncertain removals.

Solution:

colors = {"red", "green", "blue"}
print("Before clear:", colors)

colors.clear()
print("After clear:", colors)Code language: Python (python)

Explanation:

• colors.clear(): Removes every element from the set in place. The variable colors continues to exist and now points to an empty set object.
• set() in output: Python prints an empty set as set() rather than {} to avoid ambiguity with an empty dictionary, which also uses curly braces.
• Contrast with del: Writing del colors would remove the variable entirely from memory, making any further reference to it raise a NameError. .clear() keeps the variable alive but empties its contents.

Solution:

animals = {"cat", "dog", "bird", "fish"}

count = 0
for _ in animals:
    count += 1

print("Length of set:", count)Code language: Python (python)

Explanation:

• count = 0: Initializes the counter to zero before iteration begins, ensuring an accurate tally from the start.
• for _ in animals: Iterates over every element in the set. The underscore _ is a conventional placeholder variable name used when the element’s value itself is not needed inside the loop body.
• count += 1: Increments the counter by one on each iteration, effectively tallying the total number of elements visited.
• Note on len(): In practice, len(animals) achieves the same result in a single step. The manual loop here is purely for learning purposes and illustrates how element counting works under the hood.

Solution:

data = set()

if not data:
    print("The set is empty.")
else:
    print("The set is not empty.")Code language: Python (python)

Explanation:

• data = set(): Creates an empty set. Note that {} cannot be used here because Python interprets that as an empty dictionary.
• if not data: Python treats an empty set as falsy, so not data evaluates to True when the set has no elements. This is the most idiomatic way to check for emptiness in Python.
• Alternative check: if len(data) == 0 or if data == set() are also valid, but if not data is preferred for its clarity and conciseness.

Solution:

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

result = set_a.union(set_b)
print("Union:", result)Code language: Python (python)

Explanation:

• set_a.union(set_b): Returns a new set containing every element from both set_a and set_b. The original sets are not modified.
• Duplicate handling: Elements 3 and 4 appear in both sets but are stored only once in the result, because sets enforce uniqueness by definition.
• Operator shorthand: set_a | set_b is equivalent to set_a.union(set_b) and is often preferred for its brevity in expressions.
• Note on ordering: The printed output may appear in a different order each time you run it, since sets are unordered collections and do not guarantee element sequence.

Solution:

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

result = set_a.intersection(set_b)
print("Intersection:", result)Code language: Python (python)

Explanation:

• set_a.intersection(set_b): Returns a new set containing only those elements that appear in both set_a and set_b. Neither original set is changed.
• Result {3, 4}: These are the only values present in both sets. All other elements are exclusive to one set and are therefore excluded from the intersection.
• Operator shorthand: set_a & set_b produces the same output as set_a.intersection(set_b) and is more compact for use in expressions.
• Empty intersection: If two sets share no common elements, the result is set(). This is useful for detecting completely disjoint datasets.

Solution:

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

result = set_a.difference(set_b)
print("Difference (A - B):", result)Code language: Python (python)

Explanation:

• set_a.difference(set_b): Returns a new set with elements that are in set_a but absent from set_b. The original sets remain unmodified.
• Result {1, 2}: Elements 3 and 4 are excluded because they also appear in set_b. Only the values exclusive to set_a are returned.
• Operator shorthand: set_a - set_b is equivalent to set_a.difference(set_b) and reads naturally as a subtraction of one set from another.
• Order matters: set_b.difference(set_a) would return {5, 6} instead, since that operation finds what is unique to set_b. Unlike union and intersection, difference is not commutative.

Solution:

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

result = set_a.symmetric_difference(set_b)
print("Symmetric Difference:", result)Code language: Python (python)

Explanation:

• set_a.symmetric_difference(set_b): Returns a new set containing elements that belong to exactly one of the two sets. Elements shared by both are excluded from the result.
• Result {1, 2, 5, 6}: Values 3 and 4 appear in both sets and are therefore excluded. Only the elements exclusive to each set are retained.
• Operator shorthand: set_a ^ set_b is equivalent to set_a.symmetric_difference(set_b) and is concise for use in expressions.
• Commutative property: Unlike .difference(), symmetric difference is commutative. set_a ^ set_b and set_b ^ set_a always produce the same result.

Solution:

numbers = {42, 7, 19, 85, 3, 56}

print("Max:", max(numbers))
print("Min:", min(numbers))Code language: Python (python)

Explanation:

• max(numbers): Iterates through the set and returns the highest value found. It works on any iterable, including sets, lists, and tuples.
• min(numbers): Similarly iterates through the set and returns the lowest value. Both functions complete in a single pass over the data.
• No sorting required: Unlike finding the max or min manually, these built-ins do not sort the set. They scan each element once, making them efficient for large datasets.
• Unordered nature of sets: Even though sets have no guaranteed order, max() and min() still work correctly because they compare values rather than relying on position.

Solution:

numbers = {10, 20, 30, 40, 50}

total = 0
for num in numbers:
    total += num

print("Sum:", total)Code language: Python (python)

Explanation:

• total = 0: Sets the accumulator to zero before iteration begins, providing a clean starting point for the running total.
• for num in numbers: Iterates over each element in the set. Because sets are unordered, the elements may be visited in any sequence, but this does not affect the final sum.
• total += num: Adds the current element’s value to the running total on each iteration, gradually building up the cumulative sum.
• Alternative: sum(numbers) achieves the same result in a single call. The manual loop here is used deliberately to illustrate the underlying accumulation logic.

Solution:

fruits = {"apple", "banana"}
new_fruits = ["cherry", "mango", "apple"]

fruits.update(new_fruits)
print("Updated set:", fruits)Code language: Python (python)

Explanation:

• fruits.update(new_fruits): Iterates over every element in new_fruits and inserts each one into fruits in place. The original set is modified directly and no new set is created.
• Duplicate handling: "apple" already exists in fruits and also appears in new_fruits. The set silently ignores the duplicate and retains only one copy, preserving the uniqueness guarantee of sets.
• .update() vs .add(): .add() inserts a single element, while .update() unpacks an entire iterable and adds all its elements at once. Using .update() is cleaner and more efficient than looping with .add().
• In-place operation: .update() modifies the set directly and returns None. Assigning its result to a variable would store None, not the updated set.

Solution:

base = {1, 2}
from_list = [3, 4]
from_tuple = (5, 6)
from_set = {7, 8}

base.update(from_list, from_tuple, from_set)
print("Updated set:", base)Code language: Python (python)

Explanation:

• base.update(from_list, from_tuple, from_set): Accepts multiple iterables as separate arguments and unpacks each one in turn, inserting all their elements into base in a single operation.
• Mixed iterable types: .update() is type-agnostic. It processes lists, tuples, sets, strings, and any other iterable uniformly, making it highly versatile for merging data from varied sources.
• Single call efficiency: Passing all iterables in one .update() call is equivalent to calling .update() three times separately, but is more readable and slightly more efficient as it reduces method call overhead.
• In-place modification: Like all set mutation methods, .update() modifies base directly and returns None. The merged result lives in the original base variable.

Solution:

set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}

print("Is set_a a subset of set_b?", set_a.issubset(set_b))
print("Is set_b a superset of set_a?", set_b.issuperset(set_a))Code language: Python (python)

Explanation:

• set_a.issubset(set_b): Returns True if every element in set_a is also present in set_b. Here, {1, 2, 3} is fully contained within {1, 2, 3, 4, 5}, so the result is True.
• set_b.issuperset(set_a): Returns True if set_b contains all elements of set_a. This is the mirror operation of issubset() and will always yield the same boolean result when the sets are swapped.
• Operator equivalents: set_a <= set_b is equivalent to set_a.issubset(set_b), and set_b >= set_a is equivalent to set_b.issuperset(set_a). Use < and > for strict subset and superset checks, which return False when the sets are equal.
• Equal sets: If set_a == set_b, then set_a.issubset(set_b) still returns True because every element of a set is trivially contained within an identical set.

Solution:

set_a = {1, 2, 3}
set_b = {4, 5, 6}

print("Are the sets disjoint?", set_a.isdisjoint(set_b))

# Testing with overlapping sets
set_c = {3, 4, 5}
print("Are set_a and set_c disjoint?", set_a.isdisjoint(set_c))Code language: Python (python)

Explanation:

• set_a.isdisjoint(set_b): Returns True because set_a and set_b share no common elements. Internally, Python checks whether the intersection of the two sets is empty.
• set_a.isdisjoint(set_c): Returns False because set_c contains 3, which also exists in set_a. Even a single shared element is enough to make two sets non-disjoint.
• Efficiency: .isdisjoint() short-circuits as soon as it finds the first common element, making it faster than computing a full intersection when you only need a boolean answer.
• Relationship to intersection: set_a.isdisjoint(set_b) is logically equivalent to len(set_a.intersection(set_b)) == 0, but is more readable and more efficient since it avoids constructing the intermediate intersection set.

a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}

a.difference_update(b)

print("a =", a)Code language: Python (python)

Explanation:

• a.difference_update(b): Removes every element from a that is also present in b. Unlike a - b, which returns a new set, this method updates a directly.
• In-place modification: The original set a is changed. The method returns None, so avoid assigning its result to a variable.
• Elements in b but not in a: Values like 6 and 7 exist only in b and are simply ignored during the operation.

a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}

a.intersection_update(b)

print("a =", a)Code language: Python (python)

Explanation:

• a.intersection_update(b): Retains only the elements that are common to both a and b, discarding everything else from a.
• In-place modification: The set a is updated directly. This differs from a & b or a.intersection(b), both of which return a new set and leave a unchanged.
• Result: Only {3, 4, 5} survive because those are the values present in both sets. Elements 1 and 2 are removed from a, and 6 and 7 were never in a to begin with.

a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}

a.symmetric_difference_update(b)

print("a =", a)Code language: Python (python)

Explanation:

• a.symmetric_difference_update(b): Updates a to contain only elements that are in exactly one of the two sets. Shared elements (3, 4, 5) are removed, and elements unique to b (6, 7) are added.
• In-place modification: The set a is changed directly. The equivalent expression a ^= b produces the same result and is a more compact alternative.
• Symmetric nature: The operation is symmetric in outcome (the non-overlapping union), but the update always targets the set on which the method is called – in this case a.

items = {10, 20, 30, 40, 50, 60}
to_remove = {20, 40, 60}

items.difference_update(to_remove)

print("items =", items)Code language: Python (python)

Explanation:

• items.difference_update(to_remove): Removes all elements in to_remove from items in a single call. This is more concise and efficient than calling items.remove() individually for each value.
• No KeyError on missing values: If a value in to_remove is not present in items, it is silently skipped. This makes the operation safer than remove(), which raises a KeyError for missing elements.
• Accepts any iterable: The argument to difference_update() can be a set, list, or tuple – any iterable of hashable values will work.

s = {100, 200, 300}
popped = s.pop()
print("Popped:", popped)

s = set()
try:
    s.pop()
except KeyError as e:
    print("Error:", e)Code language: Python (python)

Explanation:

• s.pop(): Removes and returns an arbitrary element from the set. Because sets are unordered, there is no guarantee which element will be returned – do not rely on a specific value.
• try/except KeyError: When pop() is called on an empty set, Python raises a KeyError. Wrapping the call in a try block prevents the program from crashing and allows you to respond to the error gracefully.
• set() vs {}: An empty set must be created with set(). Using {} produces an empty dictionary, which is a common source of bugs when working with sets.

numbers = {1, 2, 3, 6, 7, 9, 12, 14, 15}

divisible_by_3 = {x for x in numbers if x % 3 == 0}

print("divisible_by_3 =", divisible_by_3)Code language: Python (python)

Explanation:

• {x for x in numbers if x % 3 == 0}: A set comprehension that iterates over every element in numbers and includes it in the result only if it passes the condition x % 3 == 0.
• x % 3 == 0: The modulo operator % returns the remainder after division. A remainder of zero confirms the number divides evenly by 3.
• Non-destructive: The original set numbers is not modified. The filtered result is stored in the new variable divisible_by_3.

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

common = set(list1) & set(list2)

print("common =", common)Code language: Python (python)

Explanation:

• set(list1) and set(list2): Converts each list into a set, which removes duplicate values and enables set operations. list1 becomes {1, 2, 3, 4, 5} and list2 becomes {3, 4, 5, 6, 7}.
• & operator: Performs a set intersection, returning a new set containing only the elements present in both sets. This is equivalent to calling set(list1).intersection(set(list2)).
• Efficiency advantage: Compared to a nested loop approach, set intersection runs in average O(min(n, m)) time, making it significantly faster for large lists.

text = "the cat sat on the mat the cat"

words = text.lower().split()
unique_words = set(words)

print("Unique word count:", len(unique_words))Code language: Python (python)

Explanation:

• text.lower(): Converts the entire string to lowercase so that words like "The" and "the" are treated as the same word during deduplication.
• .split(): Splits the string on whitespace and returns a list of individual word tokens. No separator argument is needed for standard space-separated text.
• set(words): Constructs a set from the list, which discards all duplicate entries. Only one instance of each unique word is retained.
• len(unique_words): Returns the number of elements in the set, which equals the number of distinct words. Here, "the" and "cat" each appear multiple times but are counted only once, giving a result of 5.

tags = {"python", "set", "programming", "tutorial"}

result = " | ".join(sorted(tags))

print(result)Code language: Python (python)

Explanation:

• " | ".join(...): The str.join() method takes an iterable and concatenates its elements into one string, placing the delimiter string between each pair. The delimiter itself does not appear at the start or end.
• sorted(tags): Converts the set into a sorted list before joining. Because sets are unordered, skipping this step would produce a different element sequence on each run, making the output unpredictable.
• Type requirement: join() requires all elements to be strings. If the set contained integers or other types, you would need " | ".join(str(x) for x in sorted(tags)) to convert each element first.

a = {1, 2, 3}
b = {1, 2, 3, 4, 5}
print("a is a proper subset of b:", a < b)
print("b is a proper superset of a:", b > a)
print("a is a proper subset of a:", a < a)Code language: Python (python)

Explanation:

• a < b: Returns True only if every element in a exists in b and b contains at least one element not in a. Both conditions must hold simultaneously.
• b > a: The mirror of a < b. Returns True if b strictly contains all of a and is larger. This is equivalent to b.issuperset(a) and b != a.
• a < a: Returns False because a set cannot be a proper subset of itself – the sets are equal, not strictly contained. Use a <= a (or a.issubset(a)) when you want to allow the equal case.

fs = frozenset([1, 2, 3, 4, 5])

print("frozenset:", fs)
print("Intersection with {3, 4, 5, 6}:", fs.intersection({3, 4, 5, 6}))

try:
    fs.add(6)
except AttributeError as e:
    print("Error:", e)Code language: Python (python)

Explanation:

• frozenset([1, 2, 3, 4, 5]): Constructs an immutable set from the given iterable. Like a regular set, it stores only unique, hashable elements – but once created, its contents can never change.
• fs.intersection({3, 4, 5, 6}): Non-mutating operations are fully supported. Methods like intersection(), union(), difference(), and issubset() all return new frozensets or booleans without touching the original.
• fs.add(6): Raises an AttributeError because frozenset does not implement mutation methods such as add, remove, or discard. The error message reads: 'frozenset' object has no attribute 'add'.
• Use as a dictionary key: Because frozensets are hashable, you can use them as dictionary keys or store them inside regular sets – something a mutable set cannot do.

squares_of_evens = {x**2 for x in range(1, 21) if x % 2 == 0}

print(squares_of_evens)Code language: Python (python)

Explanation:

• {x**2 for x in range(1, 21) if x % 2 == 0}: A set comprehension with three parts: the expression x**2 defines what goes into the set, for x in range(1, 21) iterates from 1 to 20, and if x % 2 == 0 restricts processing to even numbers.
• Automatic deduplication: If the expression could produce repeated values (for example, squaring both -2 and 2), the set would silently keep only one copy. This is a key advantage of set comprehensions over list comprehensions when uniqueness matters.
• Unordered output: The printed result may not appear in ascending order. If sorted output is needed, wrap the set in sorted(): print(sorted(squares_of_evens)).

items = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

seen = set()
result = []
for item in items:
    if item not in seen:
        result.append(item)
        seen.add(item)

print(result)Code language: Python (python)

Explanation:

• seen = set(): Acts as a fast lookup table. Checking membership with in on a set is O(1) on average, compared to O(n) for a list. This makes the algorithm efficient even as the input grows.
• if item not in seen: The first time an item is encountered, this condition is True and the item is appended to result. On all subsequent appearances, the item is already in seen and is skipped.
• Order is preserved: Unlike list(set(items)), which discards insertion order, this approach guarantees that elements appear in the result in the same order as their first occurrence in the input.

A = {1, 2, 3, 4, 5, 6, 7, 8}
B = {2, 4, 6}
C = {5, 7, 9}

result = A.difference(B, C)

print("Result:", result)Code language: Python (python)

Explanation:

• A.difference(B, C): Returns a new set containing every element of A that does not appear in B or in C. Passing multiple arguments to difference() is equivalent to subtracting all of them at once and is more readable than chaining - operators.
• Elements in C not in A: The value 9 is in C but not in A. It has no effect on the result because the operation only removes elements that exist in A.
• Equivalent expressions: A - B - C and A - (B | C) both produce the same result. The difference() method form is preferred when subtracting more than two sets, as it reads more clearly and avoids intermediate set creation.

coords = {(1, 2), (3, 4), (5, 6)}
print("Set of tuples:", coords)

try:
    bad_set = {[1, 2], [3, 4]}
except TypeError as e:
    print("Error:", e)Code language: Python (python)

Explanation:

• Hashability requirement: Python sets use a hash table internally. Every element must have a stable hash value, computed once and used to determine its storage slot. An object is hashable if it implements __hash__() and __eq__(), and if its hash cannot change over its lifetime.
• Tuples are hashable: Because tuples are immutable, their contents can never change after creation. Python can safely compute and store a hash for them, making tuples valid set elements and valid dictionary keys.
• Lists are not hashable: Lists are mutable – you can append, remove, or change elements at any time. If a list were stored in a set and then mutated, its hash would change and the set would no longer be able to find it. Python prevents this entirely by making lists unhashable, raising a TypeError on any attempt to hash them.

original = {1, 2, 3, 4, 5}

# Assignment: both names point to the same set object
ref = original
ref.add(99)
print("--- Assignment (=) ---")
print("original:", original)
print("ref:", ref)

# Reset
original = {1, 2, 3, 4, 5}

# Shallow copy: independent object
copied = original.copy()
copied.add(42)
print("\n--- Shallow copy (.copy()) ---")
print("original:", original)
print("copied:", copied)Code language: Python (python)

Explanation:

• ref = original: This does not create a new set. Both ref and original are names that refer to the exact same object in memory. Any mutation through one name is immediately visible through the other.
• original.copy(): Creates a new, independent set object that starts with the same elements. Mutations to copied do not affect original, and mutations to original do not affect copied.
• Why “shallow”: For a set of immutable elements (numbers, strings, tuples), shallow copy is sufficient. If the set contained mutable objects (which sets cannot, by the hashability rule), a shallow copy would still share those inner objects. For sets specifically, .copy() is always safe because all valid set elements are immutable.

import time

large_list = list(range(1_000_000))
large_set = set(range(1_000_000))
target = 999999

start = time.time()
result = target in large_list
list_time = time.time() - start

start = time.time()
result = target in large_set
set_time = time.time() - start

print(f"List lookup time:  {list_time:.6f} seconds")
print(f"Set lookup time:   {set_time:.6f} seconds")Code language: Python (python)

Explanation:

• List membership – O(n): The in operator on a list performs a linear scan from the first element to the last. In the worst case (the target is at the end or absent), Python checks every element. For a list of 1,000,000 items, this means up to 1,000,000 comparisons.
• Set membership – O(1) average: The in operator on a set computes the hash of the target and looks up the corresponding slot in the hash table directly. Regardless of how many elements the set contains, this typically completes in one or two steps.
• Practical implication: If you need to perform many membership tests against a fixed collection, convert the collection to a set once upfront. The one-time conversion cost of set(large_list) is quickly recovered when each subsequent lookup is thousands of times faster than the list equivalent.