# 6.7. The Accumulator Pattern¶

Recall that an algorithm is a set of specific steps that, when followed, solve a problem.

A pattern is similar to an algorithm, but it can be used to solve many different types of problems. Think of a pattern like tying a knot—you can use the same steps to tie your shoelaces, a drawstring, the handles of a plastic bag, the ribbon on a present, etc. The pattern is the act of tying, and it is part of a larger solution (e.g. cleaning up after your dog). Often, a pattern makes up one piece of an algorithm.

Even though two algorithms can solve very different problems, the same pattern might be found in each one.

Let’s take a look at your first coding pattern.

## 6.7.1. Keeping a Running Total¶

Assume you are working at a theater, and your job is to count how many people walk through the front door. To help you keep track of the total, your boss gives you a counting tool. Every time a person walks in, you push a button and CLICK, the total displayed on the tool increases by 1.

This is an example of the accumulator pattern. Every time a particular event occurs, the value of a running total gets updated.

In programming, the accumulator pattern occurs VERY often. The key pieces to this pattern include:

1. A variable that starts at some basic value. For numbers, this value is usually `0` or `1`. For the `str` data type, begin with the empty string, `""` or `''`.

2. A loop.

3. Inside the loop, the value of the variable steadily increases (or decreases) with each iteration.

Let’s look at some code to see how the accumulator pattern works.

### 6.7.1.1. Adding `1...num`¶

Let’s write a program that adds up the numbers from 1 to `num`, where the variable `num` stores some integer.

If we did this with pencil and paper, finding the sum might look like this when `num = 6`:

```(1 + 2) + 3 + 4 + 5 + 6   # Calculate 1 + 2
(3 + 3) + 4 + 5 + 6       # Calculate 3 + 3
(6 + 4) + 5 + 6           # Calculate 6 + 4
(10 + 5) + 6              # Calculate 10 + 5
(15 + 6)                  # Calculate 15 + 6
21                        # Final result!
```

In each step, the running total is the first number, and it gets added to the next value in the series. As we move down the steps, we see the total increase from 1 to 3 to 6 etc.

For larger values of `num`, solving by hand gets tedious really fast. Loops to the rescue!

Example

 ```1 2 3 4 5 6 7``` ```num = 6 total = 0 for integer in range(1, num+1): total += integer print(total) ```

Console Output

```21
```
1. In line 2, we assign a value of `0` to the variable `total`.

2. Each time the loop repeats, the loop variable `integer` is assigned a new, higher value (1 to 6).

3. Each time line 5 runs, the current value of `integer` is added to `total`.

4. Once the loop ends, `total` contains the sum of all the individual values.

Note

Recall that with `range(start, end)`, the loop variable takes each value from `start` up to but NOT including `end`. This is why line 4 uses `range(1, num+1)`. We want to include the value of `num` as part of the iteration.

The loop carries out the same basic algorithm that we used to solve `1 + 2 + 3 + 4 + 5 + 6` by hand. When we do this on paper, we usually do not write down a running total for simple steps like 1 + 2. With programming, however, we must store this total in a variable.

The variable `total` is called the accumulator, which is a fancy way of saying that it gathers up all the individual integers one by one.

Tip

The key to using the accumulator pattern successfully is to define the accumulator variable before you start the loop. Once inside the loop, update the variable.

### 6.7.1.2. Building a String¶

The accumulator pattern also works on strings.

In the example below, we build a new string that contains only the vowels found in a different string.

Try It

Follow the given steps to build the program!

1. On line 3, define a variable called `only_vowels` and assign it the empty string, `''`. This will be the accumulator, and it will get larger as the loop runs.

2. On line 5, set up a `for` statement to loop through the characters in `some_text`.

 `5` ```for character in some_text: ```
3. Inside the loop, we want to check if `character` is a vowel. If `True`, add `character` to `only_vowels`. If `False`, do not update `only_vowels`. Paste this code into the loop. Remember to indent!

 ```6 7 8 9``` ```if character in 'aeiou': # Check if char is a lowercase vowel. only_vowels += character # If True, add char to only_vowels. print(only_vowels) ```
4. The `print` statement displays the value of `only_vowels` each time it changes, and this allows us to see how the accumulator pattern works as the loop repeats.

Properly done, the program should build up `only_vowels` as follows:

```o
oo
ooe
ooee
ooeee
ooeeea
ooeeeae
ooeeeaea
ooeeeaeae
```

Line 7 updates `only_vowels` with the `+=` operator. Each time the statement runs, it adds a new character to the end of the string stored in the variable.

Recall that `only_vowels += character` is a shortcut for the longer expression `only_vowels = only_vowels + character`. Is the order here important?

Try It!

Replace line 7 with `only_vowels = character + only_vowels` and run the program again. What happened?

By changing how we reassign the accumulator variable, we get different results.

## 6.7.2. Reversing a String¶

Let’s look at another program that takes any string, reverses the characters, and stores the new result in another variable.

Start by defining two variables—the string we want to reverse and a variable to store the new string.

Example

 ```1 2``` ```old_string = "blue" reversed_string = "" # This is our accumulator variable. ```

Next, we loop through all the characters in `old_string`. However, instead of adding each new character to the end of `reversed_string`, we add it to the beginning.

 ```1 2 3 4 5 6 7 8``` ```old_string = "blue" reversed_string = "" # This is our accumulator variable. for char in old_string: reversed_string = char + reversed_string # Line 5 adds reversed_string to the end of char. print(reversed_string) ```

Console Output

```eulb
```

Let’s break this program down step-by-step. This table shows the values of each of our variables after each loop iteration.

The accumulator pattern, step by step

Loop iteration

`char`

`reversed_string`

(before first iteration)

not defined

`""`

1

`"b"`

`"b"`

2

`"l"`

`"lb"`

3

`"u"`

`"ulb"`

4

`"e"`

`"eulb"`

## 6.7.3. Decreasing Total¶

The accumulator pattern can also be used to reduce the size of a running total.

Example

Run the program below several times using different values for `total` and `decrease_by`

Tip

Any of the operators `+=, -=, *=, /=` can be used in the accumulator pattern to update the variable.

Which operator you choose depends on the problem you need to solve.

Use this code sample to answer the following questions:

 ```1 2 3 4 5 6``` ```total = 0 for step in range(5): total += 2 print(total) ```

Question

What does the program print?

1. 0
2. 2
3. 5
4. 10

Question

What will print if you put `total = 0` inside the for loop but before `total += 2`?

1. 0
2. 2
3. 5
4. 10