The numpy.log10()
method calculates the base-10 logarithm of elements in an array.
Example
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 arrayout
(optional) - the output array where the result will be storedwhere
(optional) - a boolean array indicating where to compute the logarithmcasting
(optional) - casting behavior when converting data typesdtype
(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)
print(result)
Output
[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 conditionarray1 > 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)
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.]
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)
Output
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.