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

Эта статья посвящена математическим функциям в 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

Логарифмы используются для изображения и представления больших чисел. Журнал – это величина, обратная экспоненте. В этой статье мы подробно рассмотрим функции 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]

( 16 оценок, среднее 3.88 из 5 )

Давайте рассмотрим библиотеки math и numpy для решения математических задач.

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

Библиотека math

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

• Функции теории чисел и функции представления. Рассмотрим некоторые из них:

  • math.comb(n, k) — возвращает количество сочетаний из n элементов по k элементам без повторений и без учёта порядка. Определим, сколькими способами можно выбрать 3 объекта из множества в 12 объектов (порядок не важен):

    import math
    
    print(math.comb(12, 3))  # 220
    

  • math.factorial(x) — возвращает факториал целого неотрицательного числа x:

    print(math.factorial(5))  # 120
    

  • math.gcd(*integers) — возвращает наибольший общий делитель (НОД) для чисел-аргументов. Возможность определения НОДа для более чем двух чисел появилась в Python версии 3.9:

    print(math.gcd(120, 210, 360))  # 30
    

  • math.lcm(*integers) — возвращает наименьшее общее кратное (НОК) для чисел-аргументов. Функция появилась в Python версии 3.9:

    print(math.lcm(10, 20, 30, 40))  # 120
    

  • math.perm(n, k=None) — возвращает количество размещений из n элементов по k элементам без повторений и с учётом порядка. Если значение аргумента k не задано, то возвращается количество перестановок множества из n элементов:

    print(math.perm(4, 2))  # 12
    print(math.perm(4))  # 24
    

  • math.prod(iterable, start=1) — возвращает произведение элементов итерируемого объекта iterable. Если iterable пустой, то возвращается значение именованного аргумента start:

    print(math.prod(range(10, 21)))  # 6704425728000
    

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

  • math.exp(x) — возвращает значение экспоненциальной функции e^x:

    print(math.exp(3.5))  # 33.11545195869231
    

  • math.log(x, base) — возвращает значение логарифма от x по основанию base. Если значение аргумента base не задано, то вычисляется натуральный логарифм. Вычисление производится по формуле log(x) / log(base):

    print(math.log(10))  # 2.302585092994046
    print(math.log(10, 2))  # 3.3219280948873626
    

  • math.pow(x, y) — возвращает значение x в степени y. В отличие от операции **, происходит преобразование обоих аргументов в вещественные числа:

    print(math.pow(2, 10))  # 1024.0
    print(math.pow(4.5, 3.7))  # 261.1477575641718
    

• Тригонометрические функции. Доступны функции синус (sin(x)), косинус (cos(x)), тангенс (tan(x)), арксинус (asin(x)), арккосинус (acos(x)), арктангенс (atan(x)). Обратите внимание: угол задаётся и возвращается в радианах. Имеются особенные функции:

  • math.dist(p, q) — возвращает Евклидово расстояние между точками p и q, заданными как итерируемые объекты одной длины:

    print(math.dist((0, 0, 0), (1, 1, 1)))  # 1.7320508075688772
    

  • math.hypot(*coordinates) — возвращает длину многомерного вектора с координатами, заданными в позиционных аргументах coordinates, и началом в центре системы координат. Для двумерной системы координат функция возвращает длину гипотенузы прямоугольного треугольника по теореме Пифагора:

    print(math.hypot(1, 1, 1))  # 1.7320508075688772
    print(math.hypot(3, 4))  # 5.0
    

• Функции преобразования угла. Доступны функции:

  • math.degrees(x) — преобразует угол из радианов в градусы:

    print(round(math.sin(math.radians(30)), 1))  # 0.5
    

  • math.radians(x) — преобразует угол из градусов в радианы.

    print(round(math.degrees(math.asin(0.5)), 1))  # 30.0
    

• Гиперболические функции. Доступны функции acosh(x), asinh(x), atanh(x), cosh(x), sinh(x), tanh(x).

• Специальные функции. Среди специальных функций интерес представляет Гамма-функция. Она описывает гладкую непрерывную функцию f(x) = (x – 1)!, график которой проходит через точки, соответствующие значениям функции факториала для целых чисел. Другими словами, гамма-функция интерполирует значения факториала для вещественных чисел:

  print(math.gamma(3))  # 2.0
  print(math.gamma(3.5))  # 3.323350970447842
  print(math.gamma(4))  # 6.0
  

В библиотеке math можно воспользоваться значениями числа пи (math.pi) и экспоненты (math.e).

Библиотека numpy

Язык программирования Python удобен для быстрого создания программ с целью проверки какой-либо идеи. Однако зачастую его используют и в решении научных задач, а также при анализе больших данных и машинном обучении.
Возникает вопрос: каким образом может быстро обрабатывать много данных интерпретируемая, а не скомпилированная программа?
Оказывается, что в решении некоторых математических задач программы на Python могут быть такими же быстрыми, как и программы, созданные на компилируемых языках.

Существенную прибавку в скорости обеспечивает библиотека numpy (Numerical Python, читается как «нампАй»). Библиотека numpy частично написана на языках С и «Фортран», благодаря чему и работает быстро. Таким образом, numpy сочетает в себе вычислительную мощность языков С и «Фортран» и простоту синтаксиса Python.

Библиотека numpy является нестандартной библиотекой.

Нестандартные модули можно установить в Python несколькими способами. Мы рассмотрим самый простой — установку из репозитория PyPI (Python Package Index). Репозиторий — коллекция дополнительных библиотек для Python, хранящаяся на сервере. В настоящий момент количество библиотек в репозитории составляет более 400 тысяч.

Для установки библиотек из репозитория необходимо подключение к сети Интернет, а далее нужно выполнить команду в консоли (терминале):

pip install <название библиотеки>

Установим библиотеку numpy командой:

pip install numpy

После ввода команды начнётся загрузка установочного пакета и дополнительных библиотек, от которых зависит numpy. Затем начнётся процесс установки. Если установка пройдёт успешно, то вы увидите вывод в командной строке:

Successfully installed numpy

Для импорта numpy обычно используют следующий код:

import numpy as np

В программе мы сможем обращаться к numpy по новому имени — np. Это упростит чтение кода. Такой импорт широко используется сообществом программистов, поэтому стоит его придерживаться, чтобы ваш код был понятен каждому.

Библиотека numpy работает с объектами-массивами, которые способны хранить много значений и быть многомерными. При этом, в отличие от списков, массивы могут хранить только значения одного типа. За счёт этого массивы в numpy занимают меньше памяти и работают быстрее, чем списки.

Создать массив можно разными способами. Один из них — использовать функцию array() для преобразования списка в массив. Для доступа к элементам массива необходимо указать индекс элемента в квадратных скобках. Индексация начинается с нуля:

import numpy as np

a = np.array([1, 2, 3, 4])
b = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
print(f"a[0] = {a[0]}")
print(f"b[0] = {b[0]}")

Вывод программы:

a[0] = 1
b[0] = [1 2]

В нашем примере массив a имеет размерность, равную 1. Размерность массива b равна 2. В терминологии numpy массив a имеет одну ось (термин «axis» из документации) длиной четыре элемента, а массив b имеет две оси: первая имеет длину 4, а длина второй оси равна 2.

Массивы numpy являются объектами класса ndarray. Наиболее важными атрибутами класса ndarray являются:

• ndarray.ndim — размерность (количество осей) массива;
• ndarray.shape — кортеж, значения которого содержат количество элементов по каждой из осей массива;
• ndarray.size — общее количество элементов массива;
• ndarray.dtype — объект, описывающий тип данных элементов массива;
• ndarray.itemsize — размер памяти в байтах, занимаемый одним элементом массива.

import numpy as np

a = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
print(f"a.ndim = {a.ndim}, a.shape = {a.shape}, a.size = {a.size}, a.dtype = {a.dtype}")

Вывод программы:

a.ndim = 2, a.shape = (4, 2), a.size = 8, a.dtype = int32

Встроенные в numpy типы данных аналогичны типам данных в языке программирования С. Например, в предыдущем примере мы создали массив со значениями типа int32, то есть целые числа со знаком (отрицательные и положительные) и размером занимаемой памяти 32 бита. Из ограничения в размере памяти для типов данных в numpy следует то, что массивы каждого типа данных могут хранить значения из определённого диапазона. Например, для int32 этот числовой диапазон составляет от -2 147 483 648 до 2 147 483 647.

Покажем на примере, что произойдёт, если попытаться записать значение не из диапазона для типа данных. Для этого создадим массив типа uint8 — целые числа без знака размером 8 бит. Диапазон значений для этого типа от 0 до 255. Тип данных можно указать через именованный аргумент dtype при создании массива:

import numpy as np

a = np.array([1, 2, 3], dtype="uint8")
a[0] = 256
print(a)

Вывод программы:

[0 2 3]

Значение элемента не вышло за пределы диапазона, а было взято с его начала.

В numpy существуют и другие встроенные типы данных. С ними можно ознакомиться в документации.

При создании массива без указания его типа в аргументе dtype библиотека numpy попытается привести его к тому типу данных, который сможет хранить все значения исходной коллекции.

Рассмотрим пример:

import numpy as np

a = np.array([1, 2.5, 3])
print(a)
print(a.dtype)
b = np.array(['text', 1, 2.5])
print(b)
print(b.dtype)

Вывод программы:

[1.  2.5 3. ]
float64
['text' '1' '2.5']
<U32

В примере для массива a был выбран тип данных float64, так как исходный список содержит вещественное число. Для массива b был выбран тип данных <U32, который может хранить строки в кодировке Unicode длиной 32 символа. Такой тип данных был выбран, поскольку в исходной коллекции есть элемент-строка.

Для создания массива из нулей используется функция np.zeros(), которая принимает кортеж с количеством чисел, соответствующим количеству осей массива, а значения в кортеже — количество элементов по каждой из осей.

import numpy as np

a = np.zeros((4, 3))
print(a)
print()
a = np.zeros((4, 3), dtype="int32")
print(a)

Вывод программы:

[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

[[0 0 0]
 [0 0 0]
 [0 0 0]
 [0 0 0]]

Функция np.ones() создаёт массив аналогично функции np.zeros(), только из элементов-единиц.

import numpy as np

a = np.ones((4, 3))
print(a)

Вывод программы:

[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]

Функция np.eye() создаёт единичную матрицу, то есть массив с единицами на главной диагонали и нулевыми остальными элементами:

import numpy as np

a = np.eye(5, 5, dtype="int8")
print(a)

Вывод программы:

[[1 0 0 0 0]
 [0 1 0 0 0]
 [0 0 1 0 0]
 [0 0 0 1 0]
 [0 0 0 0 1]]

Для создания массива, заполненного значениями из диапазона, используется функция np.arange(). Эта функция похожа на стандартную функцию range(), но возвращает массив и может создавать диапазон значений из вещественных чисел.

import numpy as np

a = np.arange(1, 10)
print(a)
print()
a = np.arange(1, 5, 0.4)
print(a)

Вывод программы:

[1 2 3 4 5 6 7 8 9]

[1.  1.4 1.8 2.2 2.6 3.  3.4 3.8 4.2 4.6]

Функция np.linspace() создаёт массив из заданного количества вещественных равномерно распределённых значений из указанного диапазона.

import numpy as np

a = np.linspace(1, 5, 10)  # задаётся начало, конец диапазона и количество значений
print(a)

Вывод программы:

[1.         1.44444444 1.88888889 2.33333333 2.77777778 3.22222222
 3.66666667 4.11111111 4.55555556 5.        ]

Для изменения размерности массива используется функция reshape(). Она принимает кортеж, значения которого задают новые размеры массива по осям. Функция reshape() возвращает новый массив. Обратите внимание: при изменении размерности количество элементов в массиве не должно измениться.

import numpy as np

a = np.zeros((4, 3), dtype="uint8")
print(a)
print()
a = a.reshape((2, 6))
print(a)

Вывод программы:

[[0 0 0]
 [0 0 0]
 [0 0 0]
 [0 0 0]]

[[0 0 0 0 0 0]
 [0 0 0 0 0 0]]

Метод resize() меняет размерность исходного массива:

import numpy as np

a = np.zeros((4, 3), dtype="uint8")
print(a)
print()
a.resize((2, 2, 3))
print(a)

Вывод программы:

[[0 0 0]
 [0 0 0]
 [0 0 0]
 [0 0 0]]

[[[0 0 0]
  [0 0 0]]

 [[0 0 0]
  [0 0 0]]]

Если при изменении размерности в функции reshape() указать значение -1 по одной или нескольким осям, то значения размерности рассчитаются автоматически:

import numpy as np

a = np.zeros((4, 3), dtype="uint8")
print(a)
print()
a = a.reshape((2, 3, -1))
print(a)

Вывод программы:

[[0 0 0]
 [0 0 0]
 [0 0 0]
 [0 0 0]]

[[[0 0]
  [0 0]
  [0 0]]

 [[0 0]
  [0 0]
  [0 0]]]

Для работы с массивами доступны все стандартные арифметические операции, а также тригонометрические, экспоненциальная и другие функции. Выполнение математических операций над массивами происходит поэлементно. Размерность массивов должна совпадать при выполнении этих операций. Применение некоторых из операций приведено в примере:

import numpy as np

a = np.array([9, 8, 7])
b = np.array([1, 2, 3])
print(a + b)
print(a - b)
print(a * b)
print(a / b)

Вывод программы:

[10 10 10]
[8 6 4]
[ 9 16 21]
[9.         4.         2.33333333]

Для умножения матриц используется операция @ или функция dot:

import numpy as np

a = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
b = np.array([[0, 0, 1],
              [0, 1, 0],
              [1, 0, 0]])
print(a @ b)

Вывод программы:

[[3 2 1]
 [6 5 4]
 [9 8 7]]

Матрицы можно транспонировать функцией transpose() и поворачивать функцией rot90(). При повороте можно указать направление поворота вторым аргументом:

import numpy as np

a = np.arange(1, 13).reshape(4, 3)
print(a)
print("Транспонирование")
print(a.transpose())
print("Поворот вправо")
print(np.rot90(a))
print("Поворот влево")
print(np.rot90(a, -1))

Вывод программы:

[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
Транспонирование
[[ 1  4  7 10]
 [ 2  5  8 11]
 [ 3  6  9 12]]
Поворот вправо
[[ 3  6  9 12]
 [ 2  5  8 11]
 [ 1  4  7 10]]
Поворот влево
[[10  7  4  1]
 [11  8  5  2]
 [12  9  6  3]]

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

import numpy as np

a = np.array([[1, 2, 3],
             [4, 5, 6],
             [7, 8, 9]])
print(a.sum())
print(a.min())
print(a.max())

Вывод программы:

45
1
9

Дополнительно в указанных функциях можно указать номер оси (индексация с 0), на которой будет работать функция:

import numpy as np

a = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
print(a.sum(axis=0))  # сумма чисел в каждом столбце
print(a.sum(axis=1))  # сумма чисел в каждой строке
print(a.min(axis=0))  # минимум по столбцам
print(a.max(axis=1))  # максимум по строкам

Вывод программы:

[12 15 18]
[ 6 15 24]
[1 2 3]
[3 6 9]

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

import numpy as np

a = np.arange(1, 13).reshape(3, 4)
print(a)
print()
print(a[:2, 2:])
print()
print(a[:, ::2])

Вывод программы:

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

[[3 4]
 [7 8]]

[[ 1  3]
 [ 5  7]
 [ 9 11]]

В цикле for можно пройти по элементам первой оси массива:

import numpy as np

a = np.arange(1, 13).reshape(3, 4)
print(a)
for row in a:
    print(row)

Вывод программы:

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

[1 2 3 4]
[5 6 7 8]
[ 9 10 11 12]

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

import numpy as np

a = np.arange(1, 13).reshape(3, 4)
print(a)
print()
print("; ".join(str(el) for el in a.flat))

Вывод программы:

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12

Покажем на примере различие в скорости работы массивов и списков. Посчитаем сумму квадратных корней первых 10⁷ чисел.

import numpy as np
from time import time

t = time()
print(f"Результат итератора: {sum(x ** 0.5 for x in range(10 ** 7))}.")
print(f"{time() - t} с.")
t = time()
print(f"Результат numpy: {np.sqrt(np.arange(10 ** 7)).sum()}.")
print(f"{time() - t} с.")

Вывод программы:

Результат итератора: 21081849486.439312.
1.7823209762573242 с.
Результат numpy: 21081849486.442448.
0.05197310447692871 с.

Библиотека numpy решила задачу в 30 раз быстрее, чем итератор.

За счёт скорости работы и удобной обработки массивов библиотека numpy используется для расчётов во многих других библиотеках. С одной из них мы поработаем в следующей главе.

Ещё по теме

Для более детального изучения библиотеки numpy рекомендуем почитать документацию.

В этом уроке мы познакомимся с встроенным модулем стандартной библиотеки Python. Этот модуль предоставляет множество функций для математических вычислений. В целях ускорения вычислений данный модуль «под капотом» написан на языке C.

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

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

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

from math import floor, ceil

float_var = 3.14
first_int_var = floor(float_var)
second_int_var = ceil(float_var)
print(f'Число {float_var} имеет тип {type(float_var)}')
print(f'Округляем число {float_var} вниз и получаем {first_int_var}')
print('С типом', type(first_int_var))
print(f'Округляем число {float_var} вверх и получаем {second_int_var}')
print('С типом', type(second_int_var))
# Вывод:
Число 3.14 имеет тип <class 'float'>
Округляем число 3.14 вниз и получаем 3
С типом <class 'int'>
Округляем число 3.14 вверх и получаем 4
С типом <class 'int'>
  

Не забудьте импортировать модуль math в свой проект!

Функция fabs() — модуль числа

Как и встроенная функция Питона abs, функция math.fabs возвращает модуль числа (если чило отрицательное, то отбрасывается знак «-»). Но есть между ними и важные отличия. Во-первых, math.fabs не предназначена для работы с комплексными числами, во-вторых, в отличие от abs, она возвращает не целочисленное, а дробное число.

from math import fabs

var = -3
first_int_var = abs(var)
second_int_var = fabs(var)
print(f'Число {var} имеет тип {type(float_var)}')
print(f'Модуль числа {var}, полученный функцией abs: {first_int_var}')
print('С типом', type(first_int_var))
print(f'Модуль числа {float_var}, полученный функцией fabs: {second_int_var}')
print('С типом', type(second_int_var))
print(abs(complex(1, 2)))
print(fabs(complex(1, 2)))
# Вывод:
Число -3 имеет тип <class 'int'>
Модуль числа -3, полученный функцией abs: 3
С типом <class 'int'>
Модуль числа -3, полученный функцией fabs: 3.0
С типом <class 'float'>
2.23606797749979
Traceback (most recent call last):
File "C:UsersivandAppDataRoamingJetBrainsPyCharm2021.2scratchesscratch.py", line 12, in
print(fabs(complex(1, 2)))
TypeError: can't convert complex to float
  

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

Эта функция предназначена для получения факториала.
Пример:

from math import factorial

var = 3
first_int_var = factorial(var)
print(f'Число {var} имеет тип {type(var)}')
print(f'Факториал числа {var}, полученный функцией factorial: {first_int_var}')
print('С типом', type(first_int_var))
# Вывод:
Число 3 имеет тип <class 'int'>
Факториал числа 3, полученный функцией factorial: 6
С типом <class 'int'>
  

Естественно, функция принимает только целое положительное число.

from math import factorial

var = -3
first_int_var = factorial(var)
print(f'Число {var} имеет тип {type(var)}')
print(f'Факториал числа {var}, полученный функцией factorial: {first_int_var}')
print('С типом', type(first_int_var))
# Вывод:
Traceback (most recent call last):
File "C:UsersivandAppDataRoamingJetBrainsPyCharm2021.2scratchesscratch.py", line 4, in
first_int_var = factorial(var)
ValueError: factorial() not defined for negative values
from math import factorial

  

var = 3.14
first_int_var = factorial(var)
print(f'Число {var} имеет тип {type(var)}')
print(f'Факториал числа {var}, полученный функцией factorial: {first_int_var}')
print('С типом', type(first_int_var))
# Вывод:
C:UsersivandAppDataRoamingJetBrainsPyCharm2021.2scratchesscratch.py:4: DeprecationWarning: Using factorial() with floats is deprecated
first_int_var = factorial(var)
Traceback (most recent call last):
File "C:UsersivandAppDataRoamingJetBrainsPyCharm2021.2scratchesscratch.py", line 4, in
first_int_var = factorial(var)
ValueError: factorial() only accepts integral values
  

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

Функция fmod() является расширением оператора % — в отличие от него, данная функция может работать с числами с плавающей точкой.
Пример:

from math import fmod

var = 3.14
print('fmod(var, 2)', fmod(var, 2))
print('fmod(2, var)', fmod(2, var))
print('fmod(var, 1)', fmod(var, 1))
print('fmod(var, 3.14)', fmod(var, 3.14))
print('fmod(var, 50)', fmod(var, 50))
# Вывод:
fmod(var, 2) 1.1400000000000001
fmod(2, var) 2.0
fmod(var, 1) 0.14000000000000012
fmod(var, 3.14) 0.0
fmod(var, 50) 3.14
  

Функция frexp()

Эта функция возвращает мантиссу и показатель степени.
Пример:

from math import frexp

var = 3.14
print('frexp(var)', frexp(var))
# Вывод:
frexp(var) (0.785, 2)
  

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

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

from math import fsum

var_list = [1/i for i in range(1, 10)]
print(f'Сумма элементов последовательностиn{var_list}nравна', fsum(var_list))
# Вывод:
Сумма элементов последовательности
[1.0, 0.5, 0.3333333333333333, 0.25, 0.2, 0.16666666666666666, 0.14285714285714285, 0.125, 0.1111111111111111]
равна 2.828968253968254
  

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

Функция exp()

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

from math import exp

var_list = 3.14
print(f'exp(3.14):', exp(var_list))
# Вывод:
exp(3.14): 23.103866858722185
  

Функция expm1()

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

from math import exp, expm1

var_list = 3.14
print(f'exp(3.14) - 1:', exp(var_list) - 1)
print(f'expm1(3.14):', expm1(var_list))
# Вывод:
exp(3.14) - 1: 22.103866858722185
expm1(3.14): 22.103866858722185
  

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

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

from math import log

var_list = 3.14
print(f'log(3.14):', log(var_list))
# Вывод:
log(3.14): 1.144222799920162
  

Функция log1p()

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

from math import log, log1p

var_list = 3.14
print(f'log(3.14 + 1):', log(var_list + 1))
print(f'log1p(3.14):', log1p(var_list))
# Вывод:
log(3.14 + 1): 1.420695787837223
log1p(3.14): 1.420695787837223
  

Функция log10()

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

from math import log10

var_list = 3.14
print(f'log10(3.14):', log10(var_list))
# Вывод:
log10(3.14): 0.49692964807321494
  

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

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

from math import pow

var_list = 3.14
print(f'pow(3.14, 10):', pow(var_list, 10))
print(f'pow(10, 3.14):', pow(10, var_list))
print(f'pow(10, 10):', pow(10, 10))
# Вывод:
pow(3.14, 10): 93174.3733866435
pow(10, 3.14): 1380.3842646028852
pow(10, 10): 10000000000.0
  

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

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

from math import sqrt

var_list = 3.14
print(f'sqrt(3.14):', sqrt(var_list))
print(f'sqrt(93174.3733866435):', sqrt(93174.3733866435))
print(f'sqrt(10000000000):', sqrt(10000000000))
# Вывод:
sqrt(3.14): 1.772004514666935
sqrt(93174.3733866435): 305.2447761824001
sqrt(10000000000): 100000.0

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

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

Пример:

from math import sin, cos, tan, acos, atan, sinh, acosh, atanh, asin

var = 0.5
print('sin(var):', sin(var))
print('cos(var):', cos(var))
print('tan(var):', tan(var))
print('acos(var):', acos(var))
print('asin(var):', asin(var))
print('atan(var):', atan(var))
print('sinh(var):', sinh(var))
print('acosh(3.14):', acosh(3.14))
print('atanh(var):', atanh(var))
# Вывод:
sin(var): 0.479425538604203
cos(var): 0.8775825618903728
tan(var): 0.5463024898437905
acos(var): 1.0471975511965979
asin(var): 0.5235987755982989
atan(var): 0.4636476090008061
sinh(var): 0.5210953054937474
acosh(3.14): 1.810991348900196
atanh(var): 0.5493061443340549
  

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

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

from math import degrees, radians

var_1 = 3.14
var_2 = 4.13
print('degrees(var_1):', degrees(var_1))
print('radians(var_2):', radians(var_2))
# Вывод:
degrees(var_1): 179.9087476710785
radians(var_2): 0.07208209810736581
  

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

В Python есть две математические константы: pi и e.
1. pi: это математическая константа со значением 3.1416..
2. e: это математическая константа со значением 2.7183..
Пример:

import math

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

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

Содержание

• 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

  ⇑

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

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

  ⇑