NumPy Basics

Learn how to create, index, slice, and manipulate NumPy arrays for fast numerical operations.

14 minutesVideo LessonPDF notes

🎯 Free Guest Mode: You are learning for free. Sign in to save your completion progress and quiz answers.

Ready to continue?

Mark this lesson as complete when you're ready to proceed.

Key moments

NumPy Importance — NumPy is introduced as the essential, fast library for numerical Python used in data science and machine learning.
Basic Array Creation — The lesson demonstrates creating arrays filled with zeros and ones, noting that they default to float data types.
Linspace and Conversion — Arrays are created using `np.linspace` for evenly spaced values and `np.array` to convert existing Python lists.
Array Attributes and Help — The shape attribute is shown, along with tips for using the Tab key and question mark in Jupyter notebooks for help.
1D Indexing and Slicing — Basic indexing and slicing techniques are demonstrated, including using negative indices to access the last element.
Advanced 2D Slicing — Slicing is applied to a 2D image array to reverse rows, reverse columns, and extract specific sections of the data.
Universal Functions (UFuncs) — Mathematical functions like sine are applied element-wise across the entire array using broadcasting without loops.
Aggregation Methods — Common statistical methods are shown, including sum, mean, standard deviation, and finding the index of the minimum and maximum values.
Boolean Masking — Boolean masks are used to filter array elements based on a condition and to conditionally replace values using `np.where`.
Arithmetic and Transpose — Element-wise array arithmetic, the dot product (`@`), the transpose operation (`.T`), and array sorting are demonstrated.

PDF notes

Bottom line: You will be able to efficiently create, manipulate, and analyze numerical data using NumPy arrays, the foundation for data science in Python. You will learn to initialize arrays, perform fast element-wise operations (broadcasting), and use advanced indexing techniques like slicing and masking for data extraction.

This lesson on NumPy Basics is hands-on and example-driven. You will be able to efficiently create, manipulate, and analyze numerical data using NumPy arrays, the foundation for data science in Python. You will learn to initialize arrays, perform fast element-wise operations (broadcasting), and use advanced indexing techniques like slicing and masking for data extraction.

What You'll Be Able To Do

Import NumPy and initialize arrays using various methods (e.g., zeros, ones, linspace).
Access and modify array elements using 1D and 2D slicing and negative indexing.
Apply universal functions (ufuncs) and aggregation methods (e.g., sum, mean, std) across entire arrays.
Use Boolean masking to filter and conditionally modify array elements.
Calculate the dot product and transpose of NumPy arrays.

Detailed Concept Walkthrough

1. Creating NumPy Arrays

NumPy arrays (ndarrays) store homogeneous data efficiently, enabling faster numerical operations than standard Python lists. They are the core data structure for numerical computing.

Mechanism: Arrays can be created from existing Python lists using np.array() or initialized using built-in functions like np.zeros() or np.ones(). They can be 1D or multi-dimensional.
Under the Hood: Initialization functions like np.zeros default to creating elements of type float64, even if the input size is specified using integers.
Best Practice: Always import NumPy using the standard alias: import numpy as np to keep code concise and readable.
Mechanism: The np.linspace(start, stop, num) function is useful for creating arrays with a specified number of evenly spaced elements between a start and end point.

import numpy as np
# From list
a = np.array([1, 2, 3])
# Initialized 2x3 array of zeros
b = np.zeros((2, 3))

Key Takeaway: Use initialization functions (zeros, ones, linspace) for structured arrays and np.array() for converting existing lists.

2. Accessing Array Data

Indexing retrieves single elements, while slicing extracts contiguous subsets of the array, similar to Python lists but extended for multiple dimensions. Slicing creates a view, not a copy.

Mechanism: Use square brackets [] with comma separation for multi-dimensional arrays (e.g., arr[row_index, col_index]).
Best Practice: Slicing follows the format [start:stop:step]. Using a colon alone (:) selects all elements along that axis.
Mechanism: A negative step (e.g., ::-1) reverses the order of elements along the specified axis (rows or columns).
Nuance: For 2D data, the first index refers to the row (Y-axis) and the second refers to the column (X-axis).

import numpy as np
Z = np.array([[1, 2, 3], [4, 5, 6]])
# Get element at row 0, col 1
element = Z[0, 1]
# Reverse columns (mirror image)
reversed_cols = Z[:, ::-1]

Key Takeaway: Slicing allows powerful data extraction and manipulation across any dimension using start:stop:step notation.

3. Broadcasting and UFuncs

NumPy allows mathematical operations (Universal Functions or UFuncs) to be applied element-wise across entire arrays without explicit Python loops. This process, called broadcasting, is significantly faster.

Mechanism: Operations like addition, multiplication, or trigonometric functions (e.g., np.sin()) are applied to every element simultaneously.
Under the Hood: NumPy operations are implemented in optimized C code, bypassing the slow Python interpreter overhead for numerical tasks.
Mechanism: Scalar values added to an array are 'broadcast' to match the array's shape, applying the operation to every element.
Mechanism: Aggregation functions like np.sum(), np.mean(), and np.std() calculate statistics across all elements or along a specified axis.

import numpy as np
arr = np.array([1, 2, 3])
# Broadcasting scalar addition
result = arr + 30
# Element-wise multiplication
prod = arr * 10
# Aggregation
mean_val = arr.mean()

Key Takeaway: Avoid Python loops for numerical operations; use NumPy's built-in UFuncs and broadcasting for speed.

4. Conditional Filtering (Masking)

Boolean masking uses a conditional expression to generate a True/False array (the mask), which is then used to select or modify elements in the original array where the mask is True.

Mechanism: A comparison operation (e.g., arr > 3) returns a Boolean array of the same shape as the original array.
Mechanism: Applying the mask to the array (arr[mask]) extracts only the elements corresponding to True values, resulting in a 1D array.
Best Practice: Use np.where(condition, value_if_true, value_if_false) for conditional replacement, which is faster than indexing and assignment.
Application: Masking is essential for data cleaning and filtering, allowing complex selection criteria in a single line of code.

import numpy as np
a = np.array([1, 4, 2, 5])
# Filter array
filtered = a[a > 3]
# Conditional replacement
result = np.where(a > 3, 100, 0)

Key Takeaway: Boolean masking is the fastest way to filter and conditionally update data in NumPy arrays.

Topics Covered in NumPy Basics

NumPy Importance (0:00 - 0:30) — NumPy is introduced as the essential, fast library for numerical Python used in data science and machine learning.
Basic Array Creation (0:30 - 1:30) — The lesson demonstrates creating arrays filled with zeros and ones, noting that they default to float data types.
Linspace and Conversion (1:30 - 2:30) — Arrays are created using np.linspace for evenly spaced values and np.array to convert existing Python lists.
Array Attributes and Help (3:00 - 4:00) — The shape attribute is shown, along with tips for using the Tab key and question mark in Jupyter notebooks for help.
1D Indexing and Slicing (4:00 - 5:00) — Basic indexing and slicing techniques are demonstrated, including using negative indices to access the last element.
Advanced 2D Slicing (5:00 - 6:30) — Slicing is applied to a 2D image array to reverse rows, reverse columns, and extract specific sections of the data.
Universal Functions (UFuncs) (6:30 - 7:30) — Mathematical functions like sine are applied element-wise across the entire array using broadcasting without loops.
Aggregation Methods (7:30 - 8:30) — Common statistical methods are shown, including sum, mean, standard deviation, and finding the index of the minimum and maximum values.
Boolean Masking (8:30 - 9:30) — Boolean masks are used to filter array elements based on a condition and to conditionally replace values using np.where.
Arithmetic and Transpose (9:30 - 10:30) — Element-wise array arithmetic, the dot product (@), the transpose operation (.T), and array sorting are demonstrated.

Python Cheat Sheet

import numpy as np — Standard import alias for NumPy
```
import numpy as np
```
np.zeros(shape) — Creates array filled with floats
```
np.zeros((2, 2))
```
np.linspace(start, stop, num) — Creates evenly spaced range
```
np.linspace(2, 10, 5)
```
arr.shape — Returns dimensions of array
```
Z.shape
```
arr[start:stop:step] — Slices array elements
```
arr[0:2]
```
arr @ other_arr — Calculates the dot product
```
a @ b
```
arr.T — Returns the transpose (swaps axes)
```
Z.T
```
np.sort(arr) — Returns a sorted copy of the array
```
np.sort(a)
```

Comparison Table

Python List	NumPy Array (ndarray)	Key Difference
Slow for numerical tasks	Fast (optimized C code)	Performance
Heterogeneous data allowed	Homogeneous data required	Data Type
Requires loops for math	Uses broadcasting (element-wise)	Operations

Common Pitfalls

Mistake: Expecting np.zeros to create integers. Avoid: Specify dtype=int if integer elements are required.
Mistake: Using Python loops for array math. Avoid: Use NumPy UFuncs or broadcasting instead.
Mistake: Confusing array multiplication (*) with dot product (@). Avoid: Use * for element-wise, use @ for matrix multiplication.
Mistake: Forgetting that slicing creates a view. Avoid: Use .copy() if you need an independent array subset.

FAQs

Why is NumPy faster than standard Python lists? NumPy arrays store data contiguously in memory and operations are executed using highly optimized C code, avoiding Python interpreter overhead.
What is broadcasting? Broadcasting is the mechanism that allows NumPy to perform operations on arrays of different shapes, typically by stretching a smaller array (like a scalar) to match the larger array's dimensions.
How do I find documentation for a function in Jupyter? Type the function name followed by a question mark (e.g., np.array?) and execute the cell to view the docstring and parameters.

Common pitfalls

Mistake: Expecting `np.zeros` to create integers. Avoid: Specify `dtype=int` if integer elements are required.
Mistake: Using Python loops for array math. Avoid: Use NumPy UFuncs or broadcasting instead.
Mistake: Confusing array multiplication (`*`) with dot product (`@`). Avoid: Use `*` for element-wise, use `@` for matrix multiplication.
Mistake: Forgetting that slicing creates a view. Avoid: Use `.copy()` if you need an independent array subset.

hi guys Giles here and today I want to do a tutorial and I wanted to do a tutorial about numpy if you want to do data science on machine learning you're gonna need to know numpy numerical python it's one of the most useful libraries in python especially if you're crunching numbers why is it so good because it's fast you can crunch numbers much much faster than say using a Python list or Python loops and it's got so many built-in functions we're gonna do numpy in five minutes let's get five minutes on the screen come over here let's look at the computer and let's get started we will be doing this tutorial in jupiter notebooks I would highly recommend Jupiter notebooks if you don't have it installed and you want to know how to do that I've made a video about that but otherwise let's just get on with it we're going to be doing Python 3 and to begin with we need to import numpy as MP I mean actually to begin with we need to install numpy if you haven't done that you can do that using a pip install and it comes with anaconda anyway which I would definitely recommend so we important numpy as NP it is always imported as NP and to begin with I'm gonna show you how to create numpy arrays and numpy arrays are really important so there are several ways and we're gonna look at a few of them the first way is using this MP zeros you can do that and you will end up with something like this so it creates an umpire array populated with zeros those zeros are actually floats so if we have a look at well first of all if we have a look at the type of what we get here we get a numpy array and if we have a look at the type of the integer or the rather the number inside the array we see that it is a float so just bear that in mind when you when you create an umpire array this way you get floats inside the array we need to do this faster so we can create different sizes of arrays and this is an example of creating a slightly bigger array populated with zeros we can look at the shape of that array but we might want to change that shape if we do we can change that shape to ten by one which may well be a more useful shape and that's something to remember when you're using numpy arrays you might need to change the shape in fact you often need to change the shape you can also create an umpire a populated with ones and you can see that we've got floats there as well and just to prove that if we look at the type of Z in there of the numbers inside the array we can see that we get a float a slightly less common way of creating an array is this NP dot empty and this creates an empty array for us to fill then there's the linspace way of creating an array and what that does it creates a range with a starting point and end point and then the number of elements that you want this is very good a lot of the time if you're making plots or you want to create an x-axis for a graph I mean there are lots of other uses as well but that's just one example that I think you might encounter and here we've now created an array as you can see it's got five elements which is what we've specified it starts at two and goes up to ten and again these numbers inside this array are floats and that's just something to bear in mind I'm taking too long and the final way I'm gonna show you of creating an array in numpy is this MP dot array and that will create one where you put a list inside these brackets in fact you can also put the name of a list inside these brackets and that will also create an array and just to check that we have a numpy array we look at the type they're at it's a numpy array here is a two dimensional array created from a two dimensional Python list and you can see how that works there we can look at the shape of this array and I want to show you a couple of tips on Jupiter notebooks if you're looking for a particular function that you can apply to this array if you type the name of the array and then a dot and then the tab key all of the available functions will come up for you another useful thing is in Jupiter notebooks if you type question mark and then the name of the array you will get the docstring about you know what it is that you've got here this is a numpy array we'll give you the attributes and the parameters that you can apply to it and that is really useful you can also narrow this down so for example if you were to do question mark Z dot and then shape you just get the bit that was relevant to the parameter shape so just bear that in mind that's quite useful faster now you can create random arrays using the random dot Rand int method in numpy and we've preceded it here so if I were to do that with this I would get a random array and I just want to show you how you can access elements of an array you've seen this one before z1 is the name of the array and then in square brackets 0 this will give us the first element of the array which is 5 we can get a range by doing 0 : 2 and that gives us an array of that range there and if we want to get the last element at the array we can use minus 1 and all that's really similar to Python lists so if you're familiar with Python lists this won't seem too odd we're getting there we're getting there The Times ticking I know that it's not going to be 5 minutes all right it's not going to be 5 minutes it's gonna be longer what I want to do now is use a photo to show you other ways that you can slice up a numpy array because I think that visual element is really helpful I've got this photo of York Minster and I am just reading that in now as an umpire array and just to show you here type of photo is a numpy array let's find out a little bit more about that photo what's its shape well it's 324 rose by 574 columns and then it's a color image so we've got three channels of RGB let's now have a look at this photo and there you can see it so let's do some slicing on this photo just to see how this works so so start stop step the step is minus one so we're going backwards so we've reversed the rows in this image what will this give us comma colon colon - one let's have a look well we've got all of the rows and we have reversed the columns so we've got a mirror image because the columns are in the reverse order what else can we do well we can just take a section of this photos if we take the rows from 50 to 150 and the columns from 152 to 80 which is from here to about here we should just cut out this tower and if we do that and have a look we can see that's exactly what we've done numpy though numpy it's numpy you've got to learn numpy just keep learning number I know it's taking longer but it's numpy and if we were to take every other row and every other column we've halved the size of the image if you have a look now this goes to about 300 where it was almost 600 on the x axis and on the y axis it goes up to just over a hundred and sixty whereas before it was over 300 so we've taken every other row and every other column so I hope that gives you some insight into slicing now I want to show you about applying mathematical functions to a numpy array we'll be there soon I promise I promise we'll be there soon and you can do that by applying it to every element of the array by using these numpy methods so we have this photo here we know what that is if we wanted to take the sine of every element that made up the numpy array of this photo we could just do it like this and we've taken the sine of every single number now obviously it's not much use doing that to a photo but if that's your data and you needed to take a sign the sign of every element in your data that's a very quick way of doing you don't have to worry about loops you can just broadcast the whole thing across the numpy array so that's really quick and then there are loads of other things that you can do so you can take the sum of the array or the product that mean the standard deviation the variance the minimum the maximum you can get the arc min and the arc max so let's just have a look at that so the sum of all the elements in photo I is this the product of all the elements is 0 the mean value is this not long to go now and then you'll know numpy and that that'll be a great thing all right it will I promise I promise I really do the standard deviation is this the variance is this figure here the minimum value is 0 the maximum is 255 or we would expect that because this is an image the odd min gives you the index value of the minimum which is that one and the arc max gives you the index value of the maximum so you can do some very quick statistics using numpy arrays and and these methods in numpy so now we're going to create another numpy array this is 1 2 3 4 5 should it be taking this long let's get back to it and there are some interesting things you can do as well you can you can test for where this is lower than 3 and you get an array that is true true false false false and you can do the same with let's say greater than 3 and you get the reverse here you want the array where the array is greater than 3 and you get 4 & 5 so you can apply these masks to numpy arrays which can be really useful when you're handling data you know if you wanted to find all of the if you had a data set of heights for example you wanted to find all of the heights greater than a certain value this would be very easy you could do it in a line of code and you know and again it's much much quicker than using a loop in python so we're gonna do something with this photo now to show you this in action so MP where photo is greater than 100 we are going to replace it with 2 5 5 and where it isn't greater than 100 we're gonna replace it with 0 let's do that and let's have a look at what we get and we get this image here so we've taken a threshold of 100 and we've replaced everything that's over 100 with the value 255 and everything that's under 100 or 100 and under with zero more numpy that's what we need more numpy the time's running down but we need more numpy you know and we could change that threshold if we wanted to and if we look at the output now you know we get a different output other things that are useful to know about numpy is now let's take these two arrays we've got a array and b array we can add those together and if we do we just get each element added together to give us seven nine eleven thirteen and fifteen if we add 30 to this array it will add 30 to each element if we multiply these arrays it will multiply each corresponding element together and give us a new array of those new elements if we multiply one by ten so if we multiply a array by ten each element is multiplied by ten do we have enough numpy yet are you numpy it out have you had enough of numpy no let's get back to it and then if we use this at symbol here we get 130 and that gives us the dot product of these two arrays so that's a nice way of getting the dot product and I just wanted to show you one other thing as well this dot T which gives us the transpose of an array so what that does is it interchanges rows and columns and just to visualize that a bit better you can see that if we apply it to this photo that's what we get so that is the transpose of an array so in in photo terms it turns a landscape into a portrait and and that's what it does with data as well and I find that a useful way to visualize this and finally you can sort an array again without having to use loops you can use the inbuilt methods here and if you do that we take this array that's unsorted and we can sort it using MP dot sort and then the array name okay I'm sorry that wasn't five minutes I know it was longer but I think that's given you the basics of numpy and you can go off and really practice with it I hope that was useful if it was like the video subscribe to the channel share it as far and wide as you possibly can and I'll see you next time bye bye

Frequently asked questions

Why is NumPy faster than standard Python lists?

NumPy arrays store data contiguously in memory and operations are executed using highly optimized C code, avoiding Python interpreter overhead.

What is broadcasting?

Broadcasting is the mechanism that allows NumPy to perform operations on arrays of different shapes, typically by stretching a smaller array (like a scalar) to match the larger array's dimensions.

How do I find documentation for a function in Jupyter?

Type the function name followed by a question mark (e.g., `np.array?`) and execute the cell to view the docstring and parameters.

How was this lesson?

Your feedback helps us refine explanations and catch bugs.