# 12.5. Accumulator Pattern with Dictionaries¶

We used the accumulator pattern to build up from an empty string or list, or to keep track of a running total.

Since dictionaries are just another type of collection, the accumulator pattern works with them as well.

## 12.5.1. Adding to an Empty Dictionary¶

We can add key/value pairs one at a time to an empty dictionary using bracket notation:

Example

Let’s create a dictionary that uses strings as key/value pairs.

 ```1 2 3 4 5 6 7 8``` ```eng_to_pirate = {} eng_to_pirate['Hello'] = 'Ahoy' eng_to_pirate['your'] = 'yer' eng_to_pirate['there'] = 'yonder' eng_to_pirate['element 18'] = 'Ar' print(eng_to_pirate) ```

Console Output

```{'Hello': 'Ahoy', 'your': 'yer', 'there': 'yonder', 'element 18': 'Ar'}
```

In lines 3 - 6, on the left hand side of the `=` operator we define the new keys for the `eng_to_pirate` dictionary. On the right hand side of the `=`, we place the value to assign to the key.

Each key is an English word, and its value is the related term in pirate-speak.

A more efficient way would be to use the accumulator pattern to add new key/value pairs. Recall that with lists and strings, the pattern adds only one new thing each time the loop repeats. For dictionaries, we need to add two items—a new key and a new value.

Let’s play with a couple of examples to practice this.

Try It!

The following program builds the `vowel_count` dictionary by adding a new key/value pair each time the loop repeats. Each character from the string `'aeiou'` becomes a key in the dictionary, which gets linked to an integer value.

1. Line 5 creates an empty dictionary and assigns it to the variable `vowel_counts`.

2. Line 7 creates a new key/value pair in `vowel_counts`. Each key is one character from `vowels`, and its value is how often that letter occurs in the `guide` string.

Now try:

1. Indent line 9 to put the `print` statement inside the loop. Run the program to see how `vowel_counts` grows each time the loop repeats.

2. Replace `guide` with `games` in line 7.

3. Use a different string in the `for` statement to count different letters or other characters. (As a good Python coder, you should change your variable names once you stop counting vowels).

The previous example took the characters from the string `'aeiou'` and turned them into dictionary keys. We used items from one collection (a string) to help us build a new dictionary.

The next example combines the elements of two lists into a single dictionary.

Try It!

Let’s build an English-to-pirate translation dictionary! We will use English words as keys and pirate words for the values.

Feel free to add your own words to each list! However, be sure to keep both lists the same length.

Note the following:

1. Since we pull elements from two different lists, we need to assign index values (0, 1, 2…) to the loop variable. This allows us to match the correct words from each list.

2. On line 9, `english_words[index]` accesses one element from the `english_words` list, and it uses that element to define a new key. For example, the first time through the loop, the left hand side of line 9 evaluates as:

1. `eng_to_pirate[english_words[index]]`

2. `eng_to_pirate[english_words]`

3. `eng_to_pirate['hello']`

3. The right hand side of line 9 uses the same index value, but it pulls an element from the `pirate_words` list:

1. `pirate_words[index]`

2. `pirate_words`

3. `'ahoy'`

4. For index value 0, line 9 reduces to `eng_to_pirate['hello'] = 'ahoy'`, and this adds the `'hello' : 'ahoy'` key/value pair to the `eng_to_pirate` dictionary.

## 12.5.2. Accumulate with an Exiting Dictionary¶

We can also use the accumulator pattern to perform an operation with the values in a dictionary.

Example

 ```1 2 3 4 5 6 7 8 9``` ```exam_scores = {'exam_1' : 95, 'exam_2' : 90.7, 'exam_3' : 88.3} total = 0 for key in exam_scores.keys(): total += exam_scores[key] average = total / len(exam_scores) rounded_average = round(average, 1) print("The average result is {0}%.".format(rounded_average)) ```

Console Output

```The average result is 91.3%.
```

Note the following:

1. In line 3, we define the accumulator variable `total` and assign it an initial value of `0`.

2. In line 4, we set the `for` statement to loop through the keys of the `exam_scores` dictionary.

3. Each time the loop repeats, line 5 increases `total` by the value linked to the current key. For example, the first time through the loop, line 5 operates this way:

1. `total += exam_scores[key]`

2. `total += exam_scores['exam_1']`

3. `total += 95`

4. `total = total + 95`

5. `total = 0 + 95`

6. `total = 95`

Question

What does the following program print?

 ```1 2 3 4 5 6 7 8``` ```my_animals = {"cats":10, "dogs":5, "elephants":25, "bears":20} total = 0 for key in my_animals: if len(key) > 4: total += my_animals[key] print(total) ```
1. 0
2. 25
3. 45
4. 60

Question

We want to code an accumulator that takes names and ticket numbers from two different lists, then uses that data to add key/value pairs to a dictionary.

The names should be the keys in the dictionary with the ticket numbers as their values.

Given the following statements:

 ```1 2 3 4 5 6``` ```names = ['Bob', 'Maria', 'Devon', 'Jessi'] ticket_numbers = [100, 101, 102, 103] ticket_holders = {} for index in range(len(names)): # Assignment statement here. ```

which of the following is the correct syntax for adding the key/value pairs to `ticket_holders`?

1. ticket_holders[index] = ticket_numbers[index]
2. ticket_holders[names[index]] = ticket_numbers[index]
3. ticket_holders[key] = ticket_numbers[value]
4. ticket_holders[key] = value