# 7. Lists and Arrays¶

Before we do can do any data analysis, we must first collect a *data set*. For instance, if we want to get a good idea of the typical temperature in San Diego in December, we might collect a large number of recorded temperatures from the past several years. Naturally, we need some way of storing this collection of numbers. Of course, we could store each recorded temperature in its own variable:

```
temp_dec_01_2005 = 65
temp_dec_02_2005 = 68
temp_dec_03_2005 = 63
...
temp_dec_31_2020 = 71
```

This gets tedious quickly – can you imagine trying to compute the average temperature this way? Your code would look something like `(temp_dec_01_2005 + temp_dec_02_2005 + ...) / n_days`

, where `n_days`

is the number of days in the data set. Instead, we’ll use *container* data types – lists and arrays – that make it much easier to work with sequential data.

## 7.1. Lists¶

Python comes with a data type that is purpose-built for storing sequential data: the *list*. Creating a list in Python is done by surrounding a group of items with square brackets, `[ ]`

, and separating each item with a comma `,`

, like so:

```
temperatures = [65, 68, 63, 71]
temperatures
```

```
[65, 68, 63, 71]
```

Any type of data is allowed inside a list (including other lists), and you can include variables:

```
x = 42
random_stuff = ['oranges', x, True, [1, 2, 3]]
random_stuff
```

```
['oranges', 42, True, [1, 2, 3]]
```

Lists are their own data type:

```
type(random_stuff)
```

```
list
```

Python’s lists are versatile and easy to use, but code that uses lists can be *slow*. As data scientists, we will be working with sequences of millions, if not billions, of entries – so speed is of the essence. Therefore, will use another type of collection to store our sequential data: the *array*.

## 7.2. Arrays¶

Arrays are like lists in that they store sequential data, but they optimized for the types of heavy calculations done in data science. They are blazing fast, and memory-efficient.

Arrays aren’t included with Python, however.
Remember that Python wasn’t originally designed specifically for data scientists. Instead, it is a *general purpose* language, used by web developers, software engineers, artists, etc. So in order to give Python what it needs – a way of efficiently working with large sequences of numbers – a group of scientists independently developed an extension to Python called NumPy (short for “numeric python”).

Tip

In case you’re curious, it’s pronounced “num-pie”.

Among other thing, NumPy provides a fast array data type. To use NumPy arrays, we’ll need to import NumPy, just as we did with the `math`

module in the previous chapter:

```
import numpy as np
```

The notation `as np`

means that we are giving `numpy`

a new, shorter name that will be faster to type. Whenever we want to use a function from the `numpy`

package, such as the `sqrt`

function, we’ll write `np.sqrt`

instead of `numpy.sqrt`

.

Let’s create an array. We do so by calling the `np.array()`

function with a list of data:

```
temperatures = np.array([65, 68, 63, 71])
temperatures
```

```
array([65, 68, 63, 71])
```

Note the square brackets! The brackets appear because we are first creating a standard Python *list*. We then pass the list into the `np.array`

function as its only argument. In fact, we could create the same array in two steps:

```
# this is a list
temperatures_list = [65, 68, 63, 71]
# and this is an array
temperatures_array = np.array(temperatures_list)
temperatures_array
```

```
array([65, 68, 63, 71])
```

Warning

A common mistake is to write `np.array([temperatures_list])`

when attempting to create an array from a list. Do you see what is wrong with this? The square brackets are unnecessary! `temperatures_list`

is already a list, so by writing `[temperatures_list]`

, we are in fact creating a *list of lists*. The overall result is a two-dimensional array, which is probably not what you wanted. The right way to create an array from a list is to write `np.array(temperatures_list)`

.

Arrays are their own data type:

```
type(temperatures)
```

```
numpy.ndarray
```

The array we’ve created contains numbers, but arrays can also contain other types of data, like strings or bools. For example, we can make an array of strings:

```
np.array(['this', 'is', 'also', 'fine'])
```

```
array(['this', 'is', 'also', 'fine'], dtype='<U4')
```

*But* in order to maximize their efficiency, a single array should contain only a single data type. That is, we shouldn’t mix ints with strings, for example. In fact, numpy will sometimes do surprising things to make sure that all of an array’s elements have the same data type.
Remember what happened when we evaluated expressions that contained both ints and float? The result was always a float. The same thing will happen if we try to make an array containing both ints and floats:

```
np.array([1, 2, 3.0])
```

```
array([1., 2., 3.])
```

If you look carefully, you’ll see that there is a decimal after each number. Numpy has helpfully converted each of the numbers to floats – even the ones that were provided as ints.

The following example may be even more surprising:

```
np.array([1, 2, 3, 'banana'])
```

```
array(['1', '2', '3', 'banana'], dtype='<U21')
```

Numpy has “helpfully” converted the ints into strings so that all of the items in the list have the same type: string. Why did it convert the ints to strings instead of the string to an integer? There’s no natural way to convert “banana” into an integer, but 2 naturally becomes the string `"2"`

.

Sometimes it is useful to know how many elements are in an array. We can determine this with the `len`

function:

```
arr = np.array([1, 2, 3])
len(arr)
```

```
3
```

## 7.3. Array Functions and Methods¶

Numpy arrays are not only useful because of their speed and memory efficiency – they also come with plenty of helpful functions and methods for performing the most common data analysis operations, such as summing all of the entries of an array or computing their mean.

The NumPy functions can be called just like we called the math functions. Once we’ve imported the `numpy`

library (abbreviated as `np`

) we can just type `np.`

followed by a function name to access the function. For instance, you can use the `np.mean`

function to calculate the mean value of a sequence:

```
example_array = np.array([1, 1, 2, 3, 3])
np.mean(example_array)
```

```
2.0
```

There are many functions, such as the `np.diff`

function which calculates the difference between each consecutive pair of elements:

```
np.diff(example_array)
```

```
array([0, 1, 1, 0])
```

Just like strings, arrays also have special *methods* that can perform calculations. A few useful ones are shown below:

```
example_array.min()
```

```
1
```

```
example_array.max()
```

```
3
```

```
example_array.sum()
```

```
10
```

```
example_array.mean()
```

```
2.0
```

Don’t worry, you don’t need to memorize all of the different functions/methods (there are a lot!) – we’ll include references when necessary.

What is the difference between a *function* and a *method*? In short, a method is a function that is “attached” to a particular instance of a type, such as a particular array. An example of a function call is `np.diff(example_array)`

; an example of a method call is `example_array.min()`

. Notice that in the method call, the variable name comes first.

Numpy organizes its operations into function and methods. It isn’t always clear why something is a method and not a function, or *vice versa*. In fact, some operations are available *both* as functions and methods. For instance, numpy provides both a function and a method for computing the mean:

```
# mean, as a function
np.mean(example_array)
```

```
2.0
```

```
# mean, as a method
example_array.mean()
```

```
2.0
```

Methods are useful for a variety of reasons, one being that they enable a coding practice called **method chaining**. For example, suppose we wish to round each number in an array of floats and then compute their mean. We can use the `.round`

method to round each number in the array. Called with the argument of `0`

, it will round each number to zero decimal places (that is, to the nearest whole number):

```
arr = np.array([3.14, 2.71, 99.99])
rounded = np.round(arr, 0)
rounded
```

```
array([ 3., 3., 100.])
```

Then we can compute the mean with the `.mean()`

method:

```
rounded.mean()
```

```
35.333333333333336
```

We could have done this all in one line as follows:

```
arr.round(0).mean()
```

```
35.333333333333336
```

This works because the result of each method is returned and used for the next method. That is, `arr.round(0)`

returns an array of rounded numbers. This array is never given a name, but it is used for the next method call to `.mean()`

.

Method chaining is sometimes desirable because it concisely captures the “flow” of the calculation. We’ll see a lot of method chaining in the coming chapters.

### 7.3.1. Example¶

Every year, the programming community forum StackOverflow surveys its users, asking them such important questions as: what is your salary? and, how many computer monitors are on your desk at home? The results are publicly available. Since many of those who respond are data scientists, we can use the data to get an idea of a typical data scientist’s salary.

The variable `salaries`

is a NumPy array containing the salaries of every US-based data scientist in the survey. How many were there? We can answer that with `len`

:

```
len(salaries)
```

```
1117
```

What was the mean salary?

```
salaries.mean()
```

```
111032.657564906
```

Nice. What about the *median* salary?

```
salaries.median()
```

```
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
/tmp/nix-shell.IKXEjZ/ipykernel_4708/4231297940.py in <module>
----> 1 salaries.median()
AttributeError: 'numpy.ndarray' object has no attribute 'median'
```

Oops. It turns out that there is no method called “median” in numpy. There is, however, a `median`

function:

```
np.median(salaries)
```

```
100000.0
```

Notice that the median is about $10,000 less than the mean. As a data scientist would point out, the mean is more “sensitive to outliers”, meaning that a few people who make a very large amount of money can skew the mean. Let’s see what the largest salary is:

```
salaries.max()
```

```
2000000.0
```

2 million dollars! Remember, though: these salaries are *self-reported*. Presumably no one checked to make sure that they were *accurate*.

## 7.4. Accessing array items¶

An array is an *ordered sequence* of items. This means that there is a “first” element, a “second” element, and so on. Therefore, we can retrieve a particular element by providing its place in the order as a number known as the element’s **index** in the array. To do so, we write the array’s name followed by square brackets. Inside the square brackets, we place the index of the element we wish to retrieve. There’s one small catch: Python, like many programming languages but unlike most humans, starts counting from zero.

For example, let’s make a list of three names:

```
names = np.array(['Xanthippe', 'Yvonne', 'Zelda'])
names
```

```
array(['Xanthippe', 'Yvonne', 'Zelda'], dtype='<U9')
```

To get the first element out of the array, we use the following syntax:

```
names[0]
```

```
'Xanthippe'
```

To get the second, we write:

```
names[1]
```

```
'Yvonne'
```

And to get the third, we write:

```
names[2]
```

```
'Zelda'
```

How do we retrieve the last element of the list? We could use the list’s length, subtracted by one:

```
names[len(names) - 1]
```

```
'Zelda'
```

But this is a lot of typing! Instead, here’s a useful trick: if you use a negative number to retrieve an element, Python starts counting from the *back* of the array. So, for instance, to retrieve the last element we can also write:

```
names[-1]
```

```
'Zelda'
```

The array above has only three things in it, and their indices are 0, 1, and 2. What happens if we try to access the list at an index that doesn’t exist, such as 99?

```
names[99]
```

```
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
/tmp/nix-shell.IKXEjZ/ipykernel_4708/1824527913.py in <module>
----> 1 names[99]
IndexError: index 99 is out of bounds for axis 0 with size 3
```

It should also be noted that the same syntax works for retrieving elements from Python lists:

```
lst = ['hi', 'i', 'am', 'a', 'list']
lst[2]
```

```
'am'
```

## 7.5. Element-wise operations¶

When working with a data set we often want to perform the same operation on all of the data set’s elements at once. For example, given an array of temperatures in Fahrenheit, we might want to convert all of them to Celsius. Because of this, Numpy makes writing code that works with

```
array1 = np.array([1, 2, 3])
```

To subtract 3 from all of these numbers, we can simply write:

```
array1 - 3
```

```
array([-2, -1, 0])
```

To multiply each of the numbers by 2, we would write:

```
array1 * 2
```

```
array([2, 4, 6])
```

And so on. In practice this means we could do something like convert an entire array of temperatures measured in Fahrenheit to Celsius by writing a single expression:

```
temperatures_f = np.array([0.5, 32.0, 71.6, 212.0])
```

Remember that the formula for converting a measurement in Fahrenheit to Celsius is \(C = (F - 32) * (5/9)\). Therefore:

```
temperatures_c = (temperatures_f - 32) * (5 / 9)
temperatures_c
```

```
array([-17.5, 0. , 22. , 100. ])
```

In the above example, first `(temperatures_f - 32)`

is evaluated and produces an array with 32 subtracted from every temperature. Then `(5 / 9)`

is evaluated. Then then every element in the new array is multiplied by 5/9, producing the final output array.

We can also do element-wise operations between pairs of data from two arrays.

For this to work, both arrays must have the same size. The arrays are then lined up next to eachother, and the operation is performed between every corresponding pair of elements. This is best demonstrated with some examples:

```
array1 = np.array([1, 2, 3])
array2 = np.array([2, 4, 6])
```

```
array1 * array2
```

```
array([ 2, 8, 18])
```

```
array1 - array2
```

```
array([-1, -2, -3])
```

```
array1**array2
```

```
array([ 1, 16, 729])
```

Both paired element-wise operations and standalone element-wise operations can be used in the same expression, since we’re always producing another array as a result of each expression.

```
(array1 * 2) - array2
```

```
array([0, 0, 0])
```

Watch out for the new errors you might encounter! Let’s see what happens if our other array isn’t the same size.

```
array_short = np.array([2,4])
array1 * array_short
```

```
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
/tmp/nix-shell.IKXEjZ/ipykernel_4708/530016198.py in <module>
1 array_short = np.array([2,4])
----> 2 array1 * array_short
ValueError: operands could not be broadcast together with shapes (3,) (2,)
```

The error message is a little cryptic – what is this about “broadcasting”? Nevertheless, we can kind of understand that there is some issue with the “shape” of the two arrays not being compatible. In fact, this error is telling us that the first array has three elements but the other only has two, so the two arrays couldn’t be pushed into the same shape.

## 7.6. Ranges¶

Often times it’s useful to create an array of consecutive numbers, such as:

```
np.array([0, 1, 2, 3, 4, 5, 6, 7])
```

```
array([0, 1, 2, 3, 4, 5, 6, 7])
```

Rather than write this array by hand, we can use the `np.arange`

function to do it for us:

```
np.arange(8)
```

```
array([0, 1, 2, 3, 4, 5, 6, 7])
```

Notice that just like indices, ranges will start at zero by default and exclude the last number. So calling `np.arange(12)`

, for instance, will create an array with eleven elements whose first entry is 0 and whose last element is 11.

While we saw an example of the range function being called with one argument, it can be called with one, two, or three arguments:

`np.arange(endpoint)`

Consecutive integers from 1 to endpoint (exclusive)`np.arange(start, endpoint)`

Consecutive numbers from start to endpoint (exclusive), increasing by 1 each step.`np.arange(start, endpoint, stepsize)`

Consecutive numbers from start to endpoint (exclusive), changing by stepsize each step.

Some example might make this clearer:

```
np.arange(10)
```

```
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
```

```
np.arange(5.5, 10)
```

```
array([5.5, 6.5, 7.5, 8.5, 9.5])
```

```
np.arange(0, 1, 0.2)
```

```
array([0. , 0.2, 0.4, 0.6, 0.8])
```

```
np.arange(-1, -4)
```

```
array([], dtype=int64)
```

```
np.arange(-1, -4, -1)
```

```
array([-1, -2, -3])
```

The result of `np.arange`

is an array like any other, so we can write things like:

```
np.arange(5) + 3
```

```
array([3, 4, 5, 6, 7])
```

How would you use `np.arange`

to create the array containing the first 6 powers of 2: 1, 2, 4, 8, 16, and 32?

`2**np.arange(6)`

## 7.7. Summary¶

To get multiple pieces of data in one place, we create a

**collection**. If the collection is ordered then it is a**sequence**.Each item in a sequence has an

**index**– its position, starting at zero.**Lists**are the most basic sequence, and are created by surrounding a group of items with square brackets and separating each item by commas:`[item, item, ...]`

**Arrays**are a sequence type from the NumPy library, and are created by passing a list into the`np.array`

function:`np.array([item, item, ...])`

`np.array(my_list)`

NumPy offers lots of additional functions that can be called on sequences. These can be accessed using

`np.function_name(arguments, ...)`

.An item can be selected from an array by using brackets with the index of the item:

`my_array[index]`

Arrays support

**element-wise operations**, such as adding or multiplying all elements by a single number.Arrays of the same length support paired element-wise operations between the two arrays, such as adding or multiplying each element in one array with each element in the same position of another array.

An array of numbers with constant spacing can be easily constructed using

`np.arange`

A range will always

*exclude*the endpoint – so`np.arange(3)`

will count`0 1 2`

.