Math.log: примеры (PYTHON)

Базовые примеры использования

Натуральный логарифм (по основанию e):

import math
print(math.log(10))

2.302585092994046

Логарифм по основанию 10:

print(math.log(100, 10))

2.0

Логарифм по произвольному основанию (2):

print(math.log(8, 2))

3.0

Логарифм от числа 1 (в любом основании) всегда равен 0:

print(math.log(1))
print(math.log(1, 5))

0.0
0.0

Логарифм от самого основания равен 1:

print(math.log(math.e))
print(math.log(7, 7))

1.0
1.0

Похожие функции в Python

• math.log10(x) - вычисляет десятичный логарифм (по основанию 10). Более точный и часто более быстрый, чем math.log(x, 10).
• math.log2(x) - вычисляет двоичный логарифм (по основанию 2). Также оптимизирован для точности и скорости по сравнению с общим случаем.
• math.log1p(x) - вычисляет ln(1+x). Предназначен для повышенной точности при очень малых значениях x, когда 1+x теряет точность из-за округления.
• numpy.log() и его варианты (numpy.log10, numpy.log2) - аналогичные функции из библиотеки NumPy, работающие с массивами данных.

Выбор функции зависит от задачи: для общего случая - math.log(), для оснований 10 или 2 предпочтительнее специализированные функции, для малых чисел - math.log1p(), для массивов - функции NumPy.

Аналоги функции в других языках

Многие языки имеют схожие функции для вычисления логарифмов.

JavaScript: Math.log() вычисляет натуральный логарифм. Для других оснований нужно использовать формулу смены основания.

console.log(Math.log(10)); // 2.302585092994046
console.log(Math.log(100) / Math.log(10)); // Логарифм по основанию 10: 2

Java: Класс Math содержит Math.log() (натуральный) и Math.log10().

System.out.println(Math.log(10)); // 2.302585092994046
System.out.println(Math.log10(100)); // 2.0

PHP: Функции log() (натуральный), log10().

echo log(10); // 2.302585092994
echo log(100, 10); // Второй аргумент - основание: 2

C#: Класс Math предоставляет Math.Log() (натуральный), Math.Log10(), Math.Log() с двумя аргументами.

Console.WriteLine(Math.Log(10)); // 2.30258509299405
Console.WriteLine(Math.Log(100, 10)); // 2

SQL (на примере PostgreSQL): Функции LN() (натуральный) и LOG() (с одним аргументом - по основанию 10, с двумя - по указанному основанию).

SELECT LN(10); -- 2.30258509299405
SELECT LOG(100); -- 2
SELECT LOG(2, 8); -- 3.0

Go: Пакет math содержит math.Log() (натуральный), math.Log10(), math.Log2().

import "math"
fmt.Println(math.Log(10)) // 2.302585092994046
fmt.Println(math.Log2(8)) // 3

Lua: Функция math.log в стандартной библиотеке вычисляет натуральный логарифм. В версии Lua 5.3+ можно использовать второй аргумент для указания основания.

print(math.log(10)) -- 2.302585092994
print(math.log(100, 10)) -- 2 (в Lua 5.3+)

Типичные ошибки

Передача неположительного аргумента вызывает ValueError.

import math
math.log(0)

ValueError: math domain error

math.log(-5)

ValueError: math domain error

Основание логарифма должно быть положительным и не равным 1.

math.log(10, 1)

ZeroDivisionError: float division by zero
# или ValueError: math domain error

math.log(10, -2)

ValueError: math domain error

Передача аргументов нечислового типа приводит к TypeError.

math.log("10")

TypeError: must be real number, not str

Потеря точности при вычислении логарифма от числа, очень близкого к 1, без использования math.log1p.

Изменения в последних версиях

В Python 3.11 была повышена скорость выполнения многих математических функций, включая math.log(), за счет внутренних оптимизаций. Функциональность и аргументы остались неизменными.

В Python 2 функция math.log(x[, base]) также присутствовала, но поведение при некорректных аргументах могло немного отличаться. Основное отличие - в Python 2 существовала отдельная функция math.log10, как и сейчас.

Расширенные примеры использования

Решение уравнения a^x = b:

import math
a = 2
b = 8
# x = log_a(b)
x = math.log(b, a)
print(f"{a}^{x} = {b}")

2^3.0 = 8

Вычисление сложных процентов (нахождение времени удвоения капитала):

rate = 0.07  # 7% годовых
time_to_double = math.log(2) / math.log(1 + rate)
print(f"Капитал удвоится через {time_to_double:.2f} лет")

Капитал удвоится через 10.24 лет

Преобразование данных с использованием логарифма для линейности (часто в анализе данных):

data = [1, 10, 100, 1000]
log_data = [math.log10(x) for x in data]
print(log_data)

[0.0, 1.0, 2.0, 3.0]

Логарифмическая вероятность (log-likelihood) в статистике:

probabilities = [0.1, 0.4, 0.25]
log_likelihood = sum(math.log(p) for p in probabilities)
print(f"Логарифмическое правдоподобие: {log_likelihood}")

Логарифмическое правдоподобие: -4.382026634673881

Работа с очень большими или малыми числами (чтобы избежать переполнения):

# Вместо вычисления произведения вероятностей, которое может быть очень малым,
# работают с суммой логарифмов.
import math
probs = [1e-50, 1e-30, 1e-40]
log_sum = sum(math.log(p) for p in probs)
print(f"Логарифм произведения: {log_sum}")
print(f"Само произведение: {math.exp(log_sum)}")

Логарифм произведения: -275.7257654455279
Само произведение: 1e-120

Сравнение точности math.log(x, 10) и math.log10(x):

x = 10**15
res1 = math.log(x, 10)
res2 = math.log10(x)
print(f"math.log(x, 10): {res1}")
print(f"math.log10(x):   {res2}")
print(f"Разница: {abs(res1 - res2)}")

math.log(x, 10): 15.0
math.log10(x):   15.0
Разница: 0.0

Использование в условиях с проверкой допустимости аргументов:

def safe_log(x, base=math.e):
    if x <= 0:
        return float('-inf') if x == 0 else None  # Обработка недопустимых значений
    if base <= 0 or base == 1:
        return None
    return math.log(x, base)

print(safe_log(100, 10))
print(safe_log(0))
print(safe_log(-5))

2.0
-inf
None