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)


A set is an unordered collection of unique values. Learn how to create and use sets in Swift!

Sets

We can use different built-in properties to help us understand information about specific collection types, like sets or arrays, in our programs!

For example, we can use `.count` to find out how many elements are contained within a set:

```pseudo
setName.count
```
We learned about using `.count` with arrays. `.count` returns an `Int` value that represents the number of values stored inside of a specified set. 

For example, we can create a set to store the items we found in our lunchbox:
```swift
var lunchbox: Set = ["Apple", "Sandwich"]
```
Then, we could use `.count` to find out how many items we have in `lunchbox`:
```swift
print("I have \(lunchbox.count) items in my lunchbox!")

// Prints: I have 2 items in my lunchbox!
```

If we want to find out if our set is empty, we can use the `.isEmpty` property to check if there are values contained within our set. 
```pseudo
setName.isEmpty
```
* If there are no values in the set, the expression will return `true`. 
* If there are values, the expression will return `false`.

Let's revisit the set `instruments` and place `instruments.isEmpty` in the conditional of an `if` statement:
```swift
var instruments = Set<String>()

if instruments.isEmpty {
  print("Let's sign up for piano lessons!")
}
// Prints: Let's sign up for piano lessons!
```



.count and .isEmpty

Another set operation we can use is `.union()`. This operation creates a set by combining the values of two sets together.

The syntax for creating a set using `.union()` is:
```pseudo
var NewSet = SetA.union(SetB)
```
![.union()](https://content.codecademy.com/courses/learn-swift/sets/Swift_VennDiagrams_union.svg)

Consider the following sets `book1` and `book2` that contain the characters of different fairy tales:
```swift
var book1: Set = ["Pig 1", "Pig 2", "Pig 3", "Wolf"]

var book2: Set = ["Little Red Riding Hood", "Grandma", "Wolf"]
```
We can use `.union()` to combine all the characters into one set called `fairyTales`:
```swift
var fairyTales = book1.union(book2)
```
Imagine finding a third book, `book3`:
```swift
var book3: Set = ["Jack", "Blunderbore", "Beanstock"]
```
With set operations, we can combine multiple sets like this:
```swift
var fairyTales = book1.union(book2).union(book3)
```
Using multiple methods in the same line of code is known as _method chaining_. 

When we print `fairyTales`, we will get something similar to the following output:
```
["Blunderbore", "Pig 1", "Pig 2", "Little Red Riding Hood", "Pig 3", "Grandma", "Wolf", "Jack", "Beanstock"]
```
The element `"Wolf"` appeared in both `book1` and `book2`; however, the element only appears once in `fairyTales` because sets only contain unique elements.


Set Operations: .union()

Imagine walking through an art museum and finding two identical *Mona Lisa* paintings hanging on the wall. That situation would most likely cause a few raised eyebrows. Art museums should only contain unique content, like a set does in Swift.

A _set_ is an unordered collection of unique elements.

There are many similarities between sets and arrays, but the main differences between the two are: 
* Set elements cannot be repeated, while that is allowed in arrays.
* A set does not have a defined order, while an array does.

Sets are a great collection type to use when the data we need to store must be unique. 

For example, we could use a set in real life to store information about employee ID numbers at a company or to store bank account numbers.

In this lesson, we will learn how to create and use sets in Swift.

GIF of a group of letters that accepts only unique values.

Introduction to Sets

If we need to remove an element from a set, we can use `.remove()`.

This method can remove a single item from a set with the following syntax:
```pseudo
setName.remove(Value)
```
Let's revisit the set `plantShelf` from the previous exercise:
```swift
var plantShelf: Set = ["Haworthia", "Graptopetalum", "Echeveria", "Corpuscularia"]
```
Unfortunately, we overwatered the `"Haworthia"` plant, and it wilted away. 

To remove this value from `plantShelf` using `.remove()`, we can use this code:
```swift
plantShelf.remove("Haworthia")
```
If we tried to remove a value that didn't exist within the set `plantShelf`, like `"Astridia"`, the set would be unaffected.

If we wanted to remove every single element from a set, we could use the `.removeAll()` method:
```pseudo
setName.removeAll()
```
Let's say we are moving our plant collection over to the window sill. Removing all the values from `plantShelf` looks like this:
```swift
plantShelf.removeAll()
```
If we print the value of `plantShelf` after removing all the values, the output looks like this:
```
[]
```

Removing Elements

The `.symmetricDifference()` operation can be used to find elements that exist in one of the given sets, but not both.

The syntax for creating a set using `.symmetricDifference()` looks like this:
```pseudo
var NewSet = SetA.symmetricDifference(SetB)
```
![.symmetricDifference()](https://content.codecademy.com/courses/learn-swift/sets/Swift_VennDiagrams_symmetricDifference.svg)

The following sets `nintendoSwitch` and `playStation4` store `String` values of games that can be played on that specific console:
```swift
var nintendoSwitch: Set = ["Animal Crossing", "DOOM Eternal", "Stardew Valley"]

var playStation4: Set = ["DOOM Eternal", "Stardew Valley", "The Last of Us"]
```
To find which games are exclusive to only one console, we can use `.symmeticDifference()` to remove any values that appear in both `switchConsole` and `playStation4`:
```swift
var exclusiveGames = nintendoSwitch.symmetricDifference(playStation4)
```
If we `print()` the values contained within `exclusiveGames`, we would get something similar to the following output:
```
["Animal Crossing", "The Last of Us"]
```

Set Operations: .symmetricDifference()

If we want to check whether or not an element exists within a set, we can use the `.contains()` method.

We can use the following syntax to check for an element inside of a set:
```pseudo
setName.contains(Value)
```
* If the item exists within the set, the expression returns `true`.
* If the item does not appear in the set, the expression returns `false`.

Imagine we are hosting a party. Let's create a set for all the food we currently have in the house:
```swift
var foodAtHome: Set = ["Chips", "Guacamole", "Cookies", "Pizza Bagels"]
```
We are about to head to the store and want to check if we already have `"Salsa"` at home or if we need to buy more. 

We can use the following `if`/`else` statement with `foodAtHome.contains("Salsa")` as our conditional:
```swift
if foodAtHome.contains("Salsa") {
  print("We don't need any more salsa.")
} else {
  print("Let's buy more salsa.")
}

// Prints: Let's buy more salsa.
```

Checking For Elements

If we want to go through every individual value contained in a set, we can use a `for`-`in` loop!

To iterate over every item of a set, we can use this syntax:
```pseudo
for Value in setName {
  // Body of loop
}
```

Imagine we are making cookies. Let's create a set that stores the necessary ingredients for baking chocolate chip cookies:
```swift
var chocoChipCookies: Set = ["Flour", "Chocolate Chips", "Butter", "Eggs", "Sugar", "Baking Powder"]
```
We can use a `for`-`in` loop that will `print()` all the ingredients we need:
```swift
for ingredient in chocoChipCookies {
  print(ingredient)
}
```
Our placeholder, `ingredient`, stores the value of the current iteration. When we run this code, we will receive something similar to the following output:
```
Flour
Chocolate Chips
Eggs
Baking Powder
Butter
Sugar
```
Sets are unordered, so this output could look different every time we run our code.


Iterating Through a Set

In Swift, we can initialize sets that are either empty or populated with values. 

A set that has been initialized without any values inside of it is known as an _empty set_. Empty sets are useful when we aren't sure what specific data we are going store within our set yet.

The syntax for creating an empty set looks like this:
```pseudo
var setName = Set<Type>()
```
* To initialize a set, use the `Set` keyword followed by the data type of the elements it will contain. 
* To signify we are creating an empty set, add parentheses `()` at the end of the statement.

For example, we can create an empty set that will store the names of the types of instruments we play:
```swift
var instruments = Set<String>()
```
Note how we state that the values of this set will be type `String`. When we print this empty set, we will get the following output:
```
[]
```
We also have the option to create a populated set. Initializing a set with values is useful when we already know what data we want to store.

To create a populated set, we can use the following syntax:
```pseudo
var setName: Set = [Value1, Value2, Value3]
```
* We must use the `Set` keyword.
* All values must be contained within brackets `[]` and each value is separated by a comma `,`.
* There are no repeated values.
* The elements of the set must all be the same type.

If we wanted to create a set that stores members of the Swift team, our code would look like this:
```swift
var swiftTeam: Set = ["Galina", "Kenny", "Sonny", "Alex"]
```
Sets are unordered, meaning that the placement of an element in a set will not dictate how it is interpreted by the compiler. For example, if we tried to print the value of `swiftTeam`:
```swift
print(swiftTeam)
```
We could get the following output:
```
["Alex", "Galina", "Sonny", "Kenny"]
```
Notice how the order that the elements were printed is different than the order in which they were initialized. The order of execution in a set could look different every time a program is run.

Creating a Set

Great job completing this lesson!

Let's go over what we learned:
* A set is an unordered collection of unique elements.
* We have the option to initialize sets that are either empty or populated:
```swift
var emptySet = Set<Type>()
var populatedSet: Set = [Value1, Value2, Value3]
```
* To add new elements to a set, use the built-in method, `.insert(Value)`.

* We can remove a single element from a set using `.remove(Value)` or we can remove all the values from a set with `.removeAll()`:

* If we want to check if a value exists within a set, we can use the method `.contains(Value)` .

* A `for`-`in` loop can be used to iterate through all the values of a set:
```swift
for placeholder in setName {
  // Body of loop
}
```
* We can use set operations to modify or create new sets based on the data in two different sets.
* The `.intersection()` operation creates sets with values that overlap in two sets: 
```swift
soda.intersection(seltzer)
```
* The `.union()` operation combines all the values of two different sets:
```swift
ketchup.union(mayo)
```
* The operation `.symmetricDifference()` creates a set of items that appear in one set, but not both:
```swift
capulets.symmetricDifference(montagues)
```
* `.subtracting()` is a set operation that removes the overlapping data of one set from another:
```swift
milkshake.subtracting(iceCream)
```

Review

In Swift, we can use set operations to create new sets based on the data within two different sets! This is useful when we are working with multiple data sets.

We can use the `.intersection()` method to find matching values in two different sets:

![.intersection()](https://content.codecademy.com/courses/learn-swift/sets/Swift_VennDiagrams_intersection.svg)

```pseudo
var newSet = SetA.intersection(SetB)
```
* We append `.intersection()` to an existing set.
* We place the second set inside the parentheses `()`.
* We do not need to use the `Set` keyword when creating a set via set operations.

Let's say we had the following two sets that contain the names of continents in the northern and southern hemisphere:
```swift
var northHemisphere: Set = ["South America", "Europe", "North America", "Africa", "Asia"]

var southHemisphere: Set = ["Australia", "Antarctica", "Africa", "South America", "Asia"]
```
We can use `.intersection()` to create a set called `bothHemispheres` that contains continents that exist in both hemispheres:
```swift
var bothHemispheres = northHemisphere.intersection(southHemisphere)
```
If we use `print()` to output `bothHemispheres`, we would get this result:
```
["Asia", "South America", "Africa"]
```

Set Operations: .intersection()

Another set operation we can use is `.subtracting()`. This method creates a new set of elements by removing the overlapping data of one set from another set. 

To use `.subtracting()` in our program, we can use this code:
```pseudo
var newSet = SetA.subtracting(SetB)
```
Any values that `SetA` shares with `SetB` will be removed and `newSet` will contain values found only in `SetA` but not in `SetB`.

![.subtracting()](https://content.codecademy.com/courses/learn-swift/sets/Swift_VennDiagrams_subtracting.svg)

Consider the following sets: `animals` and `notEndangered`:
```swift
var animals: Set = ["Bison", "Mountain Gorilla", "Hedgehog", "Sea Turtle", "Vaquita", "Ocelot"]

var notEndangered: Set = ["Bison", "Hedgehog", "Ocelot"]
```
We can use `.subtracting()` to create a set of animals that are endangered based on the two sets above:
```swift
var endangered = animals.subtracting(notEndangered)
```
If we were to output the value of `endangered`, we would get something similar to these results:
```
["Vaquita", "Mountain Gorilla", "Sea Turtle"]
```

Set Operations: .subtracting()

If we want to add new elements to our set, we can use Swift's built-in `.insert()` method. 

Being able to augment our sets with new elements is useful when we have additional data to store or when we are ready to populate an empty set.

We can use `.insert()` to add elements to a set using this syntax:
```pseudo
setName.insert(NewValue)
``` 
When appending elements to a set:
* The set we are adding to must already exist.
* The new value must be the same data type that the set was initialized with.
* If we try to add an item that already exists, the item will still only appear once in the set.

Imagine we have a collection of plants:
```swift
var plantShelf: Set = ["Haworthia", "Corpuscularia", "Echeveria"]
```
After walking through a plant nursery, we are now the proud owners of a `"Graptopetalum"`. To reflect this change in our set, we can use the following code:
```swift
plantShelf.insert("Graptopetalum")
```
If we tried to print this set, our output will look like some variation of this:
```
["Haworthia", "Graptopetalum", "Echeveria", "Corpuscularia"]
```
