3.7 NumPy 2: Linear Algebra

Linear algebra is the subject involving vector and matrix operations. NumPy makes linear algebra a lot easier, so let's find out how to use it to do what we discussed in the previous math lesson.


To perform addition/subtraction, we can use the + or - operator between two matrices. For example:

u = np.array([0, 1, 2])
v = np.array([1, 2, 3])

# w = [1, 3, 5]
w = u + v
# x = [-1, -1, -1]
x = u - v

The above code will create two NumPy arrays, and their sum is stored in w, while their difference is stored in x. If you had to do this without NumPy, things would be a lot harder. We can do the same for any -dimensional NumPy array as long as the arrays have the same dimensions.

Scalar Multiplication

To perform scalar multiplication, we just use the * operator between a scalar and a matrix. For example:

# z = [3, 6, 9]
z = 3 * np.array([1, 2, 3])

The above code stores the NumPy array in z.

Dot Product

The dot product is done by a in-built function: np.dot(x, y).

u = np.array([1, 2])
v = np.array([2, 3])

# z = 8
z = np.dot(u, v)


u = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
z = u + 1

# z = [2, 3, 4, 5, 6, 7, 8, 9, 10]

This is a bit of a unique operation that NumPy allows. Broadcasting allows us to add a number to every element of the array.

Matrix Multiplication

# returns a * b
np.dot(a, b)

The dot function from the NumPy library would just multiply inputs if you enter constants. If you input 1-dimensional NumPy arrays, it returns the dot product as discussed earlier. If you enter 2D NumPy arrays, the np.dot will multiply the two matrices together.

For example,

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

np.dot(a, b)

signifies the following multiplication:

Statistical Functions

NumPy arrays have some useful statistical functions as well. We'll discuss some of them here.


We can calculate the mean, or average, of all the elements in a numpy array using the .mean() method.


Minimum and Maximum


outputs the minimum element in the array, and


produces the maximum element in the array.


This is not exactly what you think of when you hear the word "sampling". The np.linspace() method returns a NumPy array that an array of "samples." Let's see what that means:

np.linspace(a, b, n)

Here, a represents the initial value, b represents the end value, and n represents the number of samples. As such, np.linspace(a, b, n) will return n numbers linearly spaced from a to b. Let's see an of how that works:

# [1, 2.3333, 3.6667, 5]
np.linspace(1, 5, 4)

However, linspace has a provision for an open interval as well. This means that the samples taken don't include the endpoint:

np.linspace(1,5,4,True): [1, 2.3333, 3.6667, 5]
np.linspace(1,5,4,False): [1, 2, 3, 4]

We'll often use linspace for plotting.


Finally, to take the transpose of an array, you can use the following code:


Provides the transpose of the NumpyArray


We will be using this in splitting up our data. The


function takes the dimensions of an array, and produces an array of the same size filled with random values between 0 and 1. We will use this as a way to split up data into slightly randomized categories.

And that's it! NumPy functionalities are not very easy to remember either, but you can refer back to this later.

Previous Section

Next Section

Add a page link block here (if there is no next section, delete this column)


Copyright © 2021 Code 4 Tomorrow. All rights reserved. The code in this course is licensed under the MIT License. If you would like to use content from any of our courses, you must obtain our explicit written permission and provide credit. Please contact classes@code4tomorrow.org for inquiries.