ln in Python: math.log(), np.log(), Domain, and Precision

Quick answer: Use math.log(x) for the natural logarithm of a positive scalar, numpy.log(array) for element-wise array values, and math.log1p(x) when calculating log(1 + x) near zero. Validate the domain before calling the function.

Python natural logarithm diagram comparing math.log scalar, NumPy log arrays, positive-domain validation, log1p, and exp — Use math.log for scalars, np.log for arrays, and make the positive-domain policy explicit.

ln in Python means the natural logarithm, or log base e. Python does not have a separate ln() function in the standard library. The standard scalar function is math.log(x), which returns the natural log when you pass one argument.

Use natural logs when formulas involve continuous growth, decay, entropy, log likelihoods, or values measured on an exponential scale. The inverse operation is math.exp(x), which raises e to a power. That pairing is the most important idea: math.log() moves from a positive value to its natural-log scale, and math.exp() moves back.

The official Python math.log documentation covers the scalar function. For array-based numeric work, the NumPy log documentation explains numpy.log().

Natural logs only accept positive real inputs in the standard math module. If the input is zero or negative, Python raises ValueError. Validate data before logging it, especially when values come from files, forms, sensors, or calculations that can produce zero.

Contents

Calculate ln With math.log()

Import the math module and call math.log() with one positive number. Passing math.e returns 1, because the natural log of e is one.

import math

value = math.e
natural_log = math.log(value)

print(natural_log)
print(math.isclose(natural_log, 1.0))

This is the direct replacement for ln(x) notation from math classes and calculators. The function name is log, but one argument means natural log, not base ten.

Keep the math. prefix in examples and application code unless there is a strong local convention to import functions directly. The prefix makes the source of the function clear and avoids confusion with other libraries that may also define a log function.

Log Several Positive Numbers

A simple loop is enough when you have a short list of scalar values. Each input must be positive before it reaches math.log().

import math

numbers = [1, math.e, math.e ** 2, 10]

for number in numbers:
    print(number, math.log(number))

The output shows useful anchor points. The natural log of 1 is 0, the natural log of e is 1, and the natural log of e ** 2 is 2.

For large arrays, use NumPy instead of a Python loop. For a small report, command-line check, or validation step, the standard-library loop is often clearer and keeps dependencies out of the script.

Handle Domain Errors

The natural log is defined for positive real numbers. Guard that rule explicitly when bad input should produce a readable error instead of a traceback from deep inside a calculation.

import math

def natural_log(number):
    if number <= 0:
        raise ValueError("natural log input must be positive")
    return math.log(number)

for number in [1.0, 2.5, 0.0]:
    try:
        print(number, natural_log(number))
    except ValueError as error:
        print(number, error)

This pattern is useful in functions that receive user input or data from another system. The check states the rule near the boundary of the function, so later code can assume the value is safe to log.

Do not silently replace zero with a tiny number unless that is a documented statistical choice. A hidden adjustment can change results in ways that are hard to audit later.

Convert Natural Logs To Another Base

Natural logs can convert to any other base by dividing by the natural log of that base. Python also supports math.log(x, base), but the conversion formula is useful when a derivation is written in terms of ln.

import math

number = 1000
base = 10

converted = math.log(number) / math.log(base)
direct = math.log(number, base)

print(converted)
print(direct)

Both lines return the same base-ten log at normal floating-point precision. Use the two-argument form when it reads better. Use the division formula when you want the natural-log relationship to stay visible in the code.

The same approach works for base two, base ten, or any positive base other than one. Validate the base when it comes from input, because base zero, base one, and negative bases are not valid for real logarithms.

Reverse ln With exp()

The inverse of math.log(x) is math.exp(x). If you log a positive value and then apply exp(), you should get the original value back within floating-point tolerance.

import math

starting_value = 7.5
logged = math.log(starting_value)
restored = math.exp(logged)

print(logged)
print(restored)
print(math.isclose(restored, starting_value))

This relationship helps when checking formulas. For example, many models store or optimize values on a log scale, then convert back to the original scale for display or interpretation.

Use math.isclose() for the comparison because floating-point arithmetic can introduce tiny rounding differences. Exact equality is not the right test for most decimal-looking numeric results.

Use Decimal For More Precision

For ordinary numeric scripts, math.log() and floats are the right default. If you need configurable decimal precision, the standard decimal module provides a natural-log method on Decimal numbers.

from decimal import Decimal, getcontext

getcontext().prec = 40
number = Decimal("2.7182818284590452353602874713527")
logged = number.ln()

print(logged)

This is slower than float math, but it gives you control over decimal precision for specialized calculations, financial-style rounding rules, or educational examples that need more printed digits.

Most code should still start with math.log(). Move to Decimal only when the precision requirement is real and tested, not just because more digits look more exact.

Common ln Mistakes

The first mistake is looking for math.ln(). Python uses math.log(x) for natural logs and math.log(x, base) when you need another base.

The second mistake is passing zero or a negative number to the scalar math function. Check the domain first and decide whether invalid input should be rejected, filtered, or handled in a complex-number workflow.

The third mistake is mixing scalar and array APIs. Use math.log() for one Python number. Use NumPy’s log function for arrays and vectorized calculations.

The practical rule is simple: write math.log(x) for ln(x), keep inputs positive, use math.exp() to reverse the transform, and choose a different base only when the problem actually asks for it.

Choose Scalar Or Array Math

math.log(x) is the standard-library scalar operation for ln. A one-argument call uses base e; a second argument can request another base. For arrays, numpy.log() applies the natural logarithm element by element and follows NumPy’s rules for invalid real-domain values.

import math
import numpy as np

scalar = math.log(math.e)
values = np.array([1.0, math.e, math.e ** 2])
array_logs = np.log(values)
print(scalar, array_logs)

Handle The Positive Domain

Real natural logarithms are defined for positive inputs. Zero and negative values usually indicate a data or modeling decision that must be handled before the call. You can filter invalid observations, reject the record, use a complex-number model, or apply a domain-specific transform, but do not silently turn an invalid value into a meaningful result.

Use Stable Forms Near Zero

When the expression is log(1 + x) and x is very small, math.log1p(x) is designed to retain more precision than calculating math.log(1 + x) directly. The inverse of a natural log is math.exp(); use that pair when checking a transformation or round trip.