Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


Explore the Python set and frozenset collections!

Sets

A lot of the usefulness of a set container comes from the set operations. These allow you to combine sets, find the difference and intersections of sets, and more! You can combine these operations to perform complex logic problems on multiple sets. This can be useful for filtering items, categorizing, combining, as well as many other uses.

The operations which we will be looking at are:
 * Unions
 * Intersections (and Intersection Updates)
 * Differences (and Difference Updates)
 * Symmetric Differences (and Symmetric Difference Updates)

Additional operations will not be covered in this lesson, such as finding subsets and supersets. Information about these operations can be found in the [Python documentation](https://docs.python.org/3/library/stdtypes.html#set).


Introduction to Set Operations

There are two methods for removing specific elements from a `set`:

1. The `.remove()` method searches for an element within the `set` and removes it if it exists, otherwise, a `KeyError` is thrown. 

  ```python
  # Given a list of song tags
  song_tags = {'guitar', 'acoustic', 'folk', 'country', 'live', 'blues'}

  # Remove an existing element
  song_tags.remove('folk')
  print(song_tags)

  # Try removing a non-existent element
  song_tags.remove('fiddle')
  ```

  Would output:
  ```bash
  {'blues', 'acoustic', 'country', 'guitar', 'live'}
  ```

  Followed by:
  ```error
  Traceback (most recent call last):
  File "some_file_name.py", line 9, in <module>
    song_tags.remove('fiddle')
  KeyError: 'fiddle'
  ```

2. The `.discard()` method works the same way but does not throw an exception if an element is not present.

  ```python
  # Given a list of song tags
  song_tags = {'guitar', 'acoustic', 'folk', 'country', 'live', 'blues'}

  # Try removing a non-existent element but with the discard method
  song_tags.discard('guitar')
  print(song_tags)

  # Try removing a non-existent element but with the discard method
  song_tags.discard('fiddle')
  print(song_tags)
  ```
  
  Would output: 
  ```bash
  {'folk', 'acoustic', 'blues', 'live', 'country'}
  {'folk', 'acoustic', 'blues', 'live', 'country'}
  ```

Note that items cannot be removed from a `frozenset` so neither of these methods would work.


Removing From a Set

Great Job! You have learned about many different ways to work with `set` and `frozenset` containers! We looked at: 

Creating a `set` or `frozenset`:
 * For `set` containers, we can use curly braces `{}`, the `set()` constructor, or set comprehension.
 * For `frozenset` containers, we can only use the `frozenset()` constructor.

Adding items to a `set`:
 * We can add items to a `set` individually using the `.add()` method.
 * We can add multiple items at once using the `.update()` method.

Removing items from a `set`:
 * The `.remove()` method is used to remove elements from a `set`.
 * The `.discard()` method can also be used to remove elements from a `set`. It does not throw a `KeyError` if the element is not found.

Finding Elements:
 * The `in` keyword can be used with `set` and `frozenset` containers to test if an element exists inside of them.

Union:
 * A union can be found using `set` or `frozenset` containers with the `.union()` method or `|` operator.

Intersection:
 * An intersection can be found using `set` or `frozenset` containers with the `.intersection()` method or `&` operator.

Difference:
 * The difference can be found using `set` or `frozenset` containers with the `.difference()` method or `-` operator.

Symmetric Difference:
 * The symmetric difference can be found using `set` or `frozenset` containers with the `.symmetric_difference()` method or `^` operator.

Want to learn more about sets? Check out everything about sets including additional methods, testing for superclass and subclasses, and more from the [Python documentation](https://docs.python.org/3/library/stdtypes.html#set).


Sets Review

In Python, `set` and `frozenset` items cannot be accessed by a specific index. This is due to the fact that both containers are unordered and have no indices. However, like most other Python containers, we can use the `in` keyword to test if an element is in a `set` or `frozenset`.

Here are some examples of finding if elements exist in a `set` and `frozenset`:
```python
# Given a list of song tags
song_tags = {'guitar', 'acoustic', 'folk', 'country', 'live', 'blues'}

# Print the result of testing whether 'country' is in the set of tags or not
print('country' in song_tags)
```
Would output:
```bash
True
```

This also works for `frozenset`:
```py
song_tags = {'guitar', 'acoustic', 'folk', 'country', 'live', 'blues'}

frozen_tags = frozenset(song_tags)
print('rock' in frozen_tags)
```

Would output: 
```bash
False
```

Let's use the `in` keyword to work with more user tags in our music application!


Finding Elements in a Set

The last operation we will be looking at is the symmetric difference. We can think of this operation as the opposite of the intersection operation. A resulting set will include all elements from the sets which are in one or the other, but not both. In other words, elements that are unique to each set. 

To perform this operation on the `set` or `frozenset` containers, we can use the `.symmetric_difference()` method or the `^` operator. Like the other operators, the type of the first operand (a `set` or `frozenset` on the left side of the operator or method) determines if a `set` or `frozenset` is returned when finding the symmetric difference.

Take a look at the Venn diagram that represents a symmetric difference between set `A` and set `B`:

![Python Set Symmetric Difference](https://static-assets.codecademy.com/Courses/Intermediate-Python/Symmetric%20Difference.svg)

Here is what the symmetric difference looks like in Python:

```python
# Given a set and frozenset of song tags for two python related hits
prepare_to_py = {'rock', 'heavy metal', 'electric guitar', 'synth'}

py_and_dry = frozenset({'classic', 'rock', 'electric guitar', 'rock and roll'})

# Find the elements which are exclusive to each song and not shared using the method
exclusive_tags = prepare_to_py.symmetric_difference(py_and_dry)
print(exclusive_tags)
```

Would output:
```bash
{'heavy metal', 'synth', 'rock and roll', 'classic'}
```

Alternatively, we can use the `^` operator:
```py 
# Find the elements which are exclusive to each song and not shared using the operator
frozen_exclusive_tags = py_and_dry ^ prepare_to_py
print(frozen_exclusive_tags)
```

Would output:
```
frozenset({'synth', 'rock and roll', 'heavy metal', 'classic'})
```

We can also update the original `set` using this operation by using the `.symmetric_difference_update()` method to update the original `set` with the result instead of returning a new `set` or `frozenset` object. 

Let's create a symmetric difference in our music application! 

Symmetric Difference

There are two different ways to add elements to a set:

1. The `.add()` method can add a single element to the `set`.

  ```python
  # Create a set to hold the song tags
  song_tags = {'country', 'folk', 'acoustic'}

  # Add a new tag to the set and try to add a duplicate.
  song_tags.add('guitar')
  song_tags.add('country')

  print(song_tags)
  ```

  Would output:
  ```bash
  {'country', 'acoustic', 'guitar', 'folk'}
  ```

2. The `.update()` method can add multiple elements.
   
  ```python
  # Create a set to hold the song tags
  song_tags = {'country', 'folk', 'acoustic'}

  # Add more tags using a hashable object (such as a list of elements)
  other_tags = ['live', 'blues', 'acoustic']
  song_tags.update(other_tags)

  print(song_tags)
  ```
  
  Would output:
  ```bash
  {'acoustic', 'folk', 'country', 'live', 'blues'}
  ```

There are a few things to note about adding to a set: 

- Neither of these methods will add a duplicate item to a `set`.

- A `frozenset` can not have any items added to it and so neither of these methods will work.

- Notice that when the elements are printed, they are not printed in the same order in which they entered the `set`. This is because `set` and `frozenset` containers are unordered. 

Let's practice adding to a set!


Adding to a Set

Similar to how we can find elements in common between sets, we can also find unique elements in one set.  To do so, the `set` or `frozenset` use the `.difference()` method or the `-` operator. This returns a `set` or `frozenset`, which contains only the elements from the first set which are not found in the second set. Similar to the other operations, the type of the first operand (a `set` or `frozenset` on the left side of the operator or method) determines if a `set` or `frozenset` is returned when finding the difference.

Take a look at the Venn diagram representing a difference operation that captures elements that are unique to set `A`:

![Python Set Difference](https://static-assets.codecademy.com/Courses/Intermediate-Python/Difference.svg)

Here is what finding a set difference looks like in Python:

```python
# Given a set and frozenset of song tags for two python related hits
prepare_to_py = {'rock', 'heavy metal', 'electric guitar', 'synth'}

py_and_dry = frozenset({'classic', 'rock', 'electric guitar', 'rock and roll'})

# Find the elements which are only in prepare_to_py
only_in_prepare_to_py = prepare_to_py.difference(py_and_dry)
print(only_in_prepare_to_py)
```

Would Output:
```bash
{'heavy metal', 'synth'}
```

Alternativly, we can use the `-` operator: 
```py
# Find the elements which are only in py_and_dry
only_in_py_and_dry = py_and_dry - prepare_to_py
print(only_in_py_and_dry)
```
Would output:
```bash
frozenset({'rock and roll', 'classic'})
```

This operation also supports an updating version of the method. You can use `.difference_update()` to update the original `set` with the result instead of returning a new `set` or `frozenset` object. 

Let's see how we can apply this operation to our music application!

Set Difference

Let’s say that we have two or more sets, and we want to find which items both sets have in common. The `set` container has a method called `.intersection()` which returns a new `set` or `frozenset` consisting of those elements. An intersection can also be performed on multiple sets using the `&` operator. 

Similar to the other operations, the type of the first operand (a `set` or `frozenset` on the left side of the operator or method) determines if a `set` or `frozenset` is returned when finding the intersection.

Take a look at the Venn diagram representing an intersection of set A and set B:

![Python Set Intersection](https://static-assets.codecademy.com/Courses/Intermediate-Python/Intersection.svg)

Here is what an intersection looks like in Python:

```python
# Given a set and frozenset of song tags for two python related hits
prepare_to_py = {'rock', 'heavy metal', 'electric guitar', 'synth'}

py_and_dry = frozenset({'classic', 'rock', 'electric guitar', 'rock and roll'})

# Find the intersection between them while providing the `frozenset` first.
frozen_intersected_tags = py_and_dry.intersection(prepare_to_py)
print(frozen_intersected_tags)
```

Would output: 
```bash
frozenset({'electric guitar', 'rock'})
```

And here it is with the `&` operator: 

```py
# Find the intersection using the operator `&` and providing the normal set first
intersected_tags = prepare_to_py & py_and_dry
print(intersected_tags)
```

Would output: 
```
{'rock', 'electric guitar'}
```

In addition to a regular intersection, the `set` container can also use a method called `.intersection_update()`. Instead of returning a new `set`, the original `set` is updated to contain the result of the intersection.

Let's see how we can use the intersection operation to create a recommendation feature for our music application!

Set Intersection

In Python, there are multiple ways to create a set. A set object can be created by passing an iterable object into its constructor, using curly braces, or using a set comprehension.

Let's examine the syntax of these methods:
```python
# Creating a set with curly braces
music_genres = {'country', 'punk', 'rap', 'techno', 'pop', 'latin'}

# Creating a set from a list using set()
music_genres_2 = set(['country', 'punk', 'rap', 'techno', 'pop', 'latin'])
```

It's worth noting that creating a set from a list with duplicates produces a set with the duplicates removed. Here is an example: 

```python
# Creating a set from a list that contains duplicates
music_genres_3 = set(['country', 'punk', 'rap', 'pop', 'pop', 'pop'])
print(music_genres_3)
```

Will output:
```bash
{'country', 'punk', 'pop', 'rap'}
```

While we use a similar data type in the sets above, sets can actually contain any combination of data types as long as they are unique values. Here is an example:
```py
music_different = {70, 'music times', 'categories', True , 'country', 45.7}
```

We can also create an empty set with one specific method:
```py
# Creating an empty set using the set() constructor
# Doing set = {} will define a dictionary rather than a set.  

empty_genres = set()
```

Lastly, similar to list comprehensions, we can create sets using a set comprehension and a data set (such as a list). Here is an example:
```python
items = ['country', 'punk', 'rap', 'techno', 'pop', 'latin']

music_genres = {category for category in items if category[0] == 'p'}
print(music_genres)
```

Would output a set containing all elements from `items` starting with the letter `'p'`:
```bash
{'punk', 'pop'}
```

Now, let's practice these methods to get a feel of how to create a set!

Creating a Set

When working with `set` or `frozenset` container, one of the most common operations we can perform is a merge. To do this, we can return the union of two sets using the `.union()` method or `|` operator. Doing so will return a new `set` or `frozenset` containing all elements from both sets without duplicates.

Take a look at the Venn diagram representing a union of set `A` and set `B`: 

![Python Set Union](https://static-assets.codecademy.com/Courses/Intermediate-Python/Union.svg)

Notice the resulting set contains all the elements in both set `A` and set `B` as well as elements they have in common (minus the duplicates). In this case we are only looking at merging two sets but it's also common to perform the operation on as many as we need!

Let's look at two examples of creating a union:

1. Using `union()`:
  ```python
  # Given a set and frozenset of song tags for two python related hits
  prepare_to_py = {'rock', 'heavy metal', 'electric guitar', 'synth'}

  py_and_dry = frozenset({'classic', 'rock', 'electric guitar', 'rock and roll'})

  # Get the union using the .union() method
  combined_tags = prepare_to_py.union(py_and_dry)
  print(combined_tags)
  ```

  Would output: 
  ```bash
  {'electric guitar', 'classic', 'heavy metal', 'rock and roll', 'rock', 'synth'}
  ```

2. Using `|`: 
  ```py
  # Get the union using the | operator
  frozen_combined_tags = py_and_dry | prepare_to_py
  print(frozen_combined_tags)
  ```

  Would output:
  ```bash
  frozenset({'electric guitar', 'rock and roll', 'rock', 'synth', 'heavy metal', 'classic'})
  ```

Note that the return value in both methods takes the form of the left operand. In the first example since `prepare_to_py()` called the `union()` function, so the result was a regular `set`. In the second example, since `py_and_dry` was the left operand, the end result was a `frozenset`.

Set Union

In Python, a set is a group of elements that are unordered and do not contain duplicates. Although it may seem that the usefulness of this data structure is limited, it can actually be very helpful for organizing items and performing set mathematics. 

For example, we can imagine two different groups of items that have some similarities and differences. Using set mathematics, we can find the matching items, differences, combine the sets based on different parameters, and more! This is especially helpful when combing through very large datasets. 

Alternatively, there is also an immutable version of a set called a frozenset. A frozenset behaves similarly to a normal set, but it does not include methods that modify the frozenset in any way. 

In this lesson, we'll explore: 

- How to create a set and a frozenset.
- How to add to a set (we won't be able to mutate a frozenset).
- How to remove from a set (we won't be able to mutate a frozenset).
- How to find specific elements in a set and a frozenset.
- How to perform set operations such as unions, intersections, and more.

Let's jump in!

Introduction to Python Sets

Unlike a normal `set`, you can only create a `frozenset` using its constructor. Remember that using a `frozenset` means that you cannot modify the elements inside of it.

Creating a `frozenset` using its constructor looks like this:

```python
# Creating a frozenset from a list
frozen_music_genres = frozenset(['country', 'punk', 'rap', 'techno', 'pop', 'latin'])
```

We can also create an empty `frozenset`:
```py
empty_frozen_music_genres = frozenset()
```

Let's practice creating a `frozenset` in our music application!
