NumPy sign()

import numpy as np

# create an array
array1 = np.array([9, -3, -8, 0])

# determine the sign of each element in the array
result = np.sign(array1)

print(result)

# Output:[1  -1  -1  0]

sign() Syntax

The syntax of the numpy.sign() method is:

numpy.sign(x, out = None, where = True, casting = 'same_kind', dtype = None)

sign() Arguments

The numpy.sign() method takes the following arguments:

• x - the array whose elements' signs are to be determined
• out (optional) - the output array where the result will be stored
• where (optional) - a boolean array or condition specifying which elements should be updated
• casting (optional) - casting behavior when converting data types
• dtype (optional) - the data type of the returned output

sign() Return Value

The numpy.sign() method returns an array with the same shape as the input, containing the sign of each array element.

Example 1: Determine the Sign of Each Array Element

import numpy as np

# create an input array
array1 = np.array([-2, 5, 0, -7])

# determine the sign of each element in the array
result = np.sign(array1)

print(result)

Output

[-1  1  0 -1]

In the above example, we saw how we can use numpy.sign() to determine the sign of each element in an array.

The resulting array contains -1 for negative values, 0 for zero, and 1 for positive values.

Example 2: Use of out and where in sign()

import numpy as np

array1 = np.array([[-2, 0, 3], [5, -4, 0]])

# create an output array with the same shape as x
output = np.zeros_like(array1)  

# compute the sign of each element
# where the element is non-zero,
# and store the result in the output array
np.sign(array1, where = array1 != 0, out = output)

print(output)

Output

[[-1  0  1]
 [ 1 -1  0]]

Notice the following code in the program above:

np.sign(array1, where = array1 != 0, out = output)

This code computes the sign of each element in array1, but only where the element is non-zero (based on the where condition).

And the result is stored in the output array.

Example 3: Using Optional casting Argument in sign()

The casting argument specifies the casting behavior when converting data types.

The casting can be:

• 'no' - data types should not be cast at all
• 'equiv' - only byte-order changes are allowed
• 'safe' - only casts that can preserve the precision of the values are allowed
• 'same_kind' - only safe casts or casts within a kind are allowed
• 'unsafe' - any data conversions may be done

Let's look at an example.

import numpy as np

# array of floating-point numbers
array1 = np.array([1, -2, 0, 4, -5], dtype = np.float32)

# no casting is allowed
# same data type as array1 is maintained
array2 = np.sign(array1, casting = 'no')

# casting is allowed to equivalent
# data types (floating-point numbers)
array3 = np.sign(array1, casting = 'equiv')

# casting is allowed to safe data types that
# preserve precision (floating-point numbers)
array4 = np.sign(array1, casting = 'safe')

# casting is allowed to data types of
# the same kind (floating-point numbers)
array5 = np.sign(array1, casting = 'same_kind')

# casting is allowed to any data type
# without checks (signed integers)
array6 = np.sign(array1, casting = 'unsafe')

print("Array with 'no' casting:", array2)
print("Array with 'equiv' casting:", array3)
print("Array with 'safe' casting:", array4)
print("Array with 'same_kind' casting:", array5)
print("Array with 'unsafe' casting:", array6)

Output

Array with 'no' casting: [ 1. -1.  0.  1. -1.]
Array with 'equiv' casting: [ 1. -1.  0.  1. -1.]
Array with 'safe' casting: [ 1. -1.  0.  1. -1.]
Array with 'same_kind' casting: [ 1. -1.  0.  1. -1.]
Array with 'unsafe' casting: [ 1. -1.  0.   1. -1.]

Example 4: Use of dtype Argument in sign()

import numpy as np

# original array of integers
array1 = np.array([1, -2, 0, 4, -5])

# compute the sign and specify the data type as float32
result = np.sign(array1, dtype = np.float32)

print(result)

Output

[ 1. -1.  0.  1. -1.]

Here, the original array array1 contains integers, but by specifying dtype = np.float32, the np.sign() method casts the result to np.float32.