NumPy log10()

The numpy.log10() method calculates the base-10 logarithm of elements in an array.


import numpy as np

# create an array 
array1 = np.array([1, 10, 100, 1000])

# calculate base-10 logarithm of array1 elements result = np.log10(array1)
print(result) # Output: [0. 1. 2. 3.]

log10() Syntax

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

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

log10() Arguments

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

  • x - an input array
  • out (optional) - the output array where the result will be stored
  • where (optional) - a boolean array indicating where to compute the logarithm
  • casting (optional) - casting behavior when converting data types
  • dtype (optional) - the data type of the returned output

log10() Return Value

The numpy.log10() method returns an array with the corresponding base-10 logarithmic values.

Example 1: Use of out and where in log10()

import numpy as np

array1 = np.array([1, -10, 10, 100, -1000, 10000])

# create an output array with the same shape as array1
result = np.zeros_like(array1, dtype=float)  

# compute log10 of elements in array1 # only where the element is greater than 1 np.log10(array1, where = array1 > 1, out = result)


[0. 0. 1. 2. 0. 4.]

Here, the numpy.log10() method is used to calculate the base-10 logarithm of the elements in array1. We have supplied the following additional arguments to this method:

  • where is used to specify the condition array1 > 1, indicating that the logarithm should only be computed for elements greater than 1.
  • out is set to result to store the computed logarithmic values in the result array.

Note: The logarithm of negative values is not computed, and those corresponding elements in the result array will be assigned as zeros.

Example 2: Using Optional casting Argument in log10()

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 values
  • 'same_kind' - only safe casts or casts within a kind are allowed
  • 'unsafe' - any data conversion 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 # preserving 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)


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.]

Note: The numpy.log10() method doesn't involve type casting or conversions, so the casting argument doesn't affect the results.

Example 3: Use of dtype Argument in log10()

import numpy as np

array1 = np.array([1, 10, 100, 1000, 10000])

# compute the log10 with dtype = float64 result1 = np.log10(array1, dtype = np.float64)
print("Result with dtype float64:", result1) # convert the logarithmic values to integers result2 = np.round(result1).astype(int) print("Result with dtype int:", result2)


Result with dtype float64: [0. 1. 2. 3. 4.]
Result with dtype int: [0 1 2 3 4]

In this example, we calculated the logarithmic values using np.log10() with dtype = np.float64.

Then, we used np.round() to round off the floating-point values to the nearest integer. Finally, we converted the rounded values to integers using astype(int).

Now, the result2 array contains the logarithmic values rounded to the nearest integer.