Python: Accessing Set Items Tutorial with Examples

In Python, sets are unordered collections of unique elements.

Unlike lists or tuples, sets do not allow duplicates, and their elements do not have an index, making them slightly different when it comes to accessing items.

While you cannot access set elements by index like in a list or tuple, there are several methods to access, check, and manipulate items in a set.

In this tutorial, we will cover:

1. What is a Set?
2. Basic Set Properties and Limitations
3. Iterating Over Set Items with Loops
4. Checking for Membership (in and not in)
5. Accessing and Removing Items (pop())
6. Accessing Items by Converting Set to List
7. Examples and Common Use Cases

Let’s explore each topic with examples and explanations.

1. What is a Set?

A set in Python is an unordered collection of unique elements, meaning:

• Each element appears only once (no duplicates).
• The elements are not stored in a specific order.

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

Example of a Set:

my_set = {1, 2, 3, 4, 5}
print(my_set)  # Output: {1, 2, 3, 4, 5}

# Creating a set using the set() function
another_set = set([10, 20, 30, 40])
print(another_set)  # Output: {40, 10, 20, 30}

2. Basic Set Properties and Limitations

Before diving into accessing set items, let’s review some important properties of sets:

1. Unordered: Set elements have no specific order, so you cannot access them by index.
2. Unique: Sets automatically remove duplicate values.

Example: Attempting to Access Set Items by Index (Error)

my_set = {1, 2, 3}

# Trying to access the first item using indexing (This will raise an error)
# print(my_set[0])  # Uncommenting this line will raise a TypeError

# TypeError: 'set' object is not subscriptable

• Unlike lists or tuples, you cannot access set elements using indexing.

3. Iterating Over Set Items with Loops

The most common way to access items in a set is by iterating over the set using a loop, such as a for loop. Since sets are unordered, the items will be accessed in an arbitrary order.

Example 1: Looping Through a Set with for

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

for item in my_set:
    print(item)

Output:

apple
cherry
banana

• In this example, the for loop iterates over the set and prints each item. The order is arbitrary because sets are unordered.

Example 2: Accessing Each Set Item with for

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

for number in numbers:
    print(f"Number: {number}")

Output:

Number: 50
Number: 20
Number: 40
Number: 10
Number: 30

• In this example, each item in the numbers set is accessed and printed. The order of elements may change each time you run the code.

4. Checking for Membership (in and not in)

You can use the in and not in operators to check if an element exists in a set. This is a fast and efficient operation in sets due to their underlying implementation using hash tables.

Example: Checking for Membership in a Set

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

# Checking if 'apple' is in the set
if "apple" in fruits:
    print("Apple is in the set.")

# Checking if 'orange' is not in the set
if "orange" not in fruits:
    print("Orange is not in the set.")

Output:

Apple is in the set.
Orange is not in the set.

• In this example, we use in and not in to check if certain items are present in the fruits set.

5. Accessing and Removing Items (pop())

The pop() method removes and returns a random item from the set, as sets are unordered. If the set is empty, calling pop() raises a KeyError.

Example: Accessing and Removing a Random Item with pop()

my_set = {100, 200, 300, 400}

# Removing and accessing a random item from the set
popped_item = my_set.pop()
print(f"Popped item: {popped_item}")
print(f"Remaining set: {my_set}")

Output (order may vary):

Popped item: 100
Remaining set: {200, 300, 400}

• In this example, pop() removes and returns a random item from the set. Since sets are unordered, you cannot predict which item will be removed.

6. Accessing Items by Converting Set to List

Since sets are unordered and cannot be accessed by index, you can convert the set to a list to access specific elements by index. This is useful when you need ordered access to set elements.

Example: Converting a Set to a List for Indexed Access

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

# Convert the set to a list
my_list = list(my_set)

# Access the first and second elements (after conversion)
print(f"First item: {my_list[0]}")
print(f"Second item: {my_list[1]}")

Output (order may vary):

First item: apple
Second item: banana

• In this example, we convert the set to a list, which allows us to access the elements by index. However, the order of elements in the list is still arbitrary since the set itself is unordered.

7. Examples and Common Use Cases

Example 1: Checking if a Set Contains a Specific Element

cities = {"New York", "Los Angeles", "Chicago"}

city_to_check = "Chicago"

if city_to_check in cities:
    print(f"{city_to_check} is in the set.")
else:
    print(f"{city_to_check} is not in the set.")

Output:

Chicago is in the set.

• In this example, we check if a city is in the set using the in operator.

Example 2: Accessing and Modifying a Set by Iterating

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

# Create a new set with each number doubled
doubled_numbers = {number * 2 for number in numbers}

print(f"Original set: {numbers}")
print(f"Doubled set: {doubled_numbers}")

Output:

Original set: {1, 2, 3, 4, 5}
Doubled set: {2, 4, 6, 8, 10}

• In this example, we loop through the set and create a new set where each number is doubled.

Example 3: Accessing Multiple Items by Iterating and Filtering

people = {"Alice", "Bob", "Charlie", "David"}

# Accessing and filtering names starting with 'A'
for person in people:
    if person.startswith("A"):
        print(f"Person found: {person}")

Output:

Person found: Alice

• In this example, we loop through the set and filter the names to find those starting with the letter “A”.

Summary of Python Set Accessing Methods:

Conclusion

Accessing set items in Python differs from other data structures like lists or tuples because sets are unordered and do not support indexing.

In this tutorial, we covered:

• Iterating through sets using for loops to access each item.
• Using membership operators (in, not in) to check if an item is in the set.
• Using pop() to remove and access a random item from the set.
• Converting sets to lists to access items by index.