Table of contents

Python Sets for busy people
Python Sets

alt text

Python Sets for busy people

Set items don’t have a serial number (index)
No Index. No Order. You can’t refer to an item like mySet[2]
No duplicate items
No Lists/Dictionaries
Can add new items:
- mySet.add(4): Adds a single element to the set.
- mySet.update([4, 5]): Adds multiple elements to the set.
Can remove items:
- mySet.remove(element): Removes a specific element. Raises a KeyError if not found.
- mySet.discard(element): Removes a specific element. No issues if not found.
- mySet.pop(): Removes and returns a random element. KeyError if set empty.
- mySet.clear(): Removes all elements. Slate clean.
Check if an element exists:
- element in mySet: True if item present, else False.
Get the number of elements:
- len(mySet): Total no of items in set.
Copy a set:
- mySet.copy(): Creates a shallow copy of the set.
Union of sets:
- mySet.union(other_set) or mySet | other_set: Combines all elements from both sets, without duplicates.
Intersection of sets:
- mySet.intersection(other_set) or mySet & other_set: Returns elements common to both sets.
Difference of sets:
- mySet.difference(other_set) or mySet - other_set: Returns elements in the first set but not in the second.
Symmetric difference of sets:
- mySet.symmetric_difference(other_set) or mySet ^ other_set: Returns elements in either set, but not in both.

Note:

Changeable items (also called mutable) are items that can be modified after they are created. For example:

Lists: You can add, remove, or change elements.
Dictionaries: You can add, remove, or change key-value pairs.

These items cannot be added to a set because sets need items that do not change.

Unchangeable items (also called immutable) are items that cannot be modified after they are created. For example:

Numbers: Once created, their values cannot be changed.
Strings: Any modification creates a new string.
Tuples: Their elements cannot be changed once created.

These items can be added to a set because their values stay the same.

Python Sets

A Python set is like your travel kit. Collection of unique items. There can be different items. But, they should be unique. Set items don't have serial numbers (Index). Without a serial number, you can't do something like mySet[2]="Guava". All items in a set must be different. Otherwise, how would you tell them apart? If your set has two apples, which one is which? But, you can remove items from a set. You can take out an apple and add a guava. Don't think about removing an apple and adding another apple. Sets can't contain a list or a dictionary. Period. They can contain tuples, but these tuples can't have lists or dictionaries inside them. (It won't cause an error, but it can make the code unstable.)

Python Sets Properties

So, here are some properties of Python Sets:

Items have No Index:

Python stores Set items but does not keep track of their order. This means there is no first item, second item, etc. For example, if you input `apple`, `orange`, `banana`, you might get `banana`, `apple`, `orange` as the output.

alt text

```python
mySet = {1, 2, 3}
print(mySet)  # Output could be {1, 2, 3} or {3, 1, 2} or any permutation

mySet[0] # THIS IS AN ERROR. No one is sitting at 0. There is no order, no index.
```

No Duplicates:

Since items in a set do not have serial numbers, duplicates are not allowed. If you try to add two apples, how would you distinguish between them? Therefore, when you add duplicates to a set, Python automatically removes the duplicates.

alt text

mySet = {1, 2, 2, 3}
print(mySet)  # Output: {1, 2, 3}

No In-Place Replace. Add/remove instead.

You can add/remove items, but can't change an item's value directly. Can't in-place replace items. First, remove the old one and add the new one.

alt text

```python
mySet = {1, 2, 3}

mySet.remove(2) # OK
mySet.add(4) # OK
mySet[0] = 5 # ERROR
```

No Lists/Dictionaries, Tuples Are OK.

Sets use hashing, so you can't store lists or dictionaries in them. However, you can store tuples. Just make sure these tuples don't contain lists or dictionaries inside them.

alt text

```python
# Valid elements
mySet = {1, "hello", (1, 2)} # TUPLES OK

# Invalid elements
mySet = {[1, 2], {"key": "value"}} # ERROR, NO LISTS, NO DICTS
```

When to use sets

alt text

Sets for Python are very useful when you need keep unique items and do quick membership checks. Here are some scenarios where sets are frequently used:

Removing Duplicates

Use Case: When you need to ensure that a collection of elements contains no duplicates.

Example: Removing duplicates from a list.

items = [1, 2, 2, 3, 4, 4, 5]
unique_items = list(set(items))  # [1, 2, 3, 4, 5]

Membership Testing

Use Case: When you need to check if an element exists in a collection. Sets provide average O(1) time complexity for membership tests.

Example: Checking if an item exists in a collection.

allowed_items = {"apple", "banana", "cherry"}
if "banana" in allowed_items:
    print("Banana is allowed")

Set Operations

Use Case: When you need to perform operations like union, intersection, difference, and symmetric difference between collections.

Example: Finding common elements between two sets.

set1 = {1, 2, 3}
set2 = {3, 4, 5}
common_items = set1 & set2  # {3}

Data Validation

Use Case: When validating data to ensure uniqueness, such as checking for duplicate entries in a dataset.

Example: Validating unique user IDs.

user_ids = [101, 102, 103, 101]
unique_user_ids = set(user_ids)
if len(user_ids) != len(unique_user_ids):
    print("Duplicate user IDs found")

Tracking Unique Elements

Use Case: When you need to keep track of unique items encountered during processing.

Example: Tracking unique words in a text.

text = "hello world hello"
words = text.split()
unique_words = set(words)  # {"hello", "world"}

Efficient Data Lookups

Use Case: When you need a data structure that allows for fast lookups, insertions, and deletions.

Example: Keeping track of visited URLs in a web crawler.

visited_urls = set()
visited_urls.add("https://example.com")
if "https://example.com" in visited_urls:
    print("URL already visited")