A dictionary is a data structure that holds pairs of associated data. In this lesson, you will learn how to create, manipulate, and use dictionaries in your Swift programs.

Dictionaries

Sometimes we need to update the values of our key-value pairs to ensure they contain relevant information. 

For example, if one of our contacts changes their phone number, we can go into our settings and update it to contain their new phone information.

While we can't change the name-value of our keys, we can change the value associated with them. With Swift, there are several ways we can change our values.

One option is to use subscript syntax to modify a value:
```pseudo
dictionaryName[Key] = NewValue
```
Suppose we had a dictionary called `musicGenre`:
```swift
var musicGenre = [
  "Duke Ellington": "Jazz",
  "Taylor Swift": "Country",
  "David Bowie": "Rock"
]
```
If we wanted to update the value associated with the key `"Taylor Swift"` using subscript syntax, our code would look like this:
```swift
musicGenre["Taylor Swift"] = "Pop"
```

We also have the option of changing our values using the `.updateValue()` method:
```pseudo
dictionaryName.updateValue(NewValue, forKey: Key)
```
The `.updateValue()` can be called on a dictionary and given two values. The first is the new value we want to associate with the key. The second value starts with `forKey:` followed by the key we are changing the value of. 

If we used the `.updateValue()` method to modify `"Taylor Swift"` in `musicGenre`, we could use this code:
```swift
musicGenre.updateValue("Pop", forKey: "Taylor Swift")
```

Updating Elements

When writing code, less is more. Programmers often try to keep their code as concise as possible to make their programs readable and efficient. 

Using _type inference_, the compiler can automatically determine the data type of a Swift expression. We can use type inference to declare dictionaries with less code.

When we first learned how to declare a dictionary, our code looked like this:
```swift
var fruitStand: [String: Int] = [
  "Apples": 12,
  "Bananas": 20
]
```
With type inference, we can initialize `fruitStand` with this syntax:
```swift
var fruitStand = [
  "Apples": 12,
  "Bananas": 20
]
```
We eliminated the type annotation `[String: Int]` from the initialization. 

With type inference, the compiler deduces that the keys are type `String` and the values are type `Int`.

To learn more about type inference, check out [Swift's Language Guide](https://docs.swift.org/swift-book/LanguageGuide/TheBasics.html#ID322).

Type Inference

We've used Swift's built-in properties, `.isEmpty` and `.count`, to gather information about arrays and sets.

Since dictionaries are also a collection type, we can use these properties with dictionaries too!

For example, the `.isEmpty` property will return a boolean value that denotes whether or not a dictionary is empty:
```pseudo
dictionaryName.isEmpty
```
* If the dictionary is empty, the expression will return `true`.
* If there are elements in the dictionary, the expression will return `false`.

Another useful property to use with dictionaries is `.count`. This property will return an integer that represents the number of elements contained within a dictionary:
```pseudo
dictionaryName.count
```

Let's take a look at these properties in action:
```swift
// Declare an empty dictionary
var pocketChange: [String: Int] = [:]

// Check if dictionary is empty
print(pocketChange.isEmpty)  // Prints: true

// Add a value to the dictionary
pocketChange["Nickel"] = 3  

// Check if dictionary is empty
print(pocketChange.isEmpty)  // Prints: false

// Print how many elements are in dictionary
print(pocketChange.count)    // Prints: 1
```

Inspecting a Dictionary

If we wanted to add a new key-value to a dictionary, we could use the following subscript syntax:

```pseudo
dictionaryName[NewKey] = NewValue
```

It is important to note that when adding new dictionary elements, the new key and value must match the data types of the dictionary it is being added to or else we will get an error.

Let's say we created a dictionary `donutPrices`:
```swift
var donutPrices = [
  "Strawberry": 2,
  "Chocolate": 3
]
```
We could add a third element to `donutPrices` using the following code:
```swift
donutPrices["Boston Cream"] = 4
```
If we were to `print()` the value of `donutPrices` our output would be something like:
```
["Strawberry": 2, "Chocolate": 3, "Boston Cream": 4]
```

Adding Elements

We can use loops to iterate through all of the elements of a dictionary! 

This is useful when we want to go through each individual key-value pair in a dictionary. For example, if we were the owners of a store, we may want to check the stock for every item we sell. 

If we wanted to loop through every key and value in a dictionary using a `for`-`in` loop, the syntax would look as follows:
```pseudo
for (keyHolder, valueHolder) in dictionaryName {
  // Body of loop
}
``` 
For our placeholder, since dictionaries have both keys and values, we group them together in parentheses `()` and separate them by a comma. 

Having two or more values wrapped in parentheses `()` and separated by commas `,` is called a _tuple_. To learn more about tuples, check out [Swift's Documentation](https://docs.swift.org/swift-book/ReferenceManual/Types.html#ID448).

Let's create a dictionary that stores the names and grades of individual students in a class. If we want to view each student's name and their grade, we would use the following code:
```swift
var classGrades = [
  "Raymond": 100,
  "Rosa": 82,
  "Jake": 73,
  "Terry": 90
]

for (name, grade) in classGrades {
  print("\(name) has a grade of \(grade)")
}
```
If we ran this code, we'd get something like the following output:
```
Rosa has a grade of 82
Raymond has a grade of 100
Jake has a grade of 73
Terry has a grade of 90
```

Iterating through a Dictionary

Data often comes in pairs.

On our phones' contact list, every name is associated with a phone number. When we go shopping for an item, it is marked with a price. Searching up a word in a dictionary will get us the definition.

In programming, paired data can be found in a dictionary.

A _dictionary_ is an unordered collection of paired data. The paired data is commonly referred to as a key-value pair in which a _key_ is a unique identifier for their associated _value_.

In our phones' contact list, every entry is like a key-value pair. The name of the contact would be considered the key and their associated number would be the value.

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

A treasure chest only opens when its associated key is used to unlock it.

Introduction to Dictionaries

We also have the option of creating dictionaries that are initialized with elements. In a dictionary, an element refers to a single key-value pair.

To create a populated dictionary, we will use dictionary literal syntax. A _dictionary literal_ is a collection of comma-separated key-value pairs.

The syntax to create a populated dictionary looks like this:
```pseudo
var dictionaryName: [KeyType: ValueType] = [
  Key1: Value1,
  Key2: Value2,
  Key3: Value3
]
```
* There is a type annotation for both the key and the value.
* Each key is unique.
* The keys and values must belong to their specified type.
* The key and the value are separated by a colon `:`.
* All of the elements are contained within brackets `[]`.
* Each key-value pair is separated by a comma `,`.

Let's create a dictionary called `fruitStand` that stores information about fruit stock:
```swift
var fruitStand: [String: Int] = [
  "Apples": 12,
  "Bananas": 20
]
```
* The keys are type `String` and the values are type `Int`.
* There are two key-value pairs in our dictionary.
* One pair has a key of `"Apples"` with a value of `12`.
* The other pair has a key of `"Bananas"` and a value of `20`.

If we use `print()` to output the value of `fruitStand`, we could get the following result:
```
["Bananas": 20, "Apples": 12]
```
Dictionaries are unordered- when we use `print()` to output a dictionary, the order of the elements may not appear in the order they were added in.


Creating a Dictionary Literal

Great job! In this lesson, we went over the following concepts:
* A dictionary is an unordered collection of key-value pairs.
* A key is a unique identifier used to create, update, remove, or access an associated value.
* We can create populated dictionaries using dictionary literals:
```swift
var dictionaryName = [Key1: Value1, Key2: Value2]
```
* An empty dictionary contains no key-values pairs. There are two methods of initializing an empty dictionary:
```swift
// Initializer Syntax:
var emptyInitializer = [KeyType: ValueType]()
// Dictionary Literal Syntax:
var emptyLiteral: [KeyType: ValueType] = [:]
```

* We can add elements to a dictionary using subscript syntax:
```swift
dictionaryName[NewKey] = NewValue
```
* We can remove dictionary elements using `.removeValue()` or by setting a key value to `nil`.
```swift
dictionaryName.removeValue(forKey: Key)
dictionaryName[Key] = nil
```
* We can remove all the values from a dictionary with `.removeAll()`.

* We can update the value of a key-value pair using subscript syntax or `.updateValue()`:
```swift
dictionaryName[Key] = NewValue
dictionaryName.updateValue(NewValue, forKey: Key)
```

* The `.isEmpty` property returns a boolean that equals true if a dictionary is empty.

* The `.count` property returns the number of elements contained within a dictionary.

* We can access a value using its key:
```swift
dictionaryName[Key]
```
* We can use `for`-`in` loops to iterate through the content of a dictionary:
```swift
for (KeyHolder, ValueHolder) in dictionaryName {
  // Add body
}
```
* We can use the `.keys` property to access only the keys of a dictionary.
* We can use the `.values` property to access only the values of a dictionary.

Review

There are several options for removing key-value pairs from a Swift dictionary.

In Swift, the keyword `nil` describes something as being empty or having no value. If we were to set the value of a key to `nil`, the key-value pair would be removed from the dictionary:
```pseudo
dictionaryName[Key] = nil
```
Consider the following dictionary `bookShelf` that stores key-value pairs of titles and authors for books we currently own:
```swift
var bookShelf = [
  "Goodnight Moon": "Margaret Wise Brown",
  "The BFG": "Roald Dahl",
  "Falling Up": "Shel Silverstein"
]
```
Imagine being part of a book drive and donating one of the books. To keep `bookShelf` accurate, let's remove the key-value pair `"The BFG"`: `"Roald Dahl"` by setting the value of `"The BFG"` to `nil`:
```swift
bookShelf["The BFG"] = nil
```

We can also remove a single key-value pair using the `.removeValue()` method:
```pseudo
dictionaryName.removeValue(forKey: Key)
```
The `.removeValue()` method takes a name of a key after `forKey:` to know which key-value pair to remove.

If we were to use the `.removeValue()` method to delete an element from `bookShelf`, our code would look like this: 
```swift
bookShelf.removeValue(forKey: "The BFG")
```

If we wanted to delete every key-value pair in a dictionary at once, we could use the `.removeAll()` method:
```pseudo
dictionaryName.removeAll()
```
Note how this method does not take any parameters; simply append `.removeAll()` to an existing dictionary.

If we needed to remove all the values in `bookShelf`, our syntax would be:
```swift
bookShelf.removeAll()
```

Removing Elements

What if we don't need to loop through both the keys and the values of a dictionary? We can use the properties `.keys` and `.values` to create collections of the keys and values of a dictionary that we can then loop through.

The `.keys` property stores a collection of dictionary keys, while the `.values` property stores a collection of dictionary values.

For example:
```swift
var fruitStand = [
  "Apples": 12,
  "Bananas": 20,
  "Oranges": 18
]
print(fruitStand.keys)
```
The `print()` statement in the above snippet will output the following keys:
```
["Bananas", "Oranges", "Apples"]
```
If we printed `fruitStand.values`, our output would include these values:
```
[20, 18, 12]
```
We can use these properties to specify how we want to iterate through a dictionary.

For example, if we only need the names of the fruits to create a list of what we sell, we can iterate through just the keys of `fruitStand` by appending `.keys` to the dictionary:
```swift
for fruit in fruitStand.keys {
  print(fruit)
}
```
This would give us an output similar to this:
```
"Oranges"
"Apples"
"Bananas"
```

We could append `.values` to `fruitStand` to loop through the values of our dictionary and find out the total number of fruit we have in stock:
```swift
var total = 0

for fruitStock in fruitStand.values {
  total += fruitStock
}

print(total)  // Prints: 50
```


Using .keys and .values

We've covered how to manipulate our dictionary and we can certainly print out the entire dictionary, but what if we want to access a single key-value pair?

After all, we shouldn't have to read through an entire dictionary to find a single definition (or scroll through all of our contacts to find a single phone number).

We can use subscript syntax to access the specific value associated with a key. For example, suppose we had the following dictionary `fruitNames`:
```swift
var fruitNames = [
  "mango": "Mangifera indica",
  "banana": "Musa paradisicum",
  "apple": "Pyrus malus"
]
```

If we wanted to extract the value associated with the key `"apple"` and assign it to a new variable called `appleScientific`, our code would look like this:
```swift
var appleScientific = fruitNames["apple"]
```
If we tried to print the value of `(appleScientific)`, we would get an output of:
```
Optional("Pyrus malus")
```
Swift returns an optional. The [optional type](https://developer.apple.com/documentation/swift/optional) is used in Swift when a value may not exist. For dictionaries, we might be trying to access a key that doesn't exist, so as a precaution we first get an optional instead of getting the exact value. 

There are two methods for extracting values from optionals.

If we aren't sure if a key exists within a dictionary, we can use an `if`-`let` statement:
```swift
if let appleScientific = fruitNames["apple"] {
  print(appleScientific)
} else {
  print("This key does not exist.")
}
```
`if`-`let` statements are used to check if a real value exists inside of an optional. If the value exists, the optional will be unwrapped and assigned to a variable.

If we are absolutely positive a key exists within a dictionary, we can add `!` at the end of the statement like so:
```swift
var appleScientific = fruitNames["apple"]!
```
Using `!` forces the compiler to unwrap an optional value and interpret the value as its appropriate data type; however, it should be noted that errors can occur when using `!` on a value that does not exist.

To read more about unwrapping optionals, check out [Swift's Language Guide](https://docs.swift.org/swift-book/documentation/the-swift-programming-language/thebasics/).

Accessing Values

We can create dictionaries that are initialized without any key-values pairs in it. A dictionary with no key-value pairs is also known as an _empty dictionary_.

This option is useful when we want to populate our dictionary at a later time. 

For instance, we can create a dictionary that keeps track of the names of our personal contacts and their phone numbers. Very likely, our dictionary will start off empty until we get the phone numbers of our contacts and save those key-value pairs. 

We can create an empty dictionary using empty dictionary literal syntax like this:
```pseudo
var dictionaryName: [KeyType: ValueType] = [:]
```
* We need to declare the data type of the keys and the values.
* After the assignment operator `=`, we use `[:]` to declare it's an empty dictionary.

We can also create an empty dictionary using initializer syntax:
```pseudo
var dictionaryName = [KeyType: ValueType]()
```
* We declare the key and value type after the assignment operator.
* We add parentheses `()` after declaring the data types.

Is there a major difference between these two methods? The answer is no! While [Swift's Documentation](https://docs.swift.org/swift-book/LanguageGuide/CollectionTypes.html) uses initializer syntax to declare an empty dictionary, there are no consequences of using one method over the other.
    
Let's create an empty dictionary called `yearlyPopulation` that contains `Int` type keys and `Int` type values.

Empty dictionary literal syntax:
```swift
var yearlyPopulation: [Int: Int] = [:]
```

Initializer syntax:
```swift
var yearlyPopulation = [Int: Int]()
```