1. Home

Python Tutorials - Elevate Your Coding Skills with Comprehensive Tutorials

Discover Python tutorials covering everything from the basics to advanced topics. Whether you're new to programming or looking to level up your skills, our tutorials will guide you every step of the way

• 201 Lessons
• 33 Hours
29

# Set in Python

Updated on 19/07/20242,697 Views

## Introduction

Python is known for its flexibility and popularity, offering various tools to simplify coding. Among these tools, sets are useful for managing groups of items. We will detail sets in Python, looking at their characteristics, construction, manipulation, and numerous operations. Starting with the basics and progressing to advanced concepts, we'll cover creating sets, manipulating them, and comparing them. By the end of this tutorial, you'll gain a firm understanding of how sets in Python function.

## Overview:

A set in Python is an unordered collection of unique elements that doesn't allow duplicates. Sets come in handy when dealing with distinct items. They're mutable, so you can add or remove elements after creation. The related data structure frozenset in Python resembles a set but is immutable.

## What is a Set?

In Python, a set is a collection of unique elements, perfect for handling items without duplicates. Sets are represented with curly braces {} and commas separate elements.

Creating a Set or set() function in Python:
In Python, you can create sets using {}. Here's an example:

`fruits = {"apple", "banana", "orange", "apple", "pear"}print(fruits)`

Here, "apple" is duplicated, but the set will only contain one instance. When you print 'fruits', duplicates are automatically removed.

Output:

Basic Operations:
Sets support various operations like adding, removing, and checking membership.

`# Creating a setmy_set = {1, 2, 3, 4, 5,}# Adding an elementmy_set.add(6)# Removing an elementmy_set.remove(3)# Checking membershipprint(2 in my_set) # Output: Trueprint(3 in my_set) # Output: False`

Set Operations:
Sets also allow for mathematical operations like union, intersection, and difference.

`set_A = {1, 2, 3, 4}set B = [3, 4, 5, 6]# Union of sets A and Bunion = set_A | set_B# Intersection of sets A and Bintersection = set_A & set_B# Difference between sets A and Bdifference = set_A set_Bprint(union)    # Output: {1, 2, 3, 4, 5, 6}print(intersection)   # Output: {3, 4}print(difference)    # Output: {1, 2}`

Use Case Example:
Consider a practical scenario: you have a shopping cart with a list of items, and you want to eliminate duplicates before proceeding to checkout.

`shopping_cart = ["apple", "banana", "apple", "orange", "banana", "pear"]unique_items = set(shopping_cart)print(unique_items)`

Output:

Set in Python is Mutable or Immutable?

Sets in Python are mutable, allowing the addition, removal, and modification of elements. Unlike immutable data types, sets can be changed after creation, making them suitable for dynamic collections. However, their mutability should be considered when shared across code sections or in concurrent programming.

Set Items

In Python, sets store unique items, prohibiting duplicates. They can hold various data types, enclosed in {} with items separated by commas.

Creating Set Items:
You can create a set using curly braces like this:

`my_set = [1, 2, 3, 4 3 5)print(my set)`

In this example, 'my_set' holds numbers 1 to 5.

Checking Membership:
To check if an item is in a set, use the 'in' keyword.

`numbers = {1, 2, 3, 4, 5}print(3 in numbers)   # Output: Trueprint(6 in numbers)   # Output: False`

Iterating Through Set Items:
Use loops to iterate through the items in a set:

`fruits = {apple", "banana", "orange"}for fruit in fruits:     print(fruit)`

Example with Mixed Data Types:
Sets can contain items of different types:

`mixed_set = {"apple", 123, 3.14, (1, 2, 3)}print(mixed set)`

In this case, the set ‘mixed_set’ contains a string, an integer, a float, and a tuple.

Output:

Converting List to Set:
You can convert a list into a set to remove duplicate items:

`my_list = [1, 2, 2, 3, 3, 4, 5] unique_set = set (my_list)print(unique_set)`

Create 'my_list' with duplicates and convert it to 'unique_set'. Python sets automatically remove duplicates, resulting in a set with only unique elements. Here's the output:

Dictionary in Python

A dictionary in Python is an unordered collection of key-value pairs. It allows you to store and retrieve data using unique keys. Keys are used to identify and access their corresponding values. Here's an example:

`# Creating a dictionarymy_dict = {       'name': 'Alice',       'age': 30,       'city': 'New York'}# Accessing values using keysprint("Name:", my_dict['name'])print("Age:", my_dict['age'])print("City:", my_dict['city'])`

Output:

## How to Modify a Set in Python?

Python set contains methods like add (), clear (), remove () and discard (). Sets can be modified using these.

Add elements to a set using the add() method. If the element is already in the set, it won't be duplicated because sets reject duplicates.

`fruits (apple", "banana", "orange")fruits.add("grape")print (fruits) # Output: {'orange', 'banana', 'apple', 'grape'}#Adding a duplicate elementfruits.add("banana")print (fruits) # Output: ('orange', 'banana', 'apple', 'grape'}`

Removing Elements:
Remove elements from a set using the remove() method: It removes an element if present but raises a KeyError if not found in the set.

`my_set = {1, 2, 3}my set.remove(2)   # Removes 2 from the settry:     my_set.remove(4) # Element 4 is not present, raises KeyErrorexcept KeyError as e:     print("KeyError:", e)print(my set)    # Output: (1, 3) `

To remove an element from a set without causing an error if it's absent, employ the 'discard()' method.

`my_set = {1, 2, 3}my set.discard (2) # Removes 2 from the setmy_set.discard (4) # Element 4 is not present, no errorprint(my set) # Output: (1, 3)`

Clearing a Set:
To empty a set and remove all its elements, use the 'clear()' method.

`fruits = {"apple", "banana', 'orange"}fruits.clear()print (fruits)    # Output: set()`

## How to Get the Length of a Set?

In Python, you can find a set's length (number of elements) with the 'len()' function.

Example.

`fruits = {"apple", "banana", "orange", "pear"}length = len(fruits)print("The length of the 'fruits' set is:", length)`

Here, the len() function is applied to the fruits set, and the result is stored in the variable length. It displays the length of the set.

Output:

The value 4 indicates that the 'fruits' set contains four unique elements.

Empty Set Length:
If you apply the len() function to an empty set, the result will be 0.

`empty_set = set()length empty = len(empty_set)print("The length of the 'empty_set' is: ", length_empty)`

Output:

Using Length in Conditional Statements:
You can employ a set's length in conditional statements to verify if it's empty or has elements.

`my_set = {1, 2, 3, 4, 5}if len(my_set) > 0:        print("The set is not empty.")else:       print("The set is empty.")`

Output:

## Type Casting with Python Set Method

In Python, you can perform type casting to change data types. For sets, use the 'set()' constructor to create a set from iterable types like lists, tuples, and strings.

Type Casting from List to Set:
Convert a list to a set using 'set()'. Duplicates are automatically removed, leaving only unique elements.

`my list [1, 2, 2, 3, 3, 4, 5]my set set (my_list)print("Original list:", my_list)print("Set from list: ", my.set)`

Output:

Type Casting from Tuple to Set:
Similarly convert a tuple to a set using the set() constructor.

`my_tuple = (5, 6, 7, 7, 8)my set = set (my_tuple)print("Original tuple:", my_tuple) print("Set from tuple:", my set)`

Output:

Type Casting from String to Set:
Convert a string to a set, where each character becomes an element in the set.

`my_string = "hello"my set = set (my_string)print("Original string:", my_string) print("Set from string: ", my_set)`

Output:

Type Casting from Dictionary Keys to Set:
When you convert dictionary keys to a set, you get a set containing the unique keys.

`my_dict = {'a': 1, 'b': 2, 'c': 3}key_set = set(my_dict)print("Original dictionary: ", my_dict)print("Set from dictionary keys: ", key_set)`

Output:

## Check Unique and Immutable with Python Set

Uniqueness in Sets:
Sets in Python inherently enforce uniqueness. This feature makes sets useful for handling collections of distinct items.

Example:

`# Creating a set with duplicate elementsmy_set = {1, 2, 2, 3, 3, 4, 5}print("Original set:", my_set)`

Output:

Immutability of Set Elements:
Sets are mutable, allowing element additions and removals. However, elements within a set must be of immutable data types, ensuring reliability for indexing and hashing, which is critical for set operations.
Example:

`# Creating a set with different data typesmy_set = {1, 3.14, "hello", (2, 4)}# Attempting to add a mutable list to the settry:    my_set.add([5, 6])except TypeError as e:    print("TypeError:", e)`

Output:

Here, 'my_set' comprises immutable elements like integers, floats, strings, and tuples. However, trying to add the mutable list [5, 6] to the set results in a 'TypeError' because lists, being mutable, cannot be used as set elements.

Heterogeneous Element with Python Set

In Python sets, you can combine elements of different data types, creating "heterogeneous" sets.

Example:

`# Creating a set with heterogeneous elements my_set = {1, 3.14, "hello", (2, 4)}print("My set:", my_set)`

Output:

In this example, the set ‘my_set’ contains elements of various data types:

• Integer (1)
• Float (3.14)
• String ("hello")
• Tuple ((2, 4))

Python Frozen Sets

A frozen set in Python is an immutable type of set, where elements can't be altered after creation. This trait is handy for creating unchangeable collections of unique items.

Creating a Frozen Set:
Create a frozen set using 'frozenset()' by passing an iterable (e.g., list, tuple, or another set) as an argument.

`my_list = [1, 2, 3, 3, 4, 5]my_frozen_set = frozenset (my_list) print("My frozen set:", my_frozen_set)`

Output:

Frozen sets, once created, you can't add, remove, or modify their elements, ensuring their contents stay constant.

`my_frozen_set.add(6)    # This will raise an AttributeError`

Internal Working of Set

Python sets use hash tables, offering fast average-case time complexity for actions like addition, removal, and membership checks.

Hashing:
Hashing transforms an element into a fixed-size value (hash code) representing it. Strings, integers, and tuples in Python are hashable and usable as keys in dictionaries and elements in sets.

`# Hash codes of integershash_code_1 = hash(42)hash_code_2 = hash (99)print(hash_code_1, hash_code_2)`

The 'hash()' function in Python provides an object's hash value, which can vary across program runs. Typically, for integers, the hash value matches the integer value.

Output:

Here, 'hash_code_1' will equal the hash value of '42', and 'hash_code_2' will equal the hash value of '99', which corresponds to the integer values.

Hash Tables:
A hash table stores elements with their hash codes in an array of "buckets" determined by the hash codes.

`# Creating a simple hash table (illustration) hash_table = [None] * 10 # Initialize with empty slots# Adding elements to hash tableelement_1 = "apple".element_2 = "banana"hash_code_1 = hash (element_1) hash_code_2 = hash (element_2)bucket_1 = hash_code_1 % len (hash_table) bucket_2 = hash_code_2% len (hash_table)hash_table[bucket_1] = element_1hash_table[bucket_2] = element_2print (hash_table)`

Output:

Explanation:

• The 'hash_table' is initialized with 10 empty slots, represented as '[None] * 10'.
• Two elements, "apple" and "banana," are added to the hash table.
• The hash codes for these elements are calculated using the 'hash()' function.
• The hash codes are then mapped to buckets in the hash table using the modulo operation '%' with the length of the hash table.
• "banana" is stored in the bucket at index 'hash_code_2 % len(hash_table)', which is index 4.
• "apple" is stored in the bucket at index 'hash_code_1 % len(hash_table)', which is index 5.
• The resulting 'hash_table' shows the placement of these elements in their respective buckets.

Collision Resolution (Chaining):
Collisions happen when two elements share the same hash code. Python manages collisions with chaining, where each bucket holds a linked list of elements with the same hash code.

`#Chaining (illustration)bucket with collision = 3linked_list = ["apple", "banana"]hash_table[bucket_with_collision] = linked_listprint(hash_table)`

Internal Working of Sets:
Python's set functions as a hash table implementation. When you create a set, Python employs the hash codes of elements to put them in suitable hash table buckets, enabling rapid retrieval and efficient membership checks.

`# Creating a set and adding elements fruits = {"apple", "banana", "orange"}#Hash codes and buckets (illustration)hash_code_apple = hash("apple").hash_code_banana = hash("banana")hash_code_orange = hash("orange")bucket_apple = hash_code_apple % len (hash_table)bucket_banana = hash_code_banana % len(hash_table)bucket_orange =hash_code_orange % len (hash_table)print("Hash codes: ", hash_code_apple, hash_code_banana, hash_code_orange) print("Buckets: ", bucket_apple, bucket_banana, bucket_orange)`

This calculates hash codes for "apple," "banana," and "orange" elements and determines the hash table buckets where they'd be placed.

Output:

Explanation:

• The 'hash()' function is used to calculate hash codes for the strings "apple," "banana," and "orange."
• The modulo operation % is then applied to the hash codes to calculate the buckets where these elements would be placed in the hash table.
• For "apple," the hash code is 3112855979180901583, and it is placed in bucket 3.
• For "banana," the hash code is 8457036208380033094, and it is placed in bucket 4.
• For "orange," the hash code is 7578933341900684711, and it is placed in bucket 1.

## Methods for Sets

Python sets come with various methods to perform operations. Some of the key methods include:

1. Union Operation on Python Sets (union() or | operator):

The union of two sets produces a new set containing all unique elements from both sets.

`set1 = [1, 2, 3)set2= [3, 4, 5}union_set = set1.union (set2)# Or: union_set = set1 | set2print(union_set)     # Output: (1, 2, 3, 4, 5}`

2. Intersection Operation on Python Sets (intersection() or & operator):

The Python set intersection of two sets returns a new set with elements shared by both sets.

`set1= {1, 2, 3}set2= [3, 4, 5}intersection_set = set1. intersection (set2)#Or: intersection_set = set1 & set2print(intersection_set)   # Output: (3)`

3. Finding Differences of Sets in Python (difference() or - operator):

The difference between the two sets results in a new set containing elements from the first set but not the second.

`set1 = {1, 2, 3, 4}set2 = {3, 4, 5}difference_set = set1.difference(set2)#Or: difference_set = set1 - set2print(difference_set)    # Output: (1, 2)`

## Time Complexity of Sets

Time complexities for common set operations in Python can vary:

• Average: O(1)
• Rare hash collision: O(n), where n is the elements in the collided bucket.
`my_set = {1, 2, 3}my_set.add(4)    # 0(1) average case`

2. Removing an Element (remove() or discard() methods):

• Average: O(1)
• Worst-case with hash collision: O(n), if a collision results in a lengthy linked list.
`my_set = {1, 2, 3}my_set.remove(2) # 0(1) average case`

3. Membership Test (in operator):
Membership checks using the 'in' operator are typically O(1) on average.

`my_set = {1, 2, 3}if 2 in my set:   # 0(1) average case        print("Element found!")`

4. Union Operation (union() or | operator):
The union of two sets takes O(len(s)) time, where s is the larger set.

`set1 = {1, 2, 3}set2 = {3, 4, 5}union_set = set1.union (set2)# 0(len(set1))`

5. Intersection Operation (intersection() or & operator):
The intersection of two sets takes O(min(len(s1), len(s2))) time.

`set1 = (1, 2, 3}set2 = {3, 4, 5}intersection_set = set1.intersection(set2)     # 0(min(len(set1), len(set2)))`

6. Difference Operation (difference() or - operator):
The difference between two sets takes O(len(s1)) time.

`set1 = {1, 2, 3, 4}set2 = {3, 4, 5}difference_set = set1.difference (set2) # 0(len(set1))`

7. Clearing a Set (clear() method):
Clearing a set using the clear() method is an O(1) operation.

`my_set = (1, 2, 3}my_set.clear()    # 0(1)`

Operators for Sets

Sets provide a range of operators, including union (|), intersection (&), and difference (-), which have been detailed earlier.

## Conclusion

Python sets are a valuable tool for managing unique data and performing set-based operations. They ensure uniqueness and offer practical solutions for various applications. With this Python set documentation, you can gain the expertise to use sets effectively in your Python applications.

## FAQs

1. How to create a tuple in Python?
You can create a tuple by enclosing elements in parentheses. The elements are separated by commas. Example: my_tuple = (1, 2, 3).

2. What are the common uses of Python frozen sets?

• Frozen sets serve as dictionary keys
• For creating collections of sets that must remain unaltered, frozen sets are handy.
• Due to their hashable and immutable nature, frozen sets are efficient for membership testing in other sets or dictionaries.
`set_of_frozen_sets = {frozenset({1, 2}), frozenset({3, 4})}print(frozenset({1, 2}) in set_of_frozen_sets)     # Output: True`

Director of Engineering

Director of Engineering @ upGrad. Motivated to leverage technology to solve problems. Seasoned leader for startups and fast moving orgs. Working …Read More

###### Need More Help? Talk to an Expert
+91
*
By clicking, I accept theT&Cand
Join 10M+ Learners & Transform Your Career
Learn on a personalised AI-powered platform that offers best-in-class content, live sessions & mentorship from leading industry experts.

Talk to our experts. We’re available 24/7.

Indian Nationals

1800 210 2020

Foreign Nationals

+918045604032

## Disclaimer

upGrad does not grant credit; credits are granted, accepted or transferred at the sole discretion of the relevant educational institution offering the diploma or degree. We advise you to enquire further regarding the suitability of this program for your academic, professional requirements and job prospects before enr...