Learn the basic syntax and functionality of NumPy.

Introduction to NumPy

Typically, you won't be entering data directly into an array. Instead, you'll be importing the data from somewhere else.

We're able to transform CSV (comma-separated values) files into arrays using the `np.genfromtxt()` function:

Consider the following CSV, `sample.csv`,
```
34,9,12,11,7
```
We can import this into a NumPy array using the following code:

```py
csv_array = np.genfromtxt('sample.csv', delimiter=',')
```
Note that in this case, our file `sample.csv` has values separated by commas, so we use `delimiter=','`, but sometimes you'll find files with other delimiters, the most common being tabs or colons. 

Once imported, this CSV will create the array

```py
>>> csv_array
array([34, 9, 12, 11, 7])
```

Creating an Array from a CSV

Another useful thing that arrays can do is perform element-wise *logical operations*. For instance, suppose we want to know how many elements in an array are greater than 5. We can easily write some code that checks to see whether this statement evaluates to `True` for each item in the array, without having to use a `for` loop :

```py
>>> a = np.array([10, 2, 2, 4, 5, 3, 9, 8, 9, 7])
>>> a > 5
array([True, False, False, False, False, False, True, True, True, True], dtype=bool)
```

We can then use logical operators to evaluate and select items based on certain criteria. To select all elements from the previous array that are greater than 5, we'd write the following:

```py
>>> a[a > 5]
array([10, 9, 8, 9, 7])
```
We can also combine logical statements to further specify our criteria. To do so, we place each statement in parentheses and use boolean operators like `&` (and) and `|` (or). 

In our example, we can use combined statements to find the elements that are greater than five or less than two:

```py
>>> a[(a > 5) | (a < 2)]
array([10, 9, 8, 9, 7])
```

Logical Operations with Arrays

NumPy allows us to select elements from an array using their indices. Consider the one-dimensional array

```py
a = np.array([5, 2, 7, 0, 11])
```

If we wanted to select the first element in this array, we would call:

```py
>>> a[0]
5 
```

In typical Python fashion, the indices for an array start at `0`. This is known as _zero-indexed  numbering_. In the array above, 5 is known as the _zeroth_ element, `a[0]`. It follows that 2 is the first element, `a[1]`.

We can also select negative indices, which count from opposite end of the array and start at `-1`. This is particularly useful when you want to access the last element or two of an array:

```py
>>> a[-1]
11
>>> a[-2]
0
```

If we wanted to select multiple elements in the array, we can define a range, such as `a[1:3]`, which will select all the elements from `a[1]` to `a[3]`, *including* `a[1]` but *excluding* `a[3]`.
```py
>>> a[1:3]
array([2, 7])
```

Similarly, if we wanted to select all elements before `a[3]` we would use:

```py
>>> a[:3]
array([5, 2, 7])
```

 We can also use negative indices to select multiple elements. Let's say we want to select the last 3 elements in an array:

```py
>>> a[-3:]
array([7, 0, 11])
```

Notice that when we select multiple elements, we get an array.


Selecting Elements from a 1-D Array

Sarah records her second-grade class's grades in an online spreadsheet.  Her web browser records that she visited that spreadsheet, in addition to every other site she's visited. Those sites record her location, the time she spent on them, and where she visited next. The world is chock-full of all sorts of different datasets, and learning how to create, analyze, and manipulate these datasets can give us some insight and control over our digital surroundings.

In this lesson, we'll be constructing and manipulating  *single-variable* datasets. One way to think of a single-variable dataset is that it contains answers to a question. For instance, we might ask 100 people, “How tall are you?” Their heights in inches would form our dataset.

To work with our datasets, we'll be using a powerful Python module known as *NumPy*, which stands for Numerical Python.

NumPy has many uses including:

- Efficiently working with many numbers at once
- Generating random numbers
- Performing many different numerical functions (i.e., calculating sin, cos, tan, mean, median, etc.)

In the following exercises, we'll learn how to construct one- and two-dimensional arrays and perform basic array operations.

Introduction to NumPy: Numerical Python

Arrays can also be added to or subtracted from each other in NumPy, assuming the arrays have the same number of elements.

When adding or subtracting arrays in NumPy, each element will be added/subtracted to its matching element.

```py
>>> a = np.array([1, 2, 3, 4, 5])
>>> b = np.array([6, 7, 8, 9, 10])
>>> a + b
array([ 7,  9, 11, 13, 15])
```


Operations with NumPy Arrays II

In Python, we can create lists that are made up of other lists. Similarly, in NumPy we can create an array of arrays. If the arrays that make up our bigger array are all the same size, then it has a special name: a *two-dimensional array*. 

In the previous exercises we had stored the students' test scores in separate one-dimensional arrays for each test:

```py
test_1 = np.array([92, 94, 88, 91, 87])
test_2 = np.array([79, 100, 86, 93, 91])
test_3 = np.array([87, 85, 72, 90, 92])
```
But we could have also stored all of this data in a single, two-dimensional array:

```py
np.array([[92, 94, 88, 91, 87], 
          [79, 100, 86, 93, 91],
          [87, 85, 72, 90, 92]])
```
Here, each row represents a test, and each column represents a student. This allows us to store all of our data in a single array without losing any of its organization.

As we mentioned, a two-dimensional array is a list of lists where each list has the same number of elements. Here are some examples that are **not** two-dimensional arrays.

This code will run but it will **not** create a two-dimensional array because the lists have different numbers of elements:

```py
np.array([[29, 49,  6], 
          [77,  1]])
```

This code will **not** run because the `[]` for the outer lists are missing:
```py
np.array([68, 16, 73],
         [61, 79, 30])
```

Two-Dimensional Arrays

Generally, NumPy arrays are more efficient than lists. One reason is that they allow you to do *element-wise operations*. An element-wise operation allows you to quickly perform an operation, such as addition, on each element in an array.

Let's compare how to add a number to each value in a python list versus a NumPy array: 

```py
# With a list
l = [1, 2, 3, 4, 5]
l_plus_3 = []
for i in range(len(l)):
    l_plus_3.append(l[i] + 3)
```
```py
# With an array
a = np.array(l)
a_plus_3 = a + 3

```

As we can see, if we were to add 3 to every number in a list, we would have to use a `for` loop or a list comprehension. With an array, we can just add 3. The same is true for subtraction, multiplication, and division. 

We can also use NumPy Arrays to find the squares or square roots of each value.

Squaring each value:
```py
>>> a ** 2
array([ 1,  4,  9, 16, 25, 36])
```
(Note: `**` is the exponent notation in Python. For example, 3 squared can be calculated using 3 ** 2.)

Taking the square root of each value:
```py
>>> np.sqrt(a)
array([ 1, 1.41421356, 1.73205081, 2, 2.23606798, 2.44948974])
```

Operations with NumPy Arrays

Selecting elements from a 2-d array is very similar to selecting them from a 1-d array, we just have two indices to select from. The syntax for selecting from a 2-d array is `a[row,column]` where `a` is the array.

It's important to note that when we work with arrays that have more than one dimension, the relationship between the interior arrays is defined in terms of *axes*. A two-dimensional array has two axes: axis 0 represents the values that share the same indexical position (are in the same column), and axis 1 represents the values that share an array (are in the same row). This is illustrated below.

![Diagram showing the axes in an array](https://content.codecademy.com/courses/numpy/NumPy%20Array%20fixed.svg)

Consider the array
```py
a = np.array([[32, 15, 6, 9, 14], 
              [12, 10, 5, 23, 1],
              [2, 16, 13, 40, 37]])
```
 
We can select specific elements using their indices:
```py
>>> a[2,1]
16
```
Let's say we wanted to select an entire column, we can insert `:` as the row index:
```py
# selects the first column
>>> a[:,0]
array([32, 12,  2])
```

The same works if we want to select an entire row:
```py
# selects the second row
>>> a[1,:]
array([12, 10,  5, 23,  1])
```

We can further narrow it down and select a range from a specific row:
```py
# selects the first three elements of the first row
>>> a[0,0:3]
array([32, 15,  6])
```


Selecting Elements from a 2-D Array

NumPy includes a powerful data structure known as an *array*. A NumPy array is a special type of list.  It’s a data structure that organizes multiple items.  Each item can be of any type (strings, numbers, or even other arrays).

Arrays are most powerful when they are used to store numbers.  This is because arrays give us special ways of performing mathematical operations that are both simpler to write and more efficient computationally.  We’ll get more into this later.

A NumPy array looks a lot like a Python list:

```py
my_array = np.array([1, 2, 3, 4, 5, 6])
```

We can transform a regular list into a NumPy array by using `np.array()` and saving the value to a new variable:

```py
my_list = [1, 2, 3, 4, 5, 6]
my_array = np.array(my_list)
```

NumPy Arrays

Let's take a second and review. In this lesson, you learned the basics of the NumPy package. Here are some key points:

- Arrays are a special type of list that allows us to store values in an organized manner.
- An array can be created by either defining it directly using `np.array()` or by importing a CSV using `np.genfromtxt('file.csv', delimiter=',')`.
- An operation (such as addition) can be performed on every element in an array by simply performing it on the array itself.
- Elements can be selected from arrays using their index and array locations, both of which start at 0.
- Logical operations can be used to create new, more focused arrays out of larger arrays.

The next lesson will explore how to analyze these arrays and use means, medians, and standard deviations to tell a story. But first, practice what you've learned by working through the following checkpoints.

Review

To use NumPy with Python, import it at the top of your file using the following line:

```py
import numpy as np
``` 

Writing `as np` allows us to use `np` as a shorthand for NumPy, which saves us time when calling a NumPy function (less typing = fewer errors!) 