# Writing functions with lists

## Example: Accumulator Pattern

This example demonstrates the accumulator pattern. By accumulation, we mean calculating a single value as we iterate, like taking a sum or an average.

```
def get_sum(numbers):
total = 0
for number in numbers:
total = total + number
return total
result = get_sum([3, 5, 9]);
```

In the `get_sum()`

function, we initialize the `total`

variable to zero. Then,
each time we iterate through the numbers, we increase total by the current
number.

Here is a chart showing how this code updates the `number`

and `total`

variables
each time through the loop. Iteration number 0 is where we start before the
`for`

loop.

Iteration | number | total |
---|---|---|

0 | N/A | 0 |

1 | 3 | 3 |

2 | 5 | 8 |

3 | 9 | 17 |

At the end of the function, it returns the final value for `total`

, which is
`17`

.

We then get `result = 17`

after the function `get_sum()`

is done.

## Example: Mapping Pattern

This example illustrates the mapping pattern. By mapping we mean that we start
with a list and use its values to calculate and return a *new* list.

```
def bigger(numbers):
bigger_numbers = []
for number in numbers:
bigger = number * 2
bigger_numbers.append(bigger)
return bigger_numbers
result = bigger([4, 7, 11])
```

In the `bigger()`

function, the argument to the function is a list of numbers.
We want to create and return a new list of numbers that has all the original
numbers multiplied by 2.

We start by initializing a variable called `bigger_numbers`

to an empty list,
shown as `[]`

. Then, as we iterate through the list, we calculate a bigger
number and then append it to the list.

Here is a chart that shows each step of the iteration:

Iteration | number | bigger | bigger_numbers |
---|---|---|---|

0 | N/A | N/A | [] |

1 | 4 | 8 | [8] |

2 | 7 | 14 | [8, 14] |

3 | 11 | 22 | [8, 14, 22] |

At the end of the function, it returns the final value for `bigger_numbers`

,
which is `[8, 14, 22]`

.

We then get `result = [8, 14, 22]`

after the function `bigger_numbers()`

is
done.

## Example: Filter Pattern

This example illustrates the mapping pattern. By filter we mean that we start
with a list and use its values to calculate and return a *new* list that has
some or all of the original values.

```
def only_odds(numbers):
odds = []
for number in numbers:
if number % 2 != 0:
odds.append(number)
return odds
result = only_odds([2, 3, 4, 5])
```

This function takes a list of numbers and returns a new list that has only the odd numbers from the original list.

We start by initializing a variable `odds`

to an empty list. We then iterate
through the list and check if each number is odd. We can do this by using the
`mod`

operator, `%`

, which calculates the remainder, and check if the remainder
is zero. If it is not zero, then we have an odd number, so we can append it to
the list we store in the `odds`

variable.

The function finishes by returning `odds`

, so eventually the `result`

variable
will store `[3, 5]`

.

## Example: Selection Pattern

This example illustrates the selection pattern, which chooses a single value from a list, such as a minimum or maximum value.

```
def find_min(numbers):
smallest = None
for number in numbers:
if smallest is None or number < smallest:
smallest = number
return smallest
result = find_min([10, 8, 40, 22, 3, 5])
```

Here we are trying to calculate the minimum value of a list of numbers. We start
by initializing `smallest`

to `None`

, because there is no smallest number yet.
Then, when we iterate over the list, we do *two* checks with an `if`

statement.
First, we check if smallest is still `None`

. If it is, that means we havenâ€™t
found a smallest number yet, so the one we are currently looking at must be the
smallest. Second, we check if the current `number`

is smaller than `smallest`

.
If either of these checks succeeds, we set `smallest = number`

.

Here is a chart for the iterations of the loop:

Iteration | number | smallest |
---|---|---|

0 | N/A | None |

1 | 10 | 10 |

2 | 8 | 8 |

3 | 40 | 8 |

4 | 22 | 8 |

5 | 3 | 3 |

6 | 5 | 3 |

At the end, `result = 3`

.

Notice that if we ran this code:

`result = find_min([])`

then we would get `result = None`

.

## Example: Finding the average

This example uses the accumulator pattern again.

```
def average(numbers):
total = 0
for number in numbers:
total = total + number
return total / len(numbers)
result = average([1, 2, 3, 4])
```

We sum up all of the numbers, like did in `get_sum()`

, above. However, at the
end, instead of returning `total`

, we return `total / len(numbers)`

, which gives
us the average.