---
## Learning Objectives
*After this lesson, you will be able to:*
- Perform common actions with sets.
- Perform common actions with tuples.
- Know when to use different data structures.
---
## Discussion: Lists
Here are some lists:
```python
unique_colors = ["red", "yellow", "red", "green", "red", "yellow"]
subscribed_emails = ["mary@gmail.com", "opal@gmail.com", "mary@gmail.com", "sayed@gmail.com"]
```
What could be a problem here?
---
## Introducing Sets
Lists:
```python
unique_colors_list = ["red", "yellow", "red", "green", "red", "yellow"]
subscribed_emails_list = ["mary@gmail.com", "opal@gmail.com", "mary@gmail.com", "sayed@gmail.com"]
```
Sets: Lists without duplicates!
```python
unique_colors_set = {"green", "yellow", "red"}
subscribed_emails_set = {"mary@gmail.com", "opal@gmail.com", "sayed@gmail.com"}
```
- Notice the `[]` versus the `{}`.
---
## How Can We Make a Set?
Making a set via a list - Python removes duplicates automatically.
```python
my_set = set(a_list_to_convert)
# In action:
unique_colors_list = ["red", "yellow", "red", "green", "red", "yellow"]
unique_colors_set = set(unique_colors_list)
# => {"green", "yellow", "red"}
# Instead of passing a list in (a_list_to_convert), we could just type it:
my_set_2 = (["enter", "list", "here"])
# In action:
unique_colors_set_2 = set(["red", "yellow", "red", "green", "red", "yellow"])
# => {"green", "yellow", "red"}
```
Making a set directly, in curly braces:
```python
colors = {"red", "orange", "yellow", "green", "blue", "indigo", "violet"}
```
---
## Important Note: Sets
Lists are always in the same order:
- `my_list = ["green", "yellow", "red"]` is always going to be`["green", "yellow", "red"]`
- `my_list[0]` is always `"green"`; `my_list[1]` is always `"yellow"`; `my_list[2]` is always `"red"`.
Sets are not! Like dictionaries, they're in any order.
- `my_set = {"green", "yellow", "red"}` could later be `{"red", "yellow", "green"}`!
- `my_set[0]` could be `"green"`, `"red"`, or `"yellow"` - we don't know!
We **cannot** do: `print(my_set[0])` - it could be anything! Python won't let us.
---
## We Do: Creating a Set from a List
Let's pull up a new `set_practice.py` file and make some sets!
- Make a list `clothing_list` containing the main color of your classmates' clothing.
- Using `clothing_list`, make a set named `clothing_set`.
- Use a `for` loop to print out both `clothing_list` and `clothing_set`.
- Try to print an index!
---
## We Do: Adding to a Set
How do we add more to a set?
```python
# In a list:
clothing_list.append("red")
# In a set
clothing_set.add("red")
```
`add` vs `append` - this is because we can't guarantee it's going at the end!
Let's a few colors to `clothing_list` and `clothing_set`, then print them.
- What happens if you add a duplicate?
---
## We Do: Removing from a List and a Set
Remember, lists are always the same order: `["green", "yellow", "red"]`.
- `my_list[0]` is always "green".
Remember, sets are not!
- With the set `{"green", "yellow", "red"}`, `my_set[0]` could be `green`, `red`, or `yellow`.
The same way, we need to be careful about removal:
```python
# In a list:
clothing_list.pop() # Removes and returns the last item in the list.
clothing_list.pop(0) # Removes and returns a specific (here, the first) item in the list.
# In a set
clothing_set.pop() # No! This is unreliable! The order is arbitrary.
clothing_set.pop(0) # No! Python throws an error! You can't index sets.
clothing_set.remove('red') # Do this! Call the element directly!
```
---
## Quick Review: Sets vs. Lists
**Lists**:
- The original, normal object.
- Created with `[]`.
- `append()`, `insert(index)`, `pop()`, `pop(index)`.
- Duplicates and mutable.
**Sets**:
- Lists without duplicates.
- Created with `{}` or with `set(my_list)`.
- `add()` and `remove(element)`.
## Quick Review: Sets vs. Lists
```python
### Creation ###
# List
my_list = ["red", "yellow", "green", "red"]
# Sets
my_set = {"red", "yellow", "green"}
my_set2 = set(my_list)
my_set = set(a_list_to_convert)
### Appending a New Value ###
my_list.append("blue")
my_set.add("blue")
### Appending a Duplicate ###
my_list.append("blue")
# => my_list = ["red", "yellow", "green", "red", "blue", "blue"]
my_set.add("blue")
# => my_set = {"red", "yellow", "green", "blue"}
### Removing items: ###
my_list.pop(1)
my_set.remove("red")
```
---
## Discussion: Immutability Thoughts
A set is a type of list which doesn't allow duplicates.
What if, instead, we have a list we don't want to change?
```python
rainbow_colors = ("red", "orange", "yellow", "green", "blue", "indigo", "violet")
```
We **don't** want:
```python
rainbow_colors[0] = ("gray")
## Gray's not in the rainbow!
rainbow_colors.pop()
## We can't lose violet!
rainbow_colors.append("pink")
# Pink's not in the rainbow!
```
We want `rainbow_colors` to be **immutable** - the list _cannot_ be changed.
How we do that in Python?
---
## Introducing: Tuples
Sets are one specific type of list.
- No duplicates, but mutable.
**Tuples** are another specific type of list.
- Duplicates, but immutable.
- A list that _cannot_ be changed.
```python
rainbow_colors_tuple = ("red", "orange", "yellow", "green", "blue", "indigo", "violet")
```
When should you use a tuple?
- When you need data protection through immutability.
- When you never want to change the list.
---
## Tuple Syntax
- Created with parentheses `()`.
- Access values via indices (like regular lists, but *not* like sets).
```python
rainbow_colors_tuple = ("red", "orange", "yellow", "green", "blue", "indigo", "violet")
print(rainbow_colors[1])
# Prints "orange"
```
- Tuples can be printed with a `for` loop (just like a set or list!).
```python
rainbow_colors_tuple = ("red", "orange", "yellow", "green", "blue", "indigo", "violet")
for color in rainbow_colors_tuple:
print(color)
```
---
## We Do: Tuples
Let's declare a tuple named `seasons` and set it to have the values `fall`, `winter`, `spring`, and `summer`. We'll print the tuple and each value. Then we'll try to reassign them (we can't)!
---
## Quick Review: Sets, Tuples, Lists
**List**:
- The original, normal object: `["red", "red", "yellow", "green"]`.
- Has duplicates; mutable: `append()`, `insert(index)`, `pop()`, `pop(index)`
**Set**:
- List without duplicates: `{"red", "yellow", "green"}`.
- Mutable: `add()` and `remove(element)`
**Tuple**:
- Has duplicates, but immutable: You can't change it!
- `("red", "red", "yellow", "green")` will *always* be `("red", "red", "yellow", "green")`.
---
## Quick Review: Sets, Tuples, Lists
```python
### Creation ###
# List
my_list = ["red", "yellow", "green", "red"]
# Sets
my_set = {"red", "yellow", "green"}
my_set2 = set(my_list))
my_set = set(a_list_to_convert)
# Tuples
my_tuple = ("red", "yellow", "green")
### Appending a New Value ###
my_list.append("blue")
my_set.add("blue")
# Tuples -> You can't!
### Removing items: ###
my_list.pop(1)
my_set.remove("red")
# Tuples -> You can't!
```
---
## Introducing Types
Variables certainly can hold a lot!
- Sets, tuples, and lists are easily confused.
- `type()` tells us what a variable is: set, tuple, list, dictionary, integer, string - anything!
Try it:
---
## You Do: List Types Practice
Create a local file, `sets_tuples.py`. In it:
- Create a list (`[]`), set (`{}`), and tuple (`()`) of some of your favorite foods.
- Create a second set from the list.
Next, in every list type that you can:
- Add `"pizza"` anywhere; append `"eggs"` to the end.
- Remove `"pizza"`.
- Re-assign the element at index `1` to be `"popcorn"`.
- Remove the element at index `2` and re-insert it at index `0`.
- Print the element at index `0`.
Print your final lists using a loop, then print their types. Don't throw an error!
---
## Summary and Q&A
We've learned two new types of lists:
Sets:
- A mutable list without duplicates.
- Handy for storing emails, usernames, and other unique elements.
```python
email_set = {'my_email@gmail.com', 'second_email@yahoo.com', "third_email@hotmail.com"}
```
Tuples:
- An immutable list that allows duplicates.
- Handy for storing anything that won't change.
```python
rainbow_tuple = ("red", "orange", "yellow", "green", "blue", "indigo", "violet")
```
---
## Additional Reading
- [Repl.it that recaps Tuples](https://repl.it/@SuperTernary/python-programming-tuple-practice?lite=true)
- [Python Count Occurrences of Letters, Words and Numbers in Strings and Lists-Video](https://www.youtube.com/watch?v=szIFFw_Xl_M)
- [Storing Multiple Values in Lists](https://swcarpentry.github.io/python-novice-inflammation/03-lists/)
- [Sets and Frozen Sets](https://www.python-course.eu/sets_frozensets.php)
- [Sets](https://www.learnpython.org/en/Sets)
- [Python Tuple](https://www.programiz.com/python-programming/tuple)
- [Tuples](http://openbookproject.net/thinkcs/python/english3e/tuples.html)
- [Strings, Lists, Tuples, and Dictionaries Video](https://www.youtube.com/watch?v=19EfbO5D_8s)
- [Python Data Structures: Lists, Tuples, Sets, and Dictionaries Video](https://www.youtube.com/watch?v=R-HLU9Fl5ug)