Как пишется логарифм в питоне

Логарифмы используются для изображения и представления больших чисел. Журнал – это величина, обратная экспоненте. В этой статье мы подробно рассмотрим функции log(). Логарифмические функции в Python помогают пользователям находить логарифм чисел намного проще и эффективнее.

Понимание функции

Чтобы использовать функциональные возможности журнала, нам необходимо импортировать модуль math, используя приведенный ниже оператор.

import math

Нам всем необходимо принять во внимание тот факт, что к функциям журнала нельзя получить прямой доступ. Нам нужно использовать модуль math для доступа к функциям журнала в коде.

Синтаксис:

math.log(x)

Функция math.log(x) используется для вычисления натурального логарифмического значения, т.е. логарифма с основанием e (число Эйлера), которое составляет около 2,71828 переданного ему значения параметра (числовое выражение).

Пример:

import math   

print("Log value: ", math.log(2))

В приведенном выше фрагменте кода мы запрашиваем логарифмическое значение 2.

Вывод:

Log value:  0.6931471805599453

Варианты функций

Ниже приведены варианты базовой функции журнала в Python:

• log2(х);
• log(x, Base);
• log10(x);
• log1p(x);

1. log2(x) – основание логарифма 2

Функция math.log2(x) используется для вычисления логарифмического значения числового выражения с основанием 2.

Синтаксис:

math.log2(numeric expression)

Пример:

import math 

print ("Log value for base 2: ") 
print (math.log2(20)) 

Вывод:

Log value for base 2: 
4.321928094887363

2. log(n, Base) – основание логарифма n

Функция math.log(x, Base) вычисляет логарифмическое значение x, т.е. числовое выражение для определенного (желаемого) базового значения.

Синтаксис:

math.log(numeric_expression,base_value)

Эта функция принимает два аргумента:

• числовое выражение;
• базовое значение.

Примечание. Если функции не задано базовое значение, math.log(x, (Base)) действует как базовая функция журнала и вычисляет журнал числового выражения по основанию e.

Пример:

import math 

print ("Log value for base 4 : ") 
print (math.log(20,4)) 

Вывод:

Log value for base 4 : 
2.1609640474436813

3. log10(x) – основание логарифма 10

Функция math.log10(x) вычисляет логарифмическое значение числового выражения с точностью до 10.

Синтаксис:

math.log10(numeric_expression)

Пример:

import math 

print ("Log value for base 10: ") 
print (math.log10(15)) 

В приведенном выше фрагменте кода вычислено логарифмическое значение от 15 до основания 10.

Вывод:

Log value for base 10 : 
1.1760912590556813

4. log1p(x)

Функция math.log1p(x) вычисляет журнал (1 + x) определенного входного значения, т.е. x.

Примечание: math.log1p(1 + x) эквивалентно math.log (x).

Синтаксис:

math.log1p(numeric_expression)

Пример:

import math 

print ("Log value(1+15) for x = 15 is: ") 
print (math.log1p(15)) 

В приведенном выше фрагменте кода вычисляется значение журнала (1 + 15) для входного выражения 15.

Таким образом, math.log1p(15) эквивалентен math.log(16).

Вывод:

Log value(1+15) for x = 15 is: 
2.772588722239781

Понимание журнала в NumPy

NumPy позволяет нам одновременно вычислять натуральные логарифмические значения входных элементов массива NumPy.

Чтобы использовать метод numpy.log(), нам нужно импортировать модуль NumPy, используя приведенный ниже оператор.

import numpy

Синтаксис:

numpy.log(input_array)

Функция numpy.log() принимает входной массив в качестве параметра и возвращает массив с логарифмическим значением элементов в нем.

Пример:

import numpy as np 

inp_arr = [10, 20, 30, 40, 50] 
print ("Array input elements:n", inp_arr) 

res_arr = np.log(inp_arr) 
print ("Resultant array elements:n", res_arr) 

Вывод:

Array input elements:
 [10, 20, 30, 40, 50]
Resultant array elements:
 [ 2.30258509  2.99573227  3.40119738  3.68887945  3.91202301]

( 13 оценок, среднее 3.92 из 5 )

Содержание

• 1. Функция math.exp(x). Экспонента в степени x
• 2. Функция math.expm1(x). Экспонента от x минус 1
• 3. Функция math.log(x). Натуральный логарифм
• 4. Функция math.log1p(x). Логарифм для значений, приближенных к нулю
• 5. Функция math.log2(x). Логарифм с основанием 2
• 6. Функция math.log10(x). Десятичный логарифм
• 7. Функция math.pow(x, y). Возведение в степень
• 8. Функция math.sqrt(x). Корень квадратный
• Связанные темы

Поиск на других ресурсах:

1. Функция math.exp(x). Экспонента в степени x

Функция math.exp(x) возводит число e в степень x. Функция возвращает результат вещественного типа. Аргумент x может быть целого или вещественного типа. Значение экспоненты: e = 2.718281… служит основой натурального логарифма.

В Python Функция math.exp(x) может быть заменена другими выражениями

1. math.e**x – здесь math.e – константа, равная значению экспоненты.
2. pow(math.e, x) – здесь pow() – встроенная функция языка Python.

Пример.

# Функция math.exp(x)
import math

y = math.exp(1) # y = 2.718281828459045

x = 0.0
y = math.exp(x) # y = 1.0

x = 3.85
y = math.exp(x) # y = 46.993063231579285

  ⇑

2. Функция math.expm1(x). Экспонента от x минус 1

Функция math.expm1(x) вычисляет значение выражения exp(x)-1. При вычислении значения некоторого y, вызов функции

y = math.expm1(x)

можно заменить выражением

y = math.exp(x)-1

Однако, использование функции math.expm1(x) даст более точный результат вычисления. Это и есть основное назначение данной функции.

Пример.

# Функция math.expm1(x)
import math

x = 1.0
y = math.expm1(x) # y = 1.718281828459045

y = math.expm1(0.0) # y = 0.0

  ⇑

3. Функция math.log(x). Натуральный логарифм

Функция math.log(x) предназначена для вычисления натурального логарифма числа с заданным основанием.
Общая форма функции следующая

math.log(x [, base])

где

• x – аргумент, для которого вычисляется логарифм;
• base – основание логарифма. Этот параметр функции необязательный. Если параметр base отсутствует, то за основу берется число e = 2.718281…

Если попробовать вызвать функцию log(0.0), то интерпретатор Python выдаст ошибку

ValueError: math domain error

поскольку логарифм нуля не существует.

Пример.

# Функция math.log(x)
import math

x = 1.0
y = math.log(x) # y = 0.0

  ⇑

4. Функция math.log1p(x). Логарифм для значений, приближенных к нулю

Функция log1p(x) возвращает натуральный логарифм от 1+x. Основой логарифма есть экспонента e = 2.718281… Функция необходима в случаях, когда значение аргумента x приближается к нулю. Как известно, логарифм нуля не существует. Во избежание исключительной ситуации введена данная функция.

Пример.

# Функция math.log1p(x)
import math

x = 0.0000001
y = math.log1p(x) # y = 9.999999500000032e-08

  ⇑

5. Функция math.log2(x). Логарифм с основанием 2

Функция math.log2(x) введена начиная с версии Python 3.3 и возвращает логарифм от аргумента x с основанием 2. Функция введена с целью повышения точности вычислений по сравнению с функцией math.log(x, 2). Аргумент x может быть как целого, так и вещественного типа.

Пример.

# Функция math.log2(x)
import math

x = 2
y = math.log2(x) # y = 1.0

x = 16
y = math.log2(x) # y = 4.0

  ⇑

6. Функция math.log10(x). Десятичный логарифм

Функция math.log10(x) возвращает логарифм от x с основанием 10 (base = 10). Функция дает более точный результат по сравнению с вызовом функции math.log(x, 10). Аргумент x может быть как целого, так и вещественного типа.

Пример.

# Функция math.log10(x)
import math

x = 10
y = math.log10(x) # y = 1.0

x = 100
y = math.log10(x) # y = 2.0

x = 10.00001
y = math.log10(x) # y = 1.0000004342942648

  ⇑

7. Функция math.pow(x, y). Возведение в степень

Функция math.pow(x, y) выполняет возведение x в степень y. Аргументы x, y могут быть целого и вещественного типа. Операнды комплексного типа не поддерживаются.

Особенности вычисления результата:

• результат pow(1.0, y) всегда будет равен 1.0;
• результат pow(0.0, y) всегда будет равен 1.0.

В отличие от операции ** (возведение в степень), функция math.pow(x, y) целочисленные операнды приводит к вещественному типу float.

Пример.

# Функция math.pow(x, y)
import math

# для целочисленных операндов
x = 3
y = 4
z = math.pow(x, y) # z = 81.0 - вещественный результат

# для операндов вещественного типа
x = 2.5
y = 1.5
z = math.pow(x, y) # z = 3.952847075210474

# отрицательные числа
x = -2
y = -3
z = math.pow(x, y) # z = -0.125

x = -2.0
y = 3.0
z = math.pow(x, y) # z = -8.0

# оператор **
z = (-2) ** 3 # z = -8 - результат целого типа

  ⇑

8. Функция math.sqrt(x). Корень квадратный

Функция math.sqrt(x) вычисляет квадратный корень от аргумента x. Функция возвращает результат вещественного типа. Значение x может быть положительным или нулевым. Если значение x отрицательное, то интерпретатор выдаст сообщение об ошибке

math domain error

Пример.

# Функция math.sqrt(x)
import math

# для целых чисел
x = 81
y = math.sqrt(x) # y = 9.0

x = -0.0
y = math.sqrt(x) # y = -0.0

x = 2.0
y = math.sqrt(x) # y = 1.4142135623730951

  ⇑

Связанные темы

• Теоретико-числовые функции и функции представления
• Тригонометрические функции
• Гиперболические функции
• Специальные функции и константы

  ⇑

Эта статья посвящена математическим функциям в Python. Для выполнения математических операций необходим модуль math.

Что такое модуль?

В C и C++ есть заголовочные файлы, в которых хранятся функции, переменные классов и так далее. При включении заголовочных файлов в код появляется возможность не писать лишние строки и не использовать одинаковые функции по несколько раз. Аналогично в Python для этого есть модули, которые включают функции, классы, переменные и скомпилированный код. Модуль содержит группу связанных функций, классов и переменных.

Есть три типа модулей в Python:

1. Модули, написанные на Python (.py).
2. Модули, написанные на C и загружаемые динамически (.dll, .pyd, .so, .sl и так далее).
3. Модули, написанные на C, но связанные с интерпретатором.

   import sys
   print(sys.builtin_module_names)
   

   ('_ast', '_bisect', '_codecs', '_codecs_cn', '_codecs_hk', '_codecs_iso2022', 
   '_codecs_jp', '_codecs_kr', '_codecs_tw', '_collections', '_csv', '_datetime', 
   '_functools', '_heapq', '_imp', '_io', '_json', '_locale', '_lsprof', '_md5', 
   '_multibytecodec', '_opcode', '_operator', '_pickle', '_random', '_sha1', 
   '_sha256', '_sha512', '_sre', '_stat', '_string', '_struct', '_symtable', '_thread', 
   '_tracemalloc', '_warnings', '_weakref', '_winapi', 'array', 'atexit', 'audioop', 
   'binascii', 'builtins', 'cmath', 'errno', 'faulthandler', 'gc', 'itertools', 'marshal', 
   'math', 'mmap', 'msvcrt', 'nt', 'parser', 'signal', 'sys', 'time', 'winreg', 
   'xxsubtype', 'zipimport', 'zlib').
   

Для получения списка модулей, написанных на C, но связанных с Python, можно использовать следующий код.

Как видно из списка выше, модуль math написан на C, но связан с интерпретатором. Он содержит математические функции и переменные, о которых дальше и пойдет речь.

Функции представления чисел

ceil() и floor() — целая часть числа

Сeil() и floor() — функции общего назначения. Функция ceil округляет число до ближайшего целого в большую сторону. Функция floor убирает цифры десятичных знаков. Обе принимают десятичное число в качестве аргумента и возвращают целое число.

Пример:

# Импорт модуля math
import math

# Дробный номер
number=8.10

# выводим целую часть числа с округлением к большему
print("Верхний предел 8.10 это:",math.ceil(number))

# выводим целую часть числа с округлением к меньшему
print("Нижний предел 8.10 это:",math.floor(number))

Вывод:

Верхний предел 8.10 это: 9
Нижний предел 8.10 это: 8

Функция fabs() — абсолютное значение

Функция fabs используется для вычисления абсолютного значения числа. Если число содержит любой отрицательный знак (-), то функция убирает его и возвращает положительное дробное число.

Пример:

# Импорт модуля math
import math

number = -8.10
# вывод абсолютного значения числа
print(math.fabs(number))

Вывод:

8.1

factorial() — функция факториала

Эта функция принимает положительное целое число и выводит его факториал.

Пример:

# Импорт модуля math 
import math    

number = 5
# вывод факториала числа
print("факториала числа", math.factorial(number))

Вывод:

факториала числа 120

Примечание: при попытке использовать отрицательное число, возвращается ошибка значения (Value Error).

Пример:

# Импорт модуля math 
import math    

number = -5
# вывод факториала числа
print("факториала числа", math.factorial(number))

Вывод:

ValueError: factorial() not defined for negative values

Функция fmod() — остаток от деления

Функция fmod(x,y) возвращает x % y. Разница в том, что выражение x % y работает только с целыми числами, а эту функцию можно использовать и для чисел с плавающей точкой.

Пример:

# Импорт модуля math  
import math  

print(math.fmod(5,2))  
print(math.fmod(-5,2))  
print(math.fmod(-5.2,2))  
print(math.fmod(5.2,2))  

Вывод:

1.0
-1.0
-1.2000000000000002
1.2000000000000002

Функция frexp()

Эта функция возвращает мантиссу и показатель степени в виде пары (m,n) любого числа x, решая следующее уравнение.

Пример:

# Импорт модуля math  
import math  

print(math.frexp(24.8))

Вывод:

(0.775, 5)

Функция fsum() — точная сумма float

Вычисляет точную сумму значений с плавающей точкой в итерируемом объекте и сумму списка или диапазона данных.

Пример:

# Импорт модуля math  
import math   
    
# сумма списка
numbers=[.1,.2,.3,.4,.5,.6,.7,.8,8.9]    
print("сумма ", numbers, ":", math.fsum(numbers))    
    
# сумма диапазона    
print("сумма чисел от 1 до 10:", math.fsum(range(1,11)))   

Вывод:

сумма [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 8.9] : 12.5
сумма чисел от 1 до 10: 55.0

Функции возведения в степень и логарифма

Функция exp()

Эта функция принимает один параметр в виде дробного числа и возвращает e^x.

Пример:

# Импорт модуля math  
import math   
    
print("e в степени 5 ", math.exp(5))
print("e в степени 2.5", math.exp(2.5))  

Вывод:

e в степени 5  148.4131591025766
e в степени 2.5 12.182493960703473

Функция expm1()

Эта функция работает так же, как и exp, но возвращает exp(x)-1. Здесь, expm1 значит exm-m-1, то есть, exp-minus-1.

Пример:

# Импорт модуля math  
import math   
    
print(math.exp(5)-1)
print(math.expm1(5))

Вывод:

147.4131591025766
147.4131591025766

Функция log() — логарифм числа

Функция log(x[,base]) находит логарифм числа x по основанию e (по умолчанию). base— параметр опциональный. Если нужно вычислить логарифм с определенным основанием, его нужно указать.

Пример:

# Импорт модуля math  
import math  
	  
# логарифм с основанием e
print(math.log(2))  
	  
# логарифм с указанным основанием (2)
print(math.log(64,2)) 

Вывод:

0.6931471805599453
6.0

Функция log1p()

Эта функция похожа на функцию логарифма, но добавляет 1 к x. log1p значит log-1-p, то есть, log-1-plus.

Пример:

# Импорт модуля math  
import math  
	  
print(math.log1p(2))

Вывод:

1.0986122886681098

Функция log10()

Вычисляет логарифм по основанию 10.

Пример:

# Импорт модуля math  
import math  

print(math.log10(1000))

Вывод:

3.0

Функция pow() — степень числа

Используется для нахождение степени числа. Синтаксис функции pow(Base, Power). Она принимает два аргумента: основание и степень.

Пример:

# Импорт модуля math  
import math  

print(math.pow(5,4))

Вывод:

625.0

Функция sqrt() — квадратный корень числа

Эта функция используется для нахождения квадратного корня числа. Она принимает число в качестве аргумента и находит его квадратный корень.

Пример:

# Импорт модуля math  
import math  

print(math.sqrt(256))

Вывод:

16.0

Тригонометрические функции

В Python есть следующие тригонометрические функции.

Пример:

# Импорт модуля math  
import math  
  
# функция синусы  
print("синус PI/2 :", math.sin(math.pi/2))  
# функция косинуса  
print("косинус 0 :", math.cos(0))  
# функция тангенса  
print("тангенс PI/4 :", math.tan(math.pi/4))  
  
print()  
  
# функция арксинуса
print("арксинус 0 :", math.acos(0))  
# функция арккосинуса
print("арккосинус 1 :", math.acos(1))  
# функция арктангенса 
print("арктангенс 0.5 :", math.atan(0.5))  
  
print()  
  
# функция гиперболического синуса
print("гиперболический синус 1 :", math.sinh(1))  
# функция гиперболического косинуса
print("гиперболический косинус 0 :", math.cos(0))  
# функция гиперболического тангенса
print("гиперболический тангенс 1 :", math.tan(1))  
  
print()  
  
# функция обратного гиперболического синуса  
print("обратный гиперболический синус 1 :", math.acosh(1))  
# функция обратного гиперболического косинуса
print("обратный гиперболический косинус 1 :", math.acosh(1))  
# функция обратного гиперболического тангенса 
print("обратный гиперболический тангенс 0.5 :", math.atanh(0.5))  

Вывод:

синус PI/2 : 1.0
косинус 0 : 1.0
тангенс PI/4 : 0.9999999999999999

арксинус 0 : 1.5707963267948966
арккосинус 1 : 0.0
арктангенс 0.5 : 0.4636476090008061

гиперболический синус 1 : 1.1752011936438014
гиперболический косинус 0 : 1.0
гиперболический тангенс 1 : 1.5574077246549023

обратный гиперболический синус 1 : 0.0
обратный гиперболический косинус 1 : 0.0
обратный гиперболический тангенс 0.5 : 0.5493061443340549

Функция преобразования углов

Эти функции преобразуют угол. В математике углы можно записывать двумя способами: угол и радиан. Есть две функции в Python, которые конвертируют градусы в радиан и обратно.

• degrees(): конвертирует радиан в градусы;
• radians(): конвертирует градус в радианы;

Пример:

# Импорт модуля math  
import math  

print(math.degrees(1.57))
print(math.radians(90))

Вывод:

89.95437383553924
1.5707963267948966

Математические константы

В Python есть две математические константы: pi и e.

1. pi: это математическая константа со значением 3.1416..
2. e: это математическая константа со значением 2.7183..

Пример:

# Импорт модуля math  
import math  

# вывод значения PI
print("значение PI", math.pi)

# вывод значения e
print("значение e", math.e)

Вывод:

значение PI 3.141592653589793
значение e 2.718281828459045

Содержание:

• x в степени y,
• Квадратный корень числа,
• Кубический корень из числа,
• Логарифм числа по основанию,
• Десятичный логарифм,
• Двоичный логарифм числа,
• Натуральный логарифм от x + 1,
• e в степень x,
• 2 в степень x,
• e**x - 1.

math.pow(x, y):

Функция math.pow() возвращает x в степени y.

Исключительные случаи максимально соответствуют стандарту IEEE 754. В частности, pow(1.0, x) и pow(x, 0.0) всегда возвращают 1,0, даже если x равно нулю или NaN. Если и x, и y конечны, x отрицательно, а y не является целым числом, то pow(x, y) не определен и вызывает ValueError.

В отличие от встроенного оператора **, math.pow() преобразует оба аргумента в тип float. Используйте ** или встроенную функцию pow() для вычисления точных целочисленных степеней.

Изменено в Python 3.11: особые случаи pow(0.0, -inf) и pow(-0.0, -inf) были изменены, чтобы возвращать inf вместо вызова ValueError, для соответствия IEEE 754.

>>> import math
>>> math.pow(2, 3)
# 8.0
>>> math.pow(3.14, 0.5)
1.772004514666935

math.sqrt(x):

Функция math.sqrt() возвращает квадратный корень числа x.

>>> import math
>>> math.sqrt(4)
# 2.0
>>> math.sqrt(3.14)
# 1.772004514666935

math.cbrt(x):

Функция math.cbrt() возвращает кубический корень из числа x.

Добавлено в Python 3.11

math.log(x[, base]):

Функция math.log() возвращает логарифм числа x по основанию base. Если аргумент base не указан, то возвращается натуральный логарифм числа x.

>>> import math
>>> math.log(2.78)
1.0224509277025455
>>> math.log(1024, 2)
10.0

Функция math.log(x, base) эквивалентна выражению log(x)/log(base)

math.log10(x):

Функция math.log10() возвращает десятичный логарифм числа x, вычисление которого происходит немного точнее, чем math.log(x, 10).

>>> import math
>>> math.log10(1000)
# 3.0
>>> math.log10(2)
# 0.3010299956639812
>>> math.log(2, 10)
# 0.30102999566398114

math.log2(x):

Функция math.log2() возвращает двоичный логарифм числа x, вычисление которого происходит немного точнее, чем math.log(x, 2).

>>> import math
>>> math.log2(2048)
11.0
>>> math.log2(10)
# 3.321928094887362
>>> math.log(10, 2)
# 3.3219280948873626

math.log1p(x):

Функция math.log1p() возвращает натуральный логарифм от x + 1 , значение которого расчитывается более точно, особенно для небольших чисел.

>>> import math
>>> x = 0.0001
>>> math.log1p(x)
# 9.999500033330834e-05
>>> math.log(x + 1)
# 9.999500033329732e-05

math.exp(x):

Функция math.exp() возвращает e, возведенное в степень x, где e=2.718281… — основание натуральных логарифмов. Функция считает более точно, чем math.e ** x или math.pow(math.e, x)

>>> import math
>>> math.exp(1)
# 2.718281828459045
>>> math.exp(3.14)
# 23.103866858722185

math.exp2(x):

Функция math.exp2() возвращает 2, возведенное в степень x.

Добавлено в Python 3.11

math.expm1(x):

Функция math.expm1() возвращает e**x - 1, которое вычисляется значительно точнее, чем math.exp(x) - 1, особенно для небольших чисел x.

Здесь e — основание натуральных логарифмов. Функция math.expm1() предоставляет способ для вычисления этой величины с полной точностью:

>>> import math
>>> math.expm1(0.0000007)
# 7.000002450000572e-07
>>> math.exp(0.0000007) - 1
# 7.000002451018617e-07

Библиотека Math в Python обеспечивает доступ к некоторым популярным математическим функциям и константам, которые можно использовать в коде для более сложных математических вычислений. Библиотека является встроенным модулем Python, поэтому никакой дополнительной установки через pip делать не нужно. В данной статье будут даны примеры часто используемых функций и констант библиотеки Math в Python.

Содержание статьи

• Специальные константы библиотеки math
• Число Пи из библиотеки math
• Число Эйлера из библиотеки math
• Экспонента и логарифм библиотеки math
• Функция экспоненты exp() в Python
• Функция логарифма log() в Python
• Функция log10() в Python
• Функция log2() в Python
• Функция log(x, y) в Python
• Функция log1p(x) в Python
• Арифметические функции в Python
• Тригонометрические функции в Python
• Конвертация типов числа в Python

В библиотеке Math в Python есть две важные математические константы.

Число Пи из библиотеки math

Первой важной математической константой является число Пи (π). Оно обозначает отношение длины окружности к диаметру, его значение 3,141592653589793. Чтобы получить к нему доступ, сначала импортируем библиотеку math следующим образом:

Затем можно получить доступ к константе, вызывая pi:

Вывод

Данную константу можно использовать для вычисления площади или длины окружности. Далее представлен пример простого кода, с помощью которого это можно сделать:

Вывод

Мы возвели радиус во вторую степень и умножили значение на число Пи, как и следовало сделать в соответствии с формулой πr².

Число Эйлера из библиотеки math

Число Эйлера (е) является основанием натурального логарифма. Оно также является частью библиотеки Math в Python. Получить доступ к числу можно следующим образом:

Вывод

В следующем примере представлено, как можно использовать вышеуказанную константу:

Вывод

Экспонента и логарифм библиотеки math

В данном разделе рассмотрим функции библиотеки Math в Python, которые используются для нахождения экспоненты и логарифмов.

Функция экспоненты exp() в Python

Библиотека Math в Python поставляется с функцией exp(), которую можно использовать для вычисления значения е. К примеру, ex — экспонента от х. Значение е равно 2.718281828459045.

Метод может быть использован со следующим синтаксисом:

Параметр x может быть положительным или отрицательным числом. Если x не число, метод возвращает ошибку. Рассмотрим пример использования данного метода:

Вывод

Мы объявили три переменные и присвоили им значения с различными числовыми типами данных. Мы передали значения методу exp() для вычисления их экспоненты.

Мы также можем применить данный метод для встроенных констант, что продемонстрировано ниже:

Вывод

При передаче не числового значения методу будет сгенерирована ошибка TypeError, как показано далее:

Вывод

Как видно из примера выше, генерируется ошибка TypeError.

Функция логарифма log() в Python

Функция log() возвращает логарифм определенного числа. Натуральный логарифм вычисляется относительно основания е. В следующем примере показано использование функции логарифма:

В скрипте выше методу передаются числовые значения с различными типами данных. Также рассчитывается натуральный логарифм константы pi. Вывод следующий:

Функция log10() в Python

Метод log10() возвращает логарифм по основанию 10 определенного числа. К примеру:

Вывод

Функция log2() в Python

Функция log2() возвращает логарифм определенного числа по основанию 2. К примеру:

Вывод

Функция log(x, y) в Python

Функция log(x, y) возвращает логарифм числа х по основанию y. К примеру:

Вывод

Функция log1p(x) в Python

Функция log1p(x) рассчитывает логарифм(1+x), как представлено ниже:

Вывод

Арифметические функции в Python

Арифметические функции используются для представления чисел в различных формах и осуществления над ними математических операций. Далее представлен перечень самых популярных арифметических функций:

• ceil(): округление определенного числа вверх;
• fabs(): возвращает модуль (абсолютное значение) указанного числа;
• floor(): округление определенного числа вниз;
• gcd(a, b): получение наибольшего общего делителя чисел a и b;
• fsum(iterable): возвращает сумму всех элементов итерируемого объекта;
• expm1(): возвращает (e^x)-1;
• exp(x)-1: когда значение x слишком мало, вычисление exp(x)-1 может привести к значительной потери в точности. expm1(x) может вернуть вывод с полной точностью.

В следующем примере показано использование перечисленных выше функций:

Вывод

К числу других математических функций относятся:

• pow(): принимает два вещественных аргумента, возводит первый аргумент в степень, значением которой является второй аргумент, после чего возвращает результат. К примеру, pow(2, 2) эквивалентно выражению 2 ** 2;
• sqrt(): возвращает квадратный корень определенного числа.

Примеры данных методов представлены ниже:

Возведение в степень

Вывод

Квадратный корень

Вывод

Тригонометрические функции в Python

Модуль math в Python поддерживает все тригонометрические функции. Самые популярные представлены ниже:

• sin(a): Возвращает синус "а" в радианах;
• cos(a): Возвращает косинус "а" в радианах;
• tan(a): Возвращает тангенс "а" в радианах;
• asin(a): Возвращает инвертированный синус. Аналогичным образом работают "atan" и "acos";
• degrees(a): Конвертирует угол "a" из радиан в градусы;
• radians(a): Конвертирует угол "a" из градусов в радианы.

Рассмотрим следующий пример:

Вывод

Обратите внимание, что вначале мы конвертировали значение угла из градусов в радианы для осуществления дальнейших операций.

Конвертация типов числа в Python

Python может конвертировать начальный тип числа в другой указанный тип. Данный процесс называется «преобразованием». Python может внутренне конвертировать число одного типа в другой, когда в выражении присутствуют смешанные значения. Такой случай продемонстрирован в следующем примере:

Вывод

В вышеприведенном примере целое число 3 было преобразовано в вещественное число 3.0 с плавающей точкой. Результатом сложения также является число с плавающей точкой (или запятой).

Однако иногда вам необходимо явно привести число из одного типа в другой, чтобы удовлетворить требования параметра функции или оператора. Это можно сделать с помощью различных встроенных функций Python.

Например, чтобы преобразовать целое число в число с плавающей точкой, мы должны вызвать функцию float(), как показано ниже:

Вывод

Целое число типа integer было преобразовано в вещественное число типа float. float также можно конвертировать в integer следующим образом:

Вывод

Вещественное число было преобразовано в целое через удаление дробной части и сохранение базового числа. Обратите внимание, что при конвертации значения в int подобным образом число будет усекаться, а не округляться вверх.

Заключение

Библиотека Math предоставляет функции и константы, которые можно использовать для выполнения арифметических и тригонометрических операций в Python. Библиотека изначально встроена в Python, поэтому дополнительную установку перед использованием делать не требуется. Для получения дополнительной информации можете просмотреть официальную документацию.

Содержание:развернуть

• Синтаксис и подключение
• Константы модуля Math
• Список функций

• Теоретико-числовые функции и функции представления

• Степенные и логарифмические функции

• Тригонометрические функции

• Угловые преобразования

• Гиперболические функции

• Специальные функции

Python библиотека math содержит наиболее применяемые математические функции и константы. Все вычисления происходят на множестве вещественных чисел.

Если вам нужен соответствующий аппарат для комплексного исчисления, модуль math не подойдёт. Используйте вместо него cmath. Там вы найдёте комплексные версии большинства популярных math-функций.

Синтаксис и подключение

Чтобы подключить модуль, необходимо в начале программы прописать следующую инструкцию:

import math

Теперь с помощью точечной нотации можно обращаться к константам и вызывать функции этой библиотеки. Например, так:

math.log()

Константы модуля Math

math.pi
Представление математической константы π = 3.141592…. «Пи» — это отношение длины окружности к её диаметру.

print(math.pi)
> 3.141592653589793

math.e
Число Эйлера или просто e. Иррациональное число, которое приблизительно равно 2,71828.

print(math.e)
> 2.718281828459045

math.tau
Число τ — это отношение длины окружности к её радиусу. Т.е

import math
> print(math.tau)

print(math.tau == 2 * math.pi)
> True

math.inf
Положительная бесконечность.

print(math.inf)
> inf

Для оперирования отрицательной бесконечно большой величиной, используйте -math.inf

Константа math.inf эквивалента выражению float("inf").

math.nan
NaN означает — «не число».

print(math.nan)
> nan

Аналогичная запись: float("nan").

Список функций

Теоретико-числовые функции и функции представления

math.ceil()
Функция округляет аргумент до большего целого числа.

print(math.ceil(3.0001))
> 4

math.comb(n, k)
Число сочетаний из n по k. Показывает сколькими способами можно выбрать k объектов из набора, где находится n объектов. Формула:

Решим задачу: На столе лежат шесть рубинов. Сколько существует способов выбрать два из них?

print(math.comb(6,2))
> 15

💭 Можете подставить числа в формулу, и самостоятельно проверить правильность решения.

math.copysign()
Функция принимает два аргумента. Возвращает первый аргумент, но со знаком второго.

print(math.copysign(-6, 2))
> 6.0

math.fabs()
Функция возвращает абсолютное значение аргумента:

print(math.fabs(-42))
> 42.0

math.factorial()
Вычисление факториала. Входящее значение должно быть целочисленным и неотрицательным.

print(math.factorial(5))
> 120

math.floor()
Антагонист функции ceil(). Округляет число до ближайшего целого, но в меньшую сторону.

print(math.floor(3.99))
> 3

math.fmod(a, b)
Считает остаток от деления a на b. Является аналогом оператора «%» с точностью до типа возвращаемого значения.

print(math.fmod(75, 4))
> 3.0

math.frexp(num)
Возвращает кортеж из мантиссы и экспоненты аргумента. Формула:

, где M — мантисса, E — экспонента.

print(math.frexp(10))
> (0.625, 4)

# проверим
print(pow(2, 4) * 0.625)
> 10.0

math.fsum()
Вычисляет сумму элементов итерируемого объекта. Например, вот так она работает для списка:

summable_list = [1, 2, 3, 4, 5]
print(math.fsum(summable_list))
> 15.0

math.gcd(a, b)
Возвращает наибольший общий делитель a и b. НОД — это самое большое число, на которое a и b делятся без остатка.

a = 5
b = 15
print(math.gcd(a, b))
> 5

math.isclose(x, y)
Функция возвращает True, если значения чисел x и y близки друг к другу, и False в ином случае. Помимо пары чисел принимает ещё два необязательных именованных аргумента:

• rel_tol — максимально допустимая разница между числами в процентах;
• abs_tol — минимально допустимая разница.

x = 10
y = 11
print(math.isclose(x, y))
> False

print(math.isclose(x, y, rel_tol=1))
> True

math.isfinite()
Проверяет, является ли аргумент NaN, False или же бесконечностью. True, если не является, False — в противном случае.

norm = 3
inf = float('inf')
print(math.isfinite(norm))
> True

print(math.isfinite(inf))
> False

math.isinf()
True, если аргумент — положительная/отрицательная бесконечность. False — в любом другом случае.

not_inf = 42
inf = math.inf
print(math.isinf(not_inf))
> False

print(math.isinf(inf))
> True

math.isnan()
Возврат True, если аргумент — не число (nan). Иначе — False.

not_nan = 0
nan = math.nan
print(math.isnan(not_nan))
> False

print(math.isnan(nan))
> True

math.isqrt()
Возвращает целочисленный квадратный корень аргумента, округлённый вниз.

print(math.isqrt(44))
> 6

math.ldexp(x, i)
Функция возвращает значение по формуле:

возвращаемое значение = x * (2 ** i)print(math.ldexp(3, 2))
> 12.0

math.modf()
Результат работы modf() — это кортеж из двух значений:

1. Дробная часть аргумента;
2. Целая часть аргумента;

print(math.modf(3.14))
> (0.14000000000000012, 3.0)

math.perm(n, k)
Возвращает число размещений из n по k. Формула:

Задача: Посчитать количество вариантов распределения трёх билетов на концерт Стаса Михайлова для пяти фанатов.

print(math.perm(5, 3))
> 60

Целых 60 способов! Главное — не запутаться в них, и не пропустить концерт любимого исполнителя!

math.prod()
Принимает итерируемый объект. Возвращает произведение элементов.

multiple_list = [2, 3, 4]
print(math.prod(multiple_list))
> 24

math.remainder(m, n)
Возвращает результат по формуле:

Результат = m – x * n,

где x — ближайшее целое к выражению m/n число.

print(math.remainder(55, 6))
> 1.0

print(math.remainder(4, 6))
> -2.0

math.trunc()
trunc() вернёт вам целую часть переданного в неё аргумента.

print(math.trunc(4.6))
> 4

Степенные и логарифмические функции

math.exp(x)
Возвращает e в степени x. Более точный аналог pow(math.e, x).

print(math.exp(3))
> 20.085536923187668

math.expm1(x)
Вычисляет значение выражения exp(x) - 1 и возвращает результат.

print(math.expm1(3))
> 19.085536923187668

print(math.expm1(3) == (math.exp(3) - 1))
> True

math.log()
Функция работает, как с одним, так и с двумя параметрами.

1 аргумент: вернёт значение натурального логарифма (основание e):

print(math.log(math.e))
> 1.0

2 аргумента: вернёт значение логарифма по основанию, заданному во втором аргументе:

print(math.log(16, 4))
> 2.0

☝️ Помните, это читается, как простой вопрос: «в какую степень нужно возвести число 4, чтобы получить 16«. Ответ, очевидно, 2. Функция log() с нами согласна.

math.log1p()
Это натуральный логарифм от аргумента (1 + x):

print(math.log(5) == math.log1p(4))
> True

math.log2()
Логарифм по основанию 2. Работает точнее, чем math.log(x, 2).

math.log10()
Логарифм по основанию 10. Работает точнее, чем math.log(x, 10).

math.pow(a, b)
Функция выполняет возведение числа a в степень b и возвращает затем вещественный результат.

print(math.pow(2,4))
> 16.0

math.sqrt()
Возврат квадратного корня из аргумента

print(math.sqrt(16))
> 4.0

Тригонометрические функции

math.acos()
Функция возвращает арккосинус в радианах:

print(math.acos(-1))
> 3.141592653589793

math.asin()
Возврат арксинуса (угол в радианах):

# π/2
print(math.asin(1))
> 1.5707963267948966

math.atan()
Арктангенс:

# π/4
print(math.atan(1))
> 0.7853981633974483

math.atan2(y, x)
Функция принимает на вход два аргумента и возвращает арктангенс y/x. Значение будет в радианах. atan2() учитывает четверть, в которой находится точка (x, y).

print(math.atan2(-12, 13))
> -0.7454194762741583

math.cos()
Косинус угла, который следует указывать в радианах:

print(math.cos(math.pi))
> -1.0

math.dist(p, q)
Функция возвращает значение евклидова расстояния между точками p и q. У точек должны совпадать измерения. В прямоугольной системе координат dist(p, q) эквивалентна следующей формуле:

# аналогично sqrt(8)
print(math.dist((0, 0), (2, 2)))
> 2.8284271247461903

math.hypot(x, y)
Возвращает длину вектора от начала координат до точки, заданной координатами. Иначе — функция вычисляет гипотенузу треугольника c катетами x и y.

print(math.hypot(3, 4))
> 5.0

math.sin()
Функция вернёт синус угла. Угол следует задавать в радианах:

print(math.sin(0))
> 0.0

math.tan()
Тангенс угла. Аргумент указываем в радианах.

print(math.tan(math.radians(315)))
> -1.0000000000000004

Угловые преобразования

math.degrees()
Функция переводит радианное значение угла в градусы.

print(math.degrees(math.pi))
> 180.0

math.radians()
Наоборот: из градусов — в радианы.

# функция отрабатывает прямо, как по табличке синусов =)
print(math.radians(30))
> 0.5235987755982988

print(math.pi / 6)
> 0.5235987755982988

Гиперболические функции

Гиперболические функции являются аналогами тригонометрических и тесно с ними связаны. Но тригонометрические функции основаны на окружностях, а гиперболические, соответственно, на гиперболах.

Для Python все они принимают один аргумент — точку, в которой вычисляется значение функции.

math.acosh()
Обратный гиперболический косинус:

print(math.acosh(1))
> 0.0

math.asinh()
Обратный гиперболический синус:

print(math.asinh(0))
> 0.0

math.atanh()
Обратный гиперболический тангенс:

print(math.atanh(0))
> 0.0

math.cosh()
Гиперболический косинус:

print(math.cosh(1.2))
> 1.8106555673243747

math.sinh()
Гиперболический синус:

print(math.sinh(2.5))
> 6.0502044810397875

math.tanh()
Гиперболический тангенс:

print(math.tanh(6))
> 0.9999877116507956

Специальные функции

math.erf(x)
Возвращает в x функцию ошибки Гаусса.

math.erfc(x)
Возвращает в x комплементарную функцию ошибки.

math.gamma()
Возвращает значение гамма-функции в точке x.

print(math.gamma(4))
> 6.0

math.lgamma()
Аналогично возвращается натуральный логарифм модуля значения гамма-функции в точке x.

print(math.log(math.gamma(4)))
> 1.791759469228055

print(math.lgamma(4))
> 1.7917594692280554

—

Модуль math – один из наиважнейших в Python. Этот модуль предоставляет обширный функционал для работы с числами.

math.ceil(X) – округление до ближайшего большего числа.

math.copysign(X, Y) — возвращает число, имеющее модуль такой же, как и у числа X, а знак — как у числа Y.

math.fabs(X) — модуль X.

math.factorial(X) — факториал числа X.

math.floor(X) — округление вниз.

math.fmod(X, Y) — остаток от деления X на Y.

math.frexp(X) — возвращает мантиссу и экспоненту числа.

math.ldexp(X, I) — X * 2ⁱ. Функция, обратная функции math.frexp().

math.fsum(последовательность) — сумма всех членов последовательности. Эквивалент встроенной функции sum(), но math.fsum() более точна для чисел с плавающей точкой.

math.isfinite(X) — является ли X числом.

math.isinf(X) — является ли X бесконечностью.

math.isnan(X) — является ли X NaN (Not a Number — не число).

math.modf(X) — возвращает дробную и целую часть числа X. Оба числа имеют тот же знак, что и X.

math.trunc(X) — усекает значение X до целого.

math.exp(X) — e^X.

math.expm1(X) — e^X — 1. При X → 0 точнее, чем math.exp(X)-1.

math.log(X, [base]) — логарифм X по основанию base. Если base не указан, вычисляется натуральный логарифм.

math.log1p(X) — натуральный логарифм (1 + X). При X → 0 точнее, чем math.log(1+X).

math.log10(X) — логарифм X по основанию 10.

math.log2(X) — логарифм X по основанию 2.

math.pow(X, Y) — X^Y.

math.sqrt(X) — квадратный корень из X.

math.acos(X) — арккосинус X. В радианах.

math.asin(X) — арксинус X. В радианах.

math.atan(X) — арктангенс X. В радианах.

math.atan2(Y, X) — арктангенс Y/X. В радианах. С учетом четверти, в которой находится точка (X, Y).

math.cos(X) — косинус X (X указывается в радианах).

math.sin(X) — синус X (X указывается в радианах).

math.tan(X) — тангенс X (X указывается в радианах).

math.hypot(X, Y) — вычисляет гипотенузу треугольника с катетами X и Y (math.sqrt(x * x + y * y)).

math.degrees(X) — конвертирует радианы в градусы.

math.radians(X) — конвертирует градусы в радианы.

math.cosh(X) — вычисляет гиперболический косинус.

math.sinh(X) — вычисляет гиперболический синус.

math.tanh(X) — вычисляет гиперболический тангенс.

math.acosh(X) — вычисляет обратный гиперболический косинус.

math.asinh(X) — вычисляет обратный гиперболический синус.

math.atanh(X) — вычисляет обратный гиперболический тангенс.

math.erf(X) — функция ошибок.

math.erfc(X) — дополнительная функция ошибок (1 — math.erf(X)).

math.gamma(X) — гамма-функция X.

math.lgamma(X) — натуральный логарифм гамма-функции X.

math.pi — pi = 3,1415926…

math.e — e = 2,718281…

Python offers many inbuild logarithmic functions under the module “math” which allows us to compute logs using a single line. There are 4 variants of logarithmic functions, all of which are discussed in this article.
1. log(a,(Base)) : This function is used to compute the natural logarithm (Base e) of a. If 2 arguments are passed, it computes the logarithm of the desired base of argument a, numerically value of log(a)/log(Base).
 

Syntax :
math.log(a,Base)
Parameters : 
a : The numeric value
Base :  Base to which the logarithm has to be computed.
Return Value : 
Returns natural log if 1 argument is passed and log with
specified base if 2 arguments are passed.
Exceptions : 
Raises ValueError if a negative no. is passed as argument.

Output : 

Natural logarithm of 14 is : 2.6390573296152584
Logarithm base 5 of 14 is : 1.6397385131955606

2. log2(a) : This function is used to compute the logarithm base 2 of a. Displays more accurate result than log(a,2).

Syntax :
math.log2(a)
Parameters : 
a : The numeric value
Return Value : 
Returns logarithm base 2 of a
Exceptions : 
Raises ValueError if a negative no. is passed as argument.

Output : 

Logarithm base 2 of 14 is : 3.807354922057604

3. log10(a) : This function is used to compute the logarithm base 10 of a. Displays more accurate result than log(a,10).

Syntax :
math.log10(a)
Parameters : 
a : The numeric value
Return Value : 
Returns logarithm base 10 of a
Exceptions : 
Raises ValueError if a negative no. is passed as argument.

Output : 

Logarithm base 10 of 14 is : 1.146128035678238

3. log1p(a) : This function is used to compute logarithm(1+a) . 

Syntax :
math.log1p(a)
Parameters : 
a : The numeric value
Return Value : 
Returns log(1+a)
Exceptions : 
Raises ValueError if a negative no. is passed as argument.

Output : 

Logarithm(1+a) value of 14 is : 2.70805020110221

Exception

1. ValueError : This function returns value error if number is negative. 

Output : 

log(a) value of -14 is : 

Runtime Error : 

Traceback (most recent call last):
  File "/home/8a74e9d7e5adfdb902ab15712cbaafe2.py", line 9, in 
    print (math.log(-14))
ValueError: math domain error

Practical Application

One of the application of log10() function is that it is used to compute the no. of digits of a number. Code below illustrates the same.

Output : 

The number of digits in 73293 are : 5

This article is contributed by Manjeet Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.