assignment array numpy

Nick McCullum

Software Developer & Professional Explainer

NumPy Indexing and Assignment

Hey - Nick here! This page is a free excerpt from my $199 course Python for Finance, which is 50% off for the next 50 students.

If you want the full course, click here to sign up.

In this lesson, we will explore indexing and assignment in NumPy arrays.

The Array I'll Be Using In This Lesson

As before, I will be using a specific array through this lesson. This time it will be generated using the np.random.rand method. Here's how I generated the array:

Here is the actual array:

To make this array easier to look at, I will round every element of the array to 2 decimal places using NumPy's round method:

Here's the new array:

How To Return A Specific Element From A NumPy Array

We can select (and return) a specific element from a NumPy array in the same way that we could using a normal Python list: using square brackets.

An example is below:

We can also reference multiple elements of a NumPy array using the colon operator. For example, the index [2:] selects every element from index 2 onwards. The index [:3] selects every element up to and excluding index 3. The index [2:4] returns every element from index 2 to index 4, excluding index 4. The higher endpoint is always excluded.

A few example of indexing using the colon operator are below.

Element Assignment in NumPy Arrays

We can assign new values to an element of a NumPy array using the = operator, just like regular python lists. A few examples are below (note that this is all one code block, which means that the element assignments are carried forward from step to step).

arr[2:5] = 0.5

Returns array([0. , 0. , 0.5, 0.5, 0.5])

As you can see, modifying second_new_array also changed the value of new_array .

Why is this?

By default, NumPy does not create a copy of an array when you reference the original array variable using the = assignment operator. Instead, it simply points the new variable to the old variable, which allows the second variable to make modification to the original variable - even if this is not your intention.

This may seem bizarre, but it does have a logical explanation. The purpose of array referencing is to conserve computing power. When working with large data sets, you would quickly run out of RAM if you created a new array every time you wanted to work with a slice of the array.

Fortunately, there is a workaround to array referencing. You can use the copy method to explicitly copy a NumPy array.

An example of this is below.

As you can see below, making modifications to the copied array does not alter the original.

So far in the lesson, we have only explored how to reference one-dimensional NumPy arrays. We will now explore the indexing of two-dimensional arrays.

Indexing Two-Dimensional NumPy Arrays

To start, let's create a two-dimensional NumPy array named mat :

There are two ways to index a two-dimensional NumPy array:

• mat[row, col]
• mat[row][col]

I personally prefer to index using the mat[row][col] nomenclature because it is easier to visualize in a step-by-step fashion. For example:

You can also generate sub-matrices from a two-dimensional NumPy array using this notation:

Array referencing also applies to two-dimensional arrays in NumPy, so be sure to use the copy method if you want to avoid inadvertently modifying an original array after saving a slice of it into a new variable name.

Conditional Selection Using NumPy Arrays

NumPy arrays support a feature called conditional selection , which allows you to generate a new array of boolean values that state whether each element within the array satisfies a particular if statement.

An example of this is below (I also re-created our original arr variable since its been awhile since we've seen it):

You can also generate a new array of values that satisfy this condition by passing the condition into the square brackets (just like we do for indexing).

An example of this is below:

Conditional selection can become significantly more complex than this. We will explore more examples in this section's associated practice problems.

In this lesson, we explored NumPy array indexing and assignment in thorough detail. We will solidify your knowledge of these concepts further by working through a batch of practice problems in the next section.

NumPy: Get and set values in an array using various indexing

This article explains how to get and set values, such as individual elements or subarrays (e.g., rows or columns), in a NumPy array ( ndarray ) using various indexing.

• Indexing on ndarrays — NumPy v1.26 Manual

Basics of selecting values in an ndarray

Specify with integers, specify with slices, specify with a list of boolean values: boolean indexing, specify with a list of integers: fancy indexing, combine different specification formats, assign new values to selected ranges, views and copies.

See the following articles for information on deleting, concatenating, and adding to ndarray .

• NumPy: Delete rows/columns from an array with np.delete()
• NumPy: Concatenate arrays with np.concatenate, np.stack, etc.
• NumPy: Insert elements, rows, and columns into an array with np.insert()

The NumPy version used in this article is as follows. Note that functionality may vary between versions.

Individual elements or subarrays (such as rows or columns) in an ndarray can be selected by specifying their positions or ranges in each dimension with commas, as in [○, ○, ○, ...] . The trailing : can be omitted, making [○, ○, :, :] equivalent to [○, ○] .

For a 2D array, [i] selects the ith row, and [:, i] selects the ith column (indexes start from 0 ). More details will be provided later.

Positions in each dimension can be specified not only as integers but also in other formats such as lists or slices, allowing for the selection of any subarray.

Positions (indexes) are specified as integers ( int ).

Indexes start from 0 , and negative values can be used to specify positions from the end ( -1 represents the last). Specifying a non-existent position results in an error.

The same applies to multi-dimensional arrays. Positions are specified for each dimension.

You can omit the specification of later dimensions.

In a 2D array, [i] , equivalent to [i, :] , selects the ith row as a 1D array, and [:, i] selects the ith column.

Ranges can be selected with slices ( start:end:step ).

• NumPy: Slicing ndarray

Example with a 1D array:

Example with a 2D array:

The trailing : can be omitted.

Using a slice i:i+1 selects a single row or column, preserving the array's dimensions, unlike selection with an integer ( int ), which reduces the dimensions.

• NumPy: Get the number of dimensions, shape, and size of ndarray

Slices preserve the original array's dimensions, while integers reduce them. This difference can affect outcomes or cause errors in operations like concatenation, even with the same range selected.

Specifying a list or ndarray of Boolean values ( True or False ) matching the dimensions' sizes selects True positions, similar to masking.

An error occurs if the sizes do not match.

Rows or columns can be extracted using a slice : .

Note that specifying a list of Boolean values for multiple dimensions simultaneously does not yield the expected result. Using np.ix_() is necessary.

• numpy.ix_ — NumPy v1.26 Manual

As with slices, selecting a range of width 1 (a single row or column) preserves the original array's number of dimensions.

A comparison on an ndarray yields a Boolean ndarray . Using this for indexing with [] selects True values, producing a flattened 1D array.

• NumPy: Compare two arrays element-wise

Specify multiple conditions using & (AND), | (OR), and ~ (NOT) with parentheses () . Using and , or , not , or omitting parentheses results in an error.

• How to fix "ValueError: The truth value ... is ambiguous" in NumPy, pandas

For methods of extracting rows or columns that meet certain conditions using Boolean indexing, refer to the following article.

• NumPy: Extract or delete elements, rows, and columns that satisfy the conditions

It is also possible to select ranges with a list or ndarray of integers.

Order can be inverted or repeated, and using negative values is allowed. Essentially, it involves creating a new array by selecting specific positions from the original array.

As with Boolean indexing, specifying lists for multiple dimensions simultaneously does not yield the expected result. Using np.ix_() is necessary.

As in the 1D example, the order can be inverted or repeated, and negative values are also permissible.

When selecting with a list of one element, the original array's number of dimensions is preserved, in contrast to specifying with an integer.

Different formats can be used to specify each dimension.

A combination of a list of Boolean values and a list of integers requires the use of np.ix_() .

Note that np.ix_() can only accept 1D lists or arrays.

For example, when specifying multiple lists for arrays of three dimensions or more, np.ix_() is required. However, it cannot be combined with integers or slices in the same selection operation.

Integers can be specified as lists containing a single element. In this case, the resulting array retains the same number of dimensions as the original ndarray .

You can use range() to achieve similar functionality as slices. For example, to simulate slicing, retrieve the size of the target dimension using the shape attribute and pass it to range() as in range(a.shape[n])[::] .

• How to use range() in Python

You can assign new values to selected ranges in an ndarray .

Specifying a scalar value on the right side assigns that value to all elements in the selected range on the left side.

Arrays can also be specified on the right side.

If the shape of the selected range on the left side matches that of the array on the right side, it is directly assigned. Non-contiguous locations pose no problem.

If the shape of the selected range on the left side does not match that of the array on the right side, it is assigned through broadcasting.

An error occurs if the shapes cannot be broadcast.

For more information on broadcasting, refer to the following article.

• NumPy: Broadcasting rules and examples

The specification format used for each dimension when selecting subarrays determines whether a view or a copy of the original array is returned.

For example, using slices returns a view.

Whether two arrays refer to the same memory can be checked using np.shares_memory() .

• NumPy: Views and copies of arrays

In the case of a view, changing the value in the selected subarray also changes the value in the original array, and vice versa.

Boolean indexing or fancy indexing returns a copy.

In this case, changing the value in the selected subarray does not affect the original array, and vice versa.

To create a copy of a subarray selected with a slice and process it separately from the original ndarray , use the copy() method.

When combining different specification formats, using Boolean or fancy indexing returns a copy.

Using integers and slices returns a view.

Related Categories

Related articles.

• NumPy: Functions ignoring NaN (np.nansum, np.nanmean, etc.)
• NumPy: Generate random numbers with np.random
• NumPy: Ellipsis (...) for ndarray
• List of NumPy articles
• NumPy: arange() and linspace() to generate evenly spaced values
• NumPy: Trigonometric functions (sin, cos, tan, arcsin, arccos, arctan)
• NumPy: np.sign(), np.signbit(), np.copysign()
• NumPy: Set the display format for ndarray
• NumPy: Meaning of the axis parameter (0, 1, -1)
• NumPy: Read and write CSV files (np.loadtxt, np.genfromtxt, np.savetxt)
• OpenCV, NumPy: Rotate and flip image
• NumPy: Set whether to print full or truncated ndarray
• NumPy: Calculate cumulative sum and product (np.cumsum, np.cumprod)

The text is released under the CC-BY-NC-ND license , and code is released under the MIT license . If you find this content useful, please consider supporting the work by buying the book !

The Basics of NumPy Arrays

< Understanding Data Types in Python | Contents | Computation on NumPy Arrays: Universal Functions >

Data manipulation in Python is nearly synonymous with NumPy array manipulation: even newer tools like Pandas ( Chapter 3 ) are built around the NumPy array. This section will present several examples of using NumPy array manipulation to access data and subarrays, and to split, reshape, and join the arrays. While the types of operations shown here may seem a bit dry and pedantic, they comprise the building blocks of many other examples used throughout the book. Get to know them well!

We'll cover a few categories of basic array manipulations here:

• Attributes of arrays : Determining the size, shape, memory consumption, and data types of arrays
• Indexing of arrays : Getting and setting the value of individual array elements
• Slicing of arrays : Getting and setting smaller subarrays within a larger array
• Reshaping of arrays : Changing the shape of a given array
• Joining and splitting of arrays : Combining multiple arrays into one, and splitting one array into many

NumPy Array Attributes ¶

First let's discuss some useful array attributes. We'll start by defining three random arrays, a one-dimensional, two-dimensional, and three-dimensional array. We'll use NumPy's random number generator, which we will seed with a set value in order to ensure that the same random arrays are generated each time this code is run:

Each array has attributes ndim (the number of dimensions), shape (the size of each dimension), and size (the total size of the array):

Another useful attribute is the dtype , the data type of the array (which we discussed previously in Understanding Data Types in Python ):

Other attributes include itemsize , which lists the size (in bytes) of each array element, and nbytes , which lists the total size (in bytes) of the array:

In general, we expect that nbytes is equal to itemsize times size .

Array Indexing: Accessing Single Elements ¶

If you are familiar with Python's standard list indexing, indexing in NumPy will feel quite familiar. In a one-dimensional array, the $i^{th}$ value (counting from zero) can be accessed by specifying the desired index in square brackets, just as with Python lists:

To index from the end of the array, you can use negative indices:

In a multi-dimensional array, items can be accessed using a comma-separated tuple of indices:

Values can also be modified using any of the above index notation:

Keep in mind that, unlike Python lists, NumPy arrays have a fixed type. This means, for example, that if you attempt to insert a floating-point value to an integer array, the value will be silently truncated. Don't be caught unaware by this behavior!

Array Slicing: Accessing Subarrays ¶

Just as we can use square brackets to access individual array elements, we can also use them to access subarrays with the slice notation, marked by the colon ( : ) character. The NumPy slicing syntax follows that of the standard Python list; to access a slice of an array x , use this:

If any of these are unspecified, they default to the values start=0 , stop= size of dimension , step=1 . We'll take a look at accessing sub-arrays in one dimension and in multiple dimensions.

One-dimensional subarrays ¶

A potentially confusing case is when the step value is negative. In this case, the defaults for start and stop are swapped. This becomes a convenient way to reverse an array:

Multi-dimensional subarrays ¶

Multi-dimensional slices work in the same way, with multiple slices separated by commas. For example:

Finally, subarray dimensions can even be reversed together:

Accessing array rows and columns ¶

One commonly needed routine is accessing of single rows or columns of an array. This can be done by combining indexing and slicing, using an empty slice marked by a single colon ( : ):

In the case of row access, the empty slice can be omitted for a more compact syntax:

Subarrays as no-copy views ¶

One important–and extremely useful–thing to know about array slices is that they return views rather than copies of the array data. This is one area in which NumPy array slicing differs from Python list slicing: in lists, slices will be copies. Consider our two-dimensional array from before:

Let's extract a $2 \times 2$ subarray from this:

Now if we modify this subarray, we'll see that the original array is changed! Observe:

This default behavior is actually quite useful: it means that when we work with large datasets, we can access and process pieces of these datasets without the need to copy the underlying data buffer.

Creating copies of arrays ¶

Despite the nice features of array views, it is sometimes useful to instead explicitly copy the data within an array or a subarray. This can be most easily done with the copy() method:

If we now modify this subarray, the original array is not touched:

Reshaping of Arrays ¶

Another useful type of operation is reshaping of arrays. The most flexible way of doing this is with the reshape method. For example, if you want to put the numbers 1 through 9 in a $3 \times 3$ grid, you can do the following:

Note that for this to work, the size of the initial array must match the size of the reshaped array. Where possible, the reshape method will use a no-copy view of the initial array, but with non-contiguous memory buffers this is not always the case.

Another common reshaping pattern is the conversion of a one-dimensional array into a two-dimensional row or column matrix. This can be done with the reshape method, or more easily done by making use of the newaxis keyword within a slice operation:

We will see this type of transformation often throughout the remainder of the book.

Array Concatenation and Splitting ¶

All of the preceding routines worked on single arrays. It's also possible to combine multiple arrays into one, and to conversely split a single array into multiple arrays. We'll take a look at those operations here.

Concatenation of arrays ¶

Concatenation, or joining of two arrays in NumPy, is primarily accomplished using the routines np.concatenate , np.vstack , and np.hstack . np.concatenate takes a tuple or list of arrays as its first argument, as we can see here:

You can also concatenate more than two arrays at once:

It can also be used for two-dimensional arrays:

For working with arrays of mixed dimensions, it can be clearer to use the np.vstack (vertical stack) and np.hstack (horizontal stack) functions:

Similary, np.dstack will stack arrays along the third axis.

Splitting of arrays ¶

The opposite of concatenation is splitting, which is implemented by the functions np.split , np.hsplit , and np.vsplit . For each of these, we can pass a list of indices giving the split points:

Notice that N split-points, leads to N + 1 subarrays. The related functions np.hsplit and np.vsplit are similar:

Similarly, np.dsplit will split arrays along the third axis.

Python Numerical Methods

This notebook contains an excerpt from the Python Programming and Numerical Methods - A Guide for Engineers and Scientists , the content is also available at Berkeley Python Numerical Methods .

The copyright of the book belongs to Elsevier. We also have this interactive book online for a better learning experience. The code is released under the MIT license . If you find this content useful, please consider supporting the work on Elsevier or Amazon !

< 2.6 Data Structure - Dictionaries | Contents | 2.8 Summary and Problems >

Introducing Numpy Arrays ¶

In the 2nd part of this book, we will study the numerical methods by using Python. We will use array/matrix a lot later in the book. Therefore, here we are going to introduce the most common way to handle arrays in Python using the Numpy module . Numpy is probably the most fundamental numerical computing module in Python.

NumPy is important in scientific computing, it is coded both in Python and C (for speed). On its website, a few important features for Numpy is listed:

a powerful N-dimensional array object

sophisticated (broadcasting) functions

tools for integrating C/C++ and Fortran code

useful linear algebra, Fourier transform, and random number capabilities

Here we will only introduce you the Numpy array which is related to the data structure, but we will gradually touch on other aspects of Numpy in the following chapters.

In order to use Numpy module, we need to import it first. A conventional way to import it is to use “np” as a shortened name.

WARNING! Of course, you could call it any name, but conventionally, “np” is accepted by the whole community and it is a good practice to use it for obvious purposes.

To define an array in Python, you could use the np.array function to convert a list.

TRY IT! Create the following arrays:

\(x = \begin{pmatrix} 1 & 4 & 3 \\ \end{pmatrix}\)

\(y = \begin{pmatrix} 1 & 4 & 3 \\ 9 & 2 & 7 \\ \end{pmatrix}\)

NOTE! A 2-D array could use a nested lists to represent, with the inner list represent each row.

Many times we would like to know the size or length of an array. The array shape attribute is called on an array M and returns a 2 × 3 array where the first element is the number of rows in the matrix M and the second element is the number of columns in M. Note that the output of the shape attribute is a tuple. The size attribute is called on an array M and returns the total number of elements in matrix M.

TRY IT! Find the rows, columns and the total size for array y.

NOTE! You may notice the difference that we only use y.shape instead of y.shape() , this is because shape is an attribute rather than a method in this array object. We will introduce more of the object-oriented programming in a later chapter. For now, you need to remember that when we call a method in an object, we need to use the parentheses, while the attribute don’t.

Very often we would like to generate arrays that have a structure or pattern. For instance, we may wish to create the array z = [1 2 3 … 2000]. It would be very cumbersome to type the entire description of z into Python. For generating arrays that are in order and evenly spaced, it is useful to use the arange function in Numpy.

TRY IT! Create an array z from 1 to 2000 with an increment 1.

Using the np.arange , we could create z easily. The first two numbers are the start and end of the sequence, and the last one is the increment. Since it is very common to have an increment of 1, if an increment is not specified, Python will use a default value of 1. Therefore np.arange(1, 2000) will have the same result as np.arange(1, 2000, 1) . Negative or noninteger increments can also be used. If the increment “misses” the last value, it will only extend until the value just before the ending value. For example, x = np.arange(1,8,2) would be [1, 3, 5, 7].

TRY IT! Generate an array with [0.5, 1, 1.5, 2, 2.5].

Sometimes we want to guarantee a start and end point for an array but still have evenly spaced elements. For instance, we may want an array that starts at 1, ends at 8, and has exactly 10 elements. For this purpose you can use the function np.linspace . linspace takes three input values separated by commas. So A = linspace(a,b,n) generates an array of n equally spaced elements starting from a and ending at b.

TRY IT! Use linspace to generate an array starting at 3, ending at 9, and containing 10 elements.

Getting access to the 1D numpy array is similar to what we described for lists or tuples, it has an index to indicate the location. For example:

For 2D arrays, it is slightly different, since we have rows and columns. To get access to the data in a 2D array M, we need to use M[r, c], that the row r and column c are separated by comma. This is referred to as array indexing. The r and c could be single number, a list and so on. If you only think about the row index or the column index, than it is similar to the 1D array. Let’s use the \(y = \begin{pmatrix} 1 & 4 & 3 \\ 9 & 2 & 7 \\ \end{pmatrix}\) as an example.

TRY IT! Get the element at first row and 2nd column of array y .

TRY IT! Get the first row of array y .

TRY IT! Get the last column of array y .

TRY IT! Get the first and third column of array y .

There are some predefined arrays that are really useful. For example, the np.zeros , np.ones , and np.empty are 3 useful functions. Let’s see the examples.

TRY IT! Generate a 3 by 5 array with all the as 0.

TRY IT! Generate a 5 by 3 array with all the element as 1.

NOTE! The shape of the array is defined in a tuple with row as the first item, and column as the second. If you only need a 1D array, then it could be only one number as the input: np.ones(5) .

TRY IT! Generate a 1D empty array with 3 elements.

NOTE! The empty array is not really empty, it is filled with random very small numbers.

You can reassign a value of an array by using array indexing and the assignment operator. You can reassign multiple elements to a single number using array indexing on the left side. You can also reassign multiple elements of an array as long as both the number of elements being assigned and the number of elements assigned is the same. You can create an array using array indexing.

TRY IT! Let a = [1, 2, 3, 4, 5, 6]. Reassign the fourth element of A to 7. Reassign the first, second, and thrid elements to 1. Reassign the second, third, and fourth elements to 9, 8, and 7.

TRY IT! Create a zero array b with shape 2 by 2, and set \(b = \begin{pmatrix} 1 & 2 \\ 3 & 4 \\ \end{pmatrix}\) using array indexing.

WARNING! Although you can create an array from scratch using indexing, we do not advise it. It can confuse you and errors will be harder to find in your code later. For example, b[1, 1] = 1 will give the result \(b = \begin{pmatrix} 0 & 0 \\ 0 & 1 \\ \end{pmatrix}\) , which is strange because b[0, 0], b[0, 1], and b[1, 0] were never specified.

Basic arithmetic is defined for arrays. However, there are operations between a scalar (a single number) and an array and operations between two arrays. We will start with operations between a scalar and an array. To illustrate, let c be a scalar, and b be a matrix.

b + c , b − c , b * c and b / c adds a to every element of b, subtracts c from every element of b, multiplies every element of b by c, and divides every element of b by c, respectively.

TRY IT! Let \(b = \begin{pmatrix} 1 & 2 \\ 3 & 4 \\ \end{pmatrix}\) . Add and substract 2 from b. Multiply and divide b by 2. Square every element of b. Let c be a scalar. On your own, verify the reflexivity of scalar addition and multiplication: b + c = c + b and cb = bc.

Describing operations between two matrices is more complicated. Let b and d be two matrices of the same size. b − d takes every element of b and subtracts the corresponding element of d. Similarly, b + d adds every element of d to the corresponding element of b.

TRY IT! Let \(b = \begin{pmatrix} 1 & 2 \\ 3 & 4 \\ \end{pmatrix}\) and \(d = \begin{pmatrix} 3 & 4 \\ 5 & 6 \\ \end{pmatrix}\) . Compute b + d and b - d.

There are two different kinds of matrix multiplication (and division). There is element-by-element matrix multiplication and standard matrix multiplication. For this section, we will only show how element-by-element matrix multiplication and division work. Standard matrix multiplication will be described in later chapter on Linear Algebra. Python takes the * symbol to mean element-by-element multiplication. For matrices b and d of the same size, b * d takes every element of b and multiplies it by the corresponding element of d. The same is true for / and **.

TRY IT! Compute b * d, b / d, and b**d.

The transpose of an array, b, is an array, d, where b[i, j] = d[j, i]. In other words, the transpose switches the rows and the columns of b. You can transpose an array in Python using the array method T .

TRY IT! Compute the transpose of array b.

Numpy has many arithmetic functions, such as sin, cos, etc., can take arrays as input arguments. The output is the function evaluated for every element of the input array. A function that takes an array as input and performs the function on it is said to be vectorized .

TRY IT! Compute np.sqrt for x = [1, 4, 9, 16].

Logical operations are only defined between a scalar and an array and between two arrays of the same size. Between a scalar and an array, the logical operation is conducted between the scalar and each element of the array. Between two arrays, the logical operation is conducted element-by-element.

TRY IT! Check which elements of the array x = [1, 2, 4, 5, 9, 3] are larger than 3. Check which elements in x are larger than the corresponding element in y = [0, 2, 3, 1, 2, 3].

Python can index elements of an array that satisfy a logical expression.

TRY IT! Let x be the same array as in the previous example. Create a variable y that contains all the elements of x that are strictly bigger than 3. Assign all the values of x that are bigger than 3, the value 0.

How to Use Slice Assignment in NumPy?

NumPy slice assignment allows you to use slicing on the left-hand side of an assignment operation to overwrite a specific subsequence of a NumPy array at once. The right side of the slice assignment operation provides the exact number of elements to replace the selected slice. For example, a[::2] = [...] would overwrite every other value of NumPy array a .

Here’s a minimal example of slice assignment:

The NumPy slice assignment operation doesn’t need the same shape on the left and right side because NumPy will use broadcasting to bring the array-like data structure providing the replacement data values into the same shape as the array to be overwritten.

The next example shows how to replace every other value of a 1D array with the same value. The left and right operands don’t have the same array shape—but NumPy figures it out through broadcasting .

For 2D arrays, you can use the advanced slice notation —selection comma-separated by axis—to replace whole columns like so:

Let’s dive into a practical example about NumPy slice assignments from my Python One-Liners book next. Take your time to study it and watch the explainer video to polish your NumPy slicing skills once and for all.

Practical Example Slice Assignment NumPy

Real-world data is seldomly clean: It may contain errors because of faulty sensor, or it may contain missing data because of damaged sensors. In this one-liner example, you learn about how to quickly handle smaller cleaning tasks in a single line of code .

Say, you have installed a temperature sensor in your garden to measure temperature data over a period of many weeks. Every Sunday, you uninstall the temperature sensor from the garden and take it in your house to digitize the sensor values. Now, you realize that the Sunday sensor values are faulty because they partially measured the temperature at your home and not at the outside location.

In this mini code project, you want to “clean” your data by replacing every Sunday sensor value with the average sensor value of the last seven days. But before we dive into the code, let’s explore the most important concepts you need as a basic understanding.

Examples Slice Assignment NumPy

In NumPy’s slice assignment feature, you specify the values to be replaced on the left-hand side of the equation and the values that replace them on the right-hand side of the equation.

Here is an example:

The code snippet creates an array containing 16 times the value 4. Then we use slice assignment to replace the 15 trailing sequence values with the value 16. Recall that the notation a[start:stop:step] selects the sequence starting at index “start”, ending in index “stop” (exclusive), and considering only every “step”-th sequence element. Thus, the notation a[1::] replaces all sequence elements but the first one.

This example shows how to use slice assignment with all parameters specified. An interesting twist is that we specify only a single value “16” to replace the selected elements. Do you already know the name of this feature?

Correct, broadcasting is the name of the game! The right-hand side of the equation is automatically transformed into a NumPy array. The shape of this array is equal to the left-hand array.

Before we investigate how to solve the problem with a new one-liner, let me quickly explain the shape property of NumPy arrays. Every array has an associated shape attribute (a tuple ). The i-th tuple value specifies the number of elements of the i-th axis. Hence, the number of tuple values is the dimensionality of the NumPy array.

Read over the following examples about the shapes of different arrays:

We create three arrays a , b , and c .

• Array a is 1D, so the shape tuple has only a single element.
• Array b is 2D, so the shape tuple has two elements.
• Array c is 3D, so the shape tuple has three elements.

Problem Formulation

This is everything you need to know to solve the following problem:

Given an array of temperature values, replace every seventh temperature value with the average of the last seven days.

Take a guess : what’s the output of this code snippet?

First, the puzzle creates the data matrix “ tmp ” with a one-dimensional sequence of sensor values. In every line, we define all seven sensor values for seven days of the week (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, and Sunday).

Second, we use slice assignment to replace all the Sunday values of this array. As Sunday is the seventh day of the week, the expression “ tmp[6::7] ” selects the respective Sunday values starting from the seventh element in the sequence (again: the Sunday sensor value).

Third, we reshape the one-dimensional sensor array into a two-dimensional array with seven columns. This makes it easier for us to calculate the weekly average temperature value to replace the Sunday data. Note that the dummy shape tuple value -1 (in “ tmp.reshape((-1,7)) ”) means that the number of rows ( axis 0 ) should be selected automatically. In our case, it results in the following array after reshaping :

It’s one row per week and one column per weekday.

Now we calculate the 7-day average by collapsing every row into a single average value using the np.average() function with the axis argument: axis=1 means that the second axis is collapsed into a single average value. This is the result of the right-hand side of the equation:

After replacing all Sunday sensor values, we get the following final result of the one-liner:

This example is drawn from my Python One-Liners book:

Python One-Liners Book: Master the Single Line First!

Python programmers will improve their computer science skills with these useful one-liners.

Python One-Liners will teach you how to read and write “one-liners”: concise statements of useful functionality packed into a single line of code. You’ll learn how to systematically unpack and understand any line of Python code, and write eloquent, powerfully compressed Python like an expert.

The book’s five chapters cover (1) tips and tricks, (2) regular expressions, (3) machine learning, (4) core data science topics, and (5) useful algorithms.

Detailed explanations of one-liners introduce key computer science concepts and boost your coding and analytical skills . You’ll learn about advanced Python features such as list comprehension , slicing , lambda functions , regular expressions , map and reduce functions, and slice assignments .

You’ll also learn how to:

• Leverage data structures to solve real-world problems , like using Boolean indexing to find cities with above-average pollution
• Use NumPy basics such as array , shape , axis , type , broadcasting , advanced indexing , slicing , sorting , searching , aggregating , and statistics
• Calculate basic statistics of multidimensional data arrays and the K-Means algorithms for unsupervised learning
• Create more advanced regular expressions using grouping and named groups , negative lookaheads , escaped characters , whitespaces, character sets (and negative characters sets ), and greedy/nongreedy operators
• Understand a wide range of computer science topics , including anagrams , palindromes , supersets , permutations , factorials , prime numbers , Fibonacci numbers, obfuscation , searching , and algorithmic sorting

By the end of the book, you’ll know how to write Python at its most refined , and create concise, beautiful pieces of “Python art” in merely a single line.

Get your Python One-Liners on Amazon!!

Where to Go From Here?

Do you love data science? But you struggle to get everything together and develop a good intuition about the NumPy library?

To help you improving your code understanding speed in NumPy, I co-authored a brand-new NumPy book based on puzzle-based learning. Puzzle-based learning is a new, very practical approach to learning to code — based on my experience of teaching more than 60,000 ambitious Python coders online.

Get your “ Coffee Break NumPy ” now!

While working as a researcher in distributed systems, Dr. Christian Mayer found his love for teaching computer science students.

To help students reach higher levels of Python success, he founded the programming education website Finxter.com that has taught exponential skills to millions of coders worldwide. He’s the author of the best-selling programming books Python One-Liners (NoStarch 2020), The Art of Clean Code (NoStarch 2022), and The Book of Dash (NoStarch 2022). Chris also coauthored the Coffee Break Python series of self-published books. He’s a computer science enthusiast, freelancer , and owner of one of the top 10 largest Python blogs worldwide.

His passions are writing, reading, and coding. But his greatest passion is to serve aspiring coders through Finxter and help them to boost their skills. You can join his free email academy here.

scipy.optimize.linear_sum_assignment #

Solve the linear sum assignment problem.

The cost matrix of the bipartite graph.

Calculates a maximum weight matching if true.

An array of row indices and one of corresponding column indices giving the optimal assignment. The cost of the assignment can be computed as cost_matrix[row_ind, col_ind].sum() . The row indices will be sorted; in the case of a square cost matrix they will be equal to numpy.arange(cost_matrix.shape[0]) .

for sparse inputs

The linear sum assignment problem [1] is also known as minimum weight matching in bipartite graphs. A problem instance is described by a matrix C, where each C[i,j] is the cost of matching vertex i of the first partite set (a ‘worker’) and vertex j of the second set (a ‘job’). The goal is to find a complete assignment of workers to jobs of minimal cost.

Formally, let X be a boolean matrix where \(X[i,j] = 1\) iff row i is assigned to column j. Then the optimal assignment has cost

where, in the case where the matrix X is square, each row is assigned to exactly one column, and each column to exactly one row.

This function can also solve a generalization of the classic assignment problem where the cost matrix is rectangular. If it has more rows than columns, then not every row needs to be assigned to a column, and vice versa.

This implementation is a modified Jonker-Volgenant algorithm with no initialization, described in ref. [2] .

Added in version 0.17.0.

https://en.wikipedia.org/wiki/Assignment_problem

DF Crouse. On implementing 2D rectangular assignment algorithms. IEEE Transactions on Aerospace and Electronic Systems , 52(4):1679-1696, August 2016, DOI:10.1109/TAES.2016.140952

numpy.where #

Return elements chosen from x or y depending on condition .

When only condition is provided, this function is a shorthand for np.asarray(condition).nonzero() . Using nonzero directly should be preferred, as it behaves correctly for subclasses. The rest of this documentation covers only the case where all three arguments are provided.

Where True, yield x , otherwise yield y .

Values from which to choose. x , y and condition need to be broadcastable to some shape.

An array with elements from x where condition is True, and elements from y elsewhere.

The function that is called when x and y are omitted

If all the arrays are 1-D, where is equivalent to:

This can be used on multidimensional arrays too:

The shapes of x, y, and the condition are broadcast together: