Sets in Python - Interview Questions and Answers

You can create a set using curly braces or the set() function:

my_set = {1, 2, 3}
another_set = set([4, 5, 6])

Lists are ordered and allow duplicates, while sets are unordered and only allow unique elements.

Use the add() method to add a single element:

my_set.add(4)

You can use remove(), discard(), or pop() methods.

my_set.remove(2)  # raises KeyError if element not found
my_set.discard(2)  # does nothing if element not found
my_set.pop()       # removes and returns a random element

The set will ignore the duplicate and remain unchanged, as sets do not allow duplicates.

No, a set cannot contain mutable elements like lists or dictionaries because they are not hashable.

Use the clear() method

my_set.clear()

Use the in keyword:

3 in my_set  # returns True if 3 is in the set

Use the len() function

len(my_set)

remove() raises a KeyError if the element is not found, while discard() does nothing in that case.

Use the union() method or the | operator:

set1.union(set2)
set1 | set2

Use the intersection() method or the & operator:

set1.intersection(set2)
set1 & set2

Use the difference() method or the - operator:

set1.difference(set2)
set1 - set2

The symmetric difference returns elements that are in either set, but not in both. Use the symmetric_difference() method or the ^ operator:

set1.symmetric_difference(set2)
set1 ^ set2

Use the issubset() method or the <= operator:

set1.issubset(set2)
set1 <= set2

Use the issuperset() method or the >= operator:

set1.issuperset(set2)
set1 >= set2

Use the isdisjoint() method:

set1.isdisjoint(set2)

Sets provide faster membership testing (O(1) average time complexity), eliminate duplicates automatically, and are unordered.

You can iterate over a set using a for loop:

for element in my_set:
    print(element)

A frozenset is an immutable version of a set. It cannot be changed after it is created (no elements can be added or removed).

frozen = frozenset([1, 2, 3])

Yes, frozensets are hashable and can be used as dictionary keys, whereas regular sets cannot.

You can convert a string into a set, which will store only unique characters:

my_set = set("hello")  # {'h', 'e', 'l', 'o'}

Both adding and removing an element from a set generally have O(1) time complexity.

Checking membership in a set is O(1) on average, due to the underlying hash table implementation.

Simply pass the list to the set() constructor:

my_set = set([1, 2, 2, 3, 4])  # {1, 2, 3, 4}

It will raise a TypeError because mutable objects are not hashable and cannot be added to a set.

It removes duplicates and converts the iterable into a set.

You can use the methods or operators like union(), intersection(), difference(), and symmetric_difference() on multiple sets.

Use the list() constructor:

my_list = list(my_set)

The result will always be an empty set:

{} & {1, 2}  # returns set()

You can use the sorted() function:

sorted_list = sorted(my_set)

Use the union() method or the | operator to combine multiple sets:

set1 | set2 | set3
set1.union(set2, set3)

Yes, frozensets support set operations just like regular sets.

Use the equality operator ==

set1 == set2  # returns True if both sets are equal

No, a set does not have key-value pairs, so it cannot be directly converted to a dictionary. However, you can use a set to create a dictionary with some transformation.

onvert both lists to sets and then find the union or difference:

unique_elements = set(list1) | set(list2)

Use the len() function

len(my_set)

A frozenset is immutable, so you cannot modify its elements after creation, whereas a set is mutable.

Use the difference() method or the - operator:

set1.difference(set2)
set1 - set2

It raises a KeyError because there are no elements to remove.

By definition, sets automatically discard duplicates when elements are added.

Operations like union or intersection with an empty set usually result in the other set, while operations like difference will result in the original set.

ou can use the equality operator == or the issubset() method combined with issuperset():

set1 == set2

A set is an unordered collection of unique elements, while a dictionary is a collection of key-value pairs.

No, sets cannot contain other sets because sets are mutable and not hashable.

Hashable types are immutable types like strings, integers, and frozensets, which can be used as keys in dictionaries or elements in sets.

Simply use the union() method or the | operator:

merged_set = set1 | set2

add() adds a single element, while update() adds multiple elements from another set or iterable.

Yes, sets support mathematical operations such as union, intersection, difference, and symmetric difference.