Python Sets: Complete Guide for Beginners

In the previous section, you learned the differences between Python lists and tuples and when each data structure should be used. Python also provides another powerful collection data type called a set. Unlike lists and tuples, sets are designed to store only unique values and automatically remove duplicate elements.

Sets are widely used in data analysis, database applications, web development, machine learning, and cybersecurity because they provide fast searching and efficient mathematical operations such as union, intersection, and difference.

In this lesson, you will learn what Python sets are, why they are useful, how to create them, understand their characteristics, and explore practical examples that demonstrate their real-world applications.

Learning Objectives

After completing this lesson, you will be able to:

• Understand Python sets.
• Create sets using different approaches.
• Identify the characteristics of sets.
• Differentiate between an empty set and an empty dictionary.
• Understand how duplicate values are handled.
• Apply sets in real-world programs.
• Avoid common beginner mistakes.

Understanding Python Sets

A set is an unordered collection of unique elements. Unlike lists and tuples, sets do not maintain the insertion order of elements and do not allow duplicate values.

Sets are mutable, which means elements can be added or removed after creation. However, individual elements inside a set must be immutable, such as numbers, strings, or tuples.

Why Use Sets?

Sets are useful when you need to store unique values or perform mathematical operations on collections of data.

Common uses of sets include:

• Removing duplicate values.
• Checking membership quickly.
• Comparing collections of data.
• Finding common elements.
• Finding unique elements.
• Performing union and intersection operations.

Characteristics of Sets

• Sets store only unique values.
• Duplicate elements are automatically removed.
• Sets are unordered collections.
• Sets are mutable.
• Set elements cannot be accessed using indexes.
• Sets can contain different immutable data types.

Creating Python Sets

Sets are created using curly braces {} or the set() function.

Creating a Set Using Curly Braces

fruits = {
    "Apple",
    "Banana",
    "Orange"
}

print(fruits)

Output

{'Apple', 'Banana', 'Orange'}

Python creates a set containing three unique values.

Creating a Set Using the set() Function

numbers = set([
    10,
    20,
    30,
    40
])

print(numbers)

Output

{10, 20, 30, 40}

The set() function converts another iterable into a set.

Duplicate Values are Removed Automatically

If duplicate values are provided, Python keeps only one copy.

marks = {
    85,
    90,
    85,
    95,
    90
}

print(marks)

Output

{85, 90, 95}

The duplicate values are automatically removed.

Creating an Empty Set

To create an empty set, use the set() function.

students = set()

print(type(students))

Output

<class 'set'>

Empty Set vs Empty Dictionary

Many beginners mistakenly believe that empty curly braces create an empty set.

data = {}

print(type(data))

Output

<class 'dict'>

Empty curly braces create a dictionary, not a set.

To create an empty set, always use:

data = set()

Real-World Examples

Example 1: Removing Duplicate Student Names

students = {
    "Rahul",
    "Priya",
    "Rahul",
    "Amit",
    "Priya"
}

print(students)

Output

{'Rahul', 'Priya', 'Amit'}

Duplicate student names are removed automatically.

Example 2: Unique Programming Languages

languages = set([
    "Python",
    "SQL",
    "Python",
    "Power BI",
    "SQL"
])

print(languages)

Output

{'Python', 'SQL', 'Power BI'}

The set stores only unique programming languages.

Execution Flow

Consider the following program.

numbers = {
    10,
    20,
    20,
    30
}

print(numbers)

Execution Steps

1. Python reads all four values.
2. A set object is created.
3. Duplicate values are identified automatically.
4. Only unique elements are stored.
5. The resulting set is displayed.

Output

{10, 20, 30}

Common Beginner Mistakes

• Using {} to create an empty set.
• Expecting duplicate values to remain in a set.
• Trying to access set elements using indexes.
• Assuming sets preserve insertion order.
• Trying to store mutable objects such as lists inside a set.

Chunk Summary

In this section, you learned what Python sets are, why they are useful, their characteristics, and how to create them using curly braces and the set() function. You also learned the difference between an empty set and an empty dictionary, explored practical examples, execution flow, and common beginner mistakes. In the next section, you will learn how to access, add, remove, and update set elements, iterate through sets, check membership, and apply these operations in real-world Python programs.

In the previous section, you learned what Python sets are, their characteristics, and how to create them. Since sets are mutable, you can add new elements, remove existing elements, update multiple values at once, and check whether a value exists in a set. Although sets do not support indexing, Python provides several simple methods for managing set data efficiently.

In this section, you will learn how to access set elements, add and remove values, update sets, iterate through sets, check membership, and apply these operations in practical Python programs.

Working with Set Elements

Unlike lists and tuples, sets are unordered collections. This means you cannot access elements using indexes. Instead, you work with sets by iterating through them or checking whether specific values exist.

Looping Through a Set

The most common way to access set elements is by using a for loop.

fruits = {
    "Apple",
    "Banana",
    "Orange"
}

for fruit in fruits:
    print(fruit)

Sample Output

Apple
Orange
Banana

The order may vary because sets are unordered.

Checking Membership

The in operator checks whether a value exists in a set.

languages = {
    "Python",
    "SQL",
    "Power BI"
}

print("Python" in languages)

print("Java" in languages)

Output

True
False

Membership testing is one of the fastest operations performed by sets.

Adding and Removing Elements

Python provides several methods to modify sets by adding, removing, or updating elements.

Adding a Single Element

The add() method inserts one new element into a set.

courses = {
    "Python",
    "SQL"
}

courses.add("Power BI")

print(courses)

Output

{'Python', 'SQL', 'Power BI'}

If the value already exists, nothing changes.

Adding Multiple Elements

The update() method adds multiple elements from another iterable.

courses = {
    "Python",
    "SQL"
}

courses.update([
    "Power BI",
    "Tableau"
])

print(courses)

Output

{'Python', 'SQL', 'Power BI', 'Tableau'}

Removing an Element Using remove()

The remove() method deletes a specified element.

cities = {
    "Delhi",
    "Mumbai",
    "Chennai"
}

cities.remove("Mumbai")

print(cities)

Output

{'Delhi', 'Chennai'}

If the value does not exist, Python raises a KeyError.

Removing an Element Using discard()

The discard() method removes an element without raising an error if the value is missing.

cities = {
    "Delhi",
    "Mumbai",
    "Chennai"
}

cities.discard("Kolkata")

print(cities)

Output

{'Delhi', 'Mumbai', 'Chennai'}

This method is safer when you are unsure whether the value exists.

Removing a Random Element

The pop() method removes and returns an arbitrary element.

colors = {
    "Red",
    "Green",
    "Blue"
}

removed = colors.pop()

print(removed)

print(colors)

Sample Output

Green

{'Red', 'Blue'}

The removed element may vary because sets are unordered.

Clearing a Set

The clear() method removes all elements from a set.

numbers = {
    10,
    20,
    30
}

numbers.clear()

print(numbers)

Output

set()

Practical Examples

Example 1: Student Enrollment

students = {
    "Rahul",
    "Priya"
}

students.add("Amit")

print(students)

Output

{'Rahul', 'Priya', 'Amit'}

Example 2: Course Management

courses = {
    "Python",
    "SQL"
}

courses.update([
    "Power BI",
    "Excel"
])

print(courses)

Output

{'Python', 'SQL', 'Power BI', 'Excel'}

Example 3: Product Availability

products = {
    "Laptop",
    "Mouse",
    "Keyboard"
}

if "Mouse" in products:
    print("Product Available")
else:
    print("Product Not Available")

Output

Product Available

Execution Flow

Consider the following program.

languages = {
    "Python",
    "SQL"
}

languages.add("Power BI")

print(languages)

Execution Steps

1. Python creates a set containing two elements.
2. The add() method receives the value "Power BI".
3. Python checks whether the value already exists.
4. The new value is inserted into the set.
5. The updated set is displayed.

Output

{'Python', 'SQL', 'Power BI'}

Common Beginner Mistakes

• Trying to access set elements using indexes.
• Expecting elements to appear in the order they were added.
• Using remove() without checking whether the value exists.
• Assuming pop() removes the last inserted element.
• Adding mutable objects such as lists to a set.

Chunk Summary

In this section, you learned how to work with Python sets by looping through elements, checking membership, adding values using add() and update(), removing elements with remove(), discard(), and pop(), and clearing an entire set. You also explored practical examples, execution flow, and common beginner mistakes. In the next section, you will learn powerful mathematical set operations such as union(), intersection(), difference(), and symmetric_difference(), along with their practical applications.

In the previous section, you learned how to create sets, add and remove elements, update sets, and check membership. One of the biggest advantages of Python sets is their ability to perform mathematical set operations. These operations allow you to compare collections of data, find common elements, remove duplicates, and identify differences efficiently.

Set operations are widely used in data analysis, database management, recommendation systems, machine learning, and cybersecurity because they make comparing large datasets fast and simple.

Set Operations

Python provides several built-in methods for performing mathematical operations on sets. The four most commonly used operations are:

• Union
• Intersection
• Difference
• Symmetric Difference

Union

The union() method combines all unique elements from two or more sets.

Syntax

set1.union(set2)

Example

python_students = {
    "Rahul",
    "Priya",
    "Amit"
}

sql_students = {
    "Priya",
    "Neha",
    "Rohit"
}

all_students = python_students.union(sql_students)

print(all_students)

Sample Output

{'Rahul', 'Priya', 'Amit', 'Neha', 'Rohit'}

Duplicate values appear only once in the resulting set.

Intersection

The intersection() method returns only the elements that exist in both sets.

python_students = {
    "Rahul",
    "Priya",
    "Amit"
}

sql_students = {
    "Priya",
    "Amit",
    "Rohit"
}

common_students = python_students.intersection(sql_students)

print(common_students)

Output

{'Priya', 'Amit'}

This operation is useful for finding common records.

Difference

The difference() method returns the elements that exist in the first set but not in the second set.

python_students = {
    "Rahul",
    "Priya",
    "Amit"
}

sql_students = {
    "Priya",
    "Rohit"
}

remaining = python_students.difference(sql_students)

print(remaining)

Output

{'Rahul', 'Amit'}

The matching values are removed from the result.

Symmetric Difference

The symmetric_difference() method returns elements that are present in either set but not in both.

set1 = {
    10,
    20,
    30
}

set2 = {
    20,
    30,
    40
}

result = set1.symmetric_difference(set2)

print(result)

Output

{10, 40}

Common elements are excluded from the result.

Practical Applications

Example 1: Students Enrolled in Any Course

python_students = {
    "Rahul",
    "Priya",
    "Amit"
}

powerbi_students = {
    "Neha",
    "Priya",
    "Vikas"
}

print(python_students.union(powerbi_students))

Sample Output

{'Rahul', 'Priya', 'Amit', 'Neha', 'Vikas'}

Example 2: Students Enrolled in Both Courses

python_students = {
    "Rahul",
    "Priya",
    "Amit"
}

sql_students = {
    "Priya",
    "Amit",
    "Rohit"
}

print(python_students.intersection(sql_students))

Output

{'Priya', 'Amit'}

Example 3: Finding Unique Customers

today_customers = {
    "Rahul",
    "Priya",
    "Amit"
}

yesterday_customers = {
    "Priya",
    "Neha"
}

print(today_customers.difference(yesterday_customers))

Output

{'Rahul', 'Amit'}

Example 4: Comparing Survey Responses

survey_a = {
    "Python",
    "SQL",
    "Excel"
}

survey_b = {
    "SQL",
    "Power BI",
    "Excel"
}

print(survey_a.symmetric_difference(survey_b))

Output

{'Python', 'Power BI'}

Best Practices and Performance Tips

Best Practices

• Use union() to combine unique records.
• Use intersection() to identify common values.
• Use difference() to find missing or exclusive records.
• Use symmetric_difference() to compare two datasets.
• Use descriptive variable names to improve readability.

Performance Tips

• Use sets instead of lists for frequent membership checks.
• Avoid converting between lists and sets repeatedly.
• Use set operations when comparing large datasets.
• Store only immutable values inside sets.

Execution Flow

Consider the following program.

set1 = {
    10,
    20,
    30
}

set2 = {
    20,
    40
}

result = set1.intersection(set2)

print(result)

Execution Steps

1. Python creates two sets.
2. The intersection() method compares both sets.
3. Only common elements are identified.
4. A new set containing the common values is created.
5. The resulting set is displayed.

Output

{20}

Common Beginner Mistakes

• Confusing union() with intersection().
• Expecting difference() to compare both sets automatically.
• Assuming set operations modify the original sets.
• Trying to perform set operations on lists without converting them to sets.
• Expecting duplicate values in the result of a set operation.

Chunk Summary

In this section, you learned the four most important set operations: union(), intersection(), difference(), and symmetric_difference(). You explored practical applications, best practices, performance tips, execution flow, and common beginner mistakes. In the final section, you will review the complete lesson with a lesson summary, key takeaways, FAQs, coding exercises, interview questions, a mini project, and a preview of the next lesson on Python Set Methods: Complete Guide for Beginners.

Lesson Summary

In this lesson, you learned the fundamentals of Python sets and discovered how they differ from other collection data types such as lists and tuples. A set is an unordered, mutable collection that stores only unique values, making it ideal for removing duplicates and performing mathematical set operations.

You began by understanding what sets are, their characteristics, and how to create them using curly braces and the set() function. You also learned the important difference between an empty set and an empty dictionary.

Next, you explored how to work with set elements by adding, updating, removing, and checking membership. Since sets do not support indexing, you learned how to iterate through them using loops.

Finally, you learned the four most important mathematical set operations: union(), intersection(), difference(), and symmetric_difference(). These operations are widely used in data analysis, database management, cybersecurity, and machine learning to compare collections of unique data efficiently.

Python sets provide excellent performance for membership testing and duplicate removal, making them one of the most useful data structures in Python programming.

Key Takeaways

• A set is an unordered collection of unique elements.
• Duplicate values are removed automatically.
• Sets are mutable, but their elements must be immutable.
• Sets do not support indexing or slicing.
• Use set() to create an empty set.
• Use add() to insert a single element.
• Use update() to add multiple elements.
• Use remove() or discard() to delete elements.
• Use the in operator for fast membership testing.
• Python supports union(), intersection(), difference(), and symmetric_difference() for mathematical set operations.

Frequently Asked Questions (FAQs)

1. What is a Python set?

A Python set is an unordered collection of unique elements.

2. Can a set contain duplicate values?

No. Duplicate values are automatically removed.

3. Are Python sets ordered?

No. Sets are unordered collections.

4. Can set elements be accessed using indexes?

No. Sets do not support indexing or slicing.

5. How do you create an empty set?

Use the set() function.

6. What is the difference between remove() and discard()?

remove() raises a KeyError if the element does not exist, whereas discard() does nothing.

7. What does the union() method do?

It combines all unique elements from two or more sets.

8. What does the intersection() method return?

It returns only the elements common to both sets.

9. Why are sets faster for membership testing?

Sets use hash-based storage, making membership checks very efficient.

10. When should sets be used?

Use sets when working with unique values, removing duplicates, or performing mathematical set operations.

Coding Exercises

1. Create a set containing five programming languages.
2. Create a set with duplicate values and observe the result.
3. Create an empty set using the set() function.
4. Add a new element using add().
5. Add multiple elements using update().
6. Remove an element using remove() and discard().
7. Use the in operator to check whether an element exists.
8. Find the union of two sets.
9. Find the intersection of two sets.
10. Find the difference and symmetric difference between two sets.

Interview Questions

1. What is a Python set?
2. How is a set different from a list?
3. Why are duplicate values removed automatically in a set?
4. How do you create an empty set?
5. Explain the difference between remove() and discard().
6. Why do sets not support indexing?
7. What is the purpose of the union() method?
8. Explain the difference between intersection() and difference().
9. Why are sets commonly used for membership testing?
10. Give two real-world applications of Python sets.

Mini Project: Student Course Enrollment Using Sets

Create a Python program that manages student enrollments using sets.

Your program should:

• Create two sets representing students enrolled in Python and SQL courses.
• Display all unique students using union().
• Display students enrolled in both courses using intersection().
• Display students enrolled only in the Python course using difference().
• Display students enrolled in only one course using symmetric_difference().
• Allow a new student to be added using add().

Sample Output

========== STUDENT COURSE ENROLLMENT ==========

Python Students

{'Rahul', 'Priya', 'Amit'}

SQL Students

{'Priya', 'Neha', 'Rohit'}

All Students

{'Rahul', 'Priya', 'Amit', 'Neha', 'Rohit'}

Students in Both Courses

{'Priya'}

Only Python Students

{'Rahul', 'Amit'}

Students in Only One Course

{'Rahul', 'Amit', 'Neha', 'Rohit'}

==============================================

What’s Next?

Congratulations! You have successfully learned the fundamentals of Python Sets. You now understand how to create sets, manage unique values, perform membership testing, modify sets, and use powerful mathematical operations to compare collections of data.

In the next lesson, you will learn Python Set Methods: Complete Guide for Beginners. You will explore every important built-in set method, including copy(), clear(), pop(), issubset(), issuperset(), isdisjoint(), update(), and many more with practical examples and real-world applications.