Understanding numpy.ones_like() function (4 examples)

Introduction

The numpy.ones_like() function is a powerful tool within the NumPy library, widely used in data science, engineering, and mathematical programming for generating arrays with the same shape and type as a given array but filled with ones. This tutorial aims to explain the use of numpy.ones_like() function through practical examples, ranging from basic to advanced usage scenarios.

The Fundamentals of numpy.ones_like()

Before diving into examples, it’s important to understand the syntax of numpy.ones_like():

numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)

Where:

• a: The shape and data-type of a define these same attributes of the returned array.
• dtype: The desired data-type for the array. If not specified, the data-type of a is used.
• order: Memory layout of the array. ‘C’ for C-style row-major order, ‘F’ for Fortran-style column-major order, or ‘K’ to keep the existing order.
• subok: If True, then the newly created array will also be a subclass of a if a is a subclass of ndarray.
• shape: Overrides the shape of the result. If specified, it must be compatible with the shape of a.

Example 1: Basic Usage

First, let’s cover how to create an array filled with ones, that mirrors the shape and type of an existing array.

import numpy as np

original_array = np.arange(6).reshape((3, 2))
ones_array = np.ones_like(original_array)

print("Original array:\n", original_array)
print("Ones array:\n", ones_array)

Output:

Original array:
 [[0 1]
 [2 3]
 [4 5]]
Ones array:
 [[1 1]
 [1 1]
 [1 1]]

This basic example demonstrates creating a new array of ones with the same shape as the original_array.

Example 2: Specifying DataType

In some cases, you might need the array of ones to have a different data type. Let’s see how to specify the data type while using numpy.ones_like().

import numpy as np

float_array = np.array([1, 2, 3], dtype=np.float32)
ones_float = np.ones_like(float_array, dtype=np.int64)

print("Original array with float32:", float_array.dtype)
print("Ones array with int64:", ones_float.dtype)

Output:

Original array with float32: float32
Ones array with int64: int64

By specifying the dtype parameter, we created an array of ones with int64 type, differing from the original array’s float32 data type.

Example 3: 3D Array and Memory Order

Moving towards more complex scenarios, let us work with a 3-dimensional array and explore the order parameter.

import numpy as np

three_d_array = np.random.rand(2, 2, 3)
ones_3d_C = np.ones_like(three_d_array, order='C')
ones_3d_F = np.ones_like(three_d_array, order='F')

print("Memory layout of ones_3d_C is:", ones_3d_C.flags['C_CONTIGUOUS'])
print("Memory layout of ones_3d_F is:", ones_3d_F.flags['F_CONTIGUOUS'])

Output:

Memory layout of ones_3d_C is: True
Memory layout of ones_3d_F is: True

The order parameter allows us to define the memory layout. Despite both being arrays of ones, their memory layout can be adjusted to match the requirements of different computational scenarios.

Example 4: Working with subok Parameter

The subok parameter can be a bit abstract but is useful when working with subclasses of the ndarray. To illustrate its use, let’s create a subclass and use ones_like to create an array of ones that also belongs to the subclass.

import numpy as np

class MyArray(np.ndarray):
    pass

subclassed_array = np.array([(1, 2), (3, 4)]).view(MyArray)
ones_like_subclassed = np.ones_like(subclassed_array, subok=True)

print("Ones like subclassed array is instance of MyArray:", isinstance(ones_like_subclassed, MyArray))

Output:

Ones like subclassed array is instance of MyArray: True

Through the use of the subok parameter, we’ve managed to create an array of ones that retains the subclass type of its reference array.

Conclusion

The numpy.ones_like() function provides a convenient way to generate arrays of ones matching the shape, type, and even the subclass of another array. Through the examples provided, we’ve seen how its parameters can be adjusted to achieve different outcomes, making it a versatile tool in the toolkit of anyone working with numerical data in Python.