Why sets are used in Python

Introduction

Sets are used to store unique items and to quickly check if something is in a group. They help remove duplicates and make some tasks faster.

When you want to remove duplicate items from a list of things.

When you need to check if an item exists in a collection quickly.

When you want to find common items between two groups.

When you want to combine two groups but keep only unique items.

When you want to find items that are in one group but not in another.

Syntax

Python

my_set = {item1, item2, item3}
# or
my_set = set([item1, item2, item3])

Sets use curly braces {} or the set() function to create.

Items in a set are unique and unordered.

Examples

Create a set of fruits with unique names.

Python

fruits = {'apple', 'banana', 'orange'}

Creates a set from a list with duplicates; duplicates are removed.

Python

numbers = set([1, 2, 2, 3, 4])
print(numbers)

Finds common items between two sets using & operator.

Python

a = {1, 2, 3}
b = {2, 3, 4}
common = a & b
print(common)

Sample Program

This program shows how sets remove duplicates, check membership, and perform union, intersection, and difference operations.

Python

items = ['apple', 'banana', 'apple', 'orange', 'banana']
unique_items = set(items)
print('Unique items:', unique_items)

if 'apple' in unique_items:
    print('Apple is in the set')

set_a = {1, 2, 3}
set_b = {3, 4, 5}
print('Union:', set_a | set_b)
print('Intersection:', set_a & set_b)
print('Difference:', set_a - set_b)

Important Notes

Sets do not keep the order of items like lists do.

You cannot have mutable items like lists inside a set.

Sets are very fast for checking if an item exists.

Summary

Sets store unique items only.

They help remove duplicates easily.

Sets support fast membership tests and set operations like union and intersection.

Practice

1. Which of the following is the main reason to use a set in Python?

easy

A. To store unique items without duplicates

B. To keep items in a specific order

C. To allow duplicate values

D. To store key-value pairs

Solution

1. Step 1: Understand the purpose of sets

   Sets automatically remove duplicate items, so they only keep unique elements.

2. Step 2: Compare with other data types

   Lists allow duplicates and keep order, dictionaries store key-value pairs, so they don't fit the main use of sets.

3. Final Answer:

   To store unique items without duplicates -> Option A

4. Quick Check:

   Sets = Unique items [OK]

Hint: Sets always keep unique items, no duplicates allowed [OK]

Common Mistakes:

• Thinking sets keep order
• Confusing sets with lists or dictionaries
• Assuming sets allow duplicates

2. Which of the following is the correct way to create a set in Python?

easy

A. my_set = {1, 2, 3}

B. my_set = [1, 2, 3]

C. my_set = (1, 2, 3)

D. my_set = {'a': 1, 'b': 2}

Solution

1. Step 1: Recall set syntax

   Sets are created using curly braces with comma-separated values, like {1, 2, 3}.

2. Step 2: Identify other data types

   Square brackets create lists, parentheses create tuples, and curly braces with key-value pairs create dictionaries.

3. Final Answer:

   my_set = {1, 2, 3} -> Option A

4. Quick Check:

   Curly braces with values = set [OK]

Hint: Use curly braces with values to create sets [OK]

Common Mistakes:

• Using square brackets instead of curly braces
• Confusing sets with dictionaries
• Using parentheses which create tuples

3. What will be the output of the following code?

my_list = [1, 2, 2, 3, 4, 4, 4]
my_set = set(my_list)
print(my_set)

medium

A. {1, 2, 2, 3, 4, 4, 4}

B. [1, 2, 2, 3, 4, 4, 4]

C. {1, 2, 3, 4}

D. (1, 2, 3, 4)

Solution

1. Step 1: Convert list to set

   Using <code>set()</> on a list removes duplicates, so repeated numbers appear only once.

2. Step 2: Understand set output format

   Printing a set shows unique values inside curly braces without duplicates.

3. Final Answer:

   {1, 2, 3, 4} -> Option C

4. Quick Check:

   set(list with duplicates) = unique values [OK]

Hint: set() removes duplicates from any list or iterable [OK]

Common Mistakes:

• Expecting list output instead of set
• Thinking duplicates remain in set
• Confusing set with tuple or list syntax

4. Find the error in this code that tries to create a set with duplicate values:

my_set = {1, 2, 2, 3}
print(my_set)

medium

A. You must convert the set to a list before printing

B. Sets cannot have duplicate values, so this code will cause an error

C. The syntax for creating a set is wrong

D. The code is correct; duplicates are automatically removed

Solution

1. Step 1: Check set behavior with duplicates

   Sets automatically remove duplicates, so writing duplicates in the set literal is allowed but duplicates are ignored.

2. Step 2: Verify syntax and output

   The syntax is correct and printing the set will show unique values only.

3. Final Answer:

   The code is correct; duplicates are automatically removed -> Option D

4. Quick Check:

   Duplicates ignored in sets = code runs fine [OK]

Hint: Duplicates in set literals are ignored, no error occurs [OK]

Common Mistakes:

• Thinking duplicates cause errors in sets
• Believing set syntax is wrong with duplicates
• Trying to convert set to list unnecessarily

5. You have two lists:

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

How can you find the common elements between these lists efficiently using sets?

hard

A. Use list1 + list2 to combine and then remove duplicates

B. Use set(list1) & set(list2) to get the intersection

C. Use a for loop to check each element manually

D. Use set(list1) | set(list2) to get the union

Solution

1. Step 1: Convert lists to sets

   Convert both lists to sets to use set operations like intersection.

2. Step 2: Use intersection operator

   The & operator on sets returns elements common to both sets.

3. Final Answer:

   Use set(list1) & set(list2) to get the intersection -> Option B

4. Quick Check:

   Set intersection = common elements [OK]

Hint: Use & operator on sets to find common items fast [OK]

Common Mistakes:

• Using + operator which concatenates lists
• Using union instead of intersection
• Manually looping instead of using sets