Python Language
Математический модуль

Округление: круглое, напольное, потолочное, trunc

В дополнение к встроенной round функции, то math модуль обеспечивает floor , ceil и trunc функции.

x = 1.55
y = -1.55

# round to the nearest integer
round(x)       #  2
round(y)       # -2

# the second argument gives how many decimal places to round to (defaults to 0)
round(x, 1)    #  1.6
round(y, 1)    # -1.6

# math is a module so import it first, then use it.
import math

# get the largest integer less than x
math.floor(x)  #  1
math.floor(y)  # -2

# get the smallest integer greater than x
math.ceil(x)   #  2
math.ceil(y)   # -1

# drop fractional part of x
math.trunc(x)  #  1, equivalent to math.floor for positive numbers
math.trunc(y)  # -1, equivalent to math.ceil for negative numbers

round(1.3)  # 1.0

round(0.5)  # 1.0
round(1.5)  # 2.0

round(1.3)      # 1
round(1.33, 1)  # 1.3

round(0.5)  # 0
round(1.5)  # 2

Предупреждение!

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

round(2.675, 2)  # 2.67, not 2.68!

Предупреждение о полу, trunc и целочисленном делении отрицательных чисел

Python (и C ++ и Java) округляются от нуля для отрицательных чисел. Рассматривать:

>>> math.floor(-1.7)
-2.0
>>> -5 // 2
-3

Логарифмы

math.log(x) дает естественный (базовый e ) логарифм x .

math.log(math.e)  # 1.0
math.log(1)       # 0.0
math.log(100)     # 4.605170185988092

math.log может потерять точность с числами, близкими к 1, из-за ограничений чисел с плавающей запятой. Чтобы точно подсчитать логарифмы, близкие к 1, используйте math.log1p , который оценивает естественный логарифм 1 плюс аргумент:

math.log(1 + 1e-20)  # 0.0
math.log1p(1e-20)    # 1e-20

math.log10 может использоваться для базы бревна 10:

math.log10(10)  # 1.0

math.log(100, 10) # 2.0
math.log(27, 3)   # 3.0
math.log(1, 10)   # 0.0

Копирование знаков

В Python 2.6 и выше math.copysign(x, y) возвращает x со знаком y . Возвращаемое значение всегда является float .

math.copysign(-2, 3)    # 2.0
math.copysign(3, -3)    # -3.0
math.copysign(4, 14.2)  # 4.0
math.copysign(1, -0.0)  # -1.0, on a platform which supports signed zero

тригонометрия

Вычисление длины гипотенузы

math.hypot(2, 4) # Just a shorthand for SquareRoot(2**2 + 4**2)
# Out: 4.47213595499958

Преобразование градусов в / из радианов

Все math функции ожидают радианов, поэтому вам нужно преобразовать градусы в радианы:

math.radians(45)              # Convert 45 degrees to radians
# Out: 0.7853981633974483

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

math.degrees(math.asin(1))    # Convert the result of asin to degrees
# Out: 90.0

Синус, косинус, касательная и обратная функции

# Sine and arc sine
math.sin(math.pi / 2)
# Out: 1.0
math.sin(math.radians(90))   # Sine of 90 degrees
# Out: 1.0

math.asin(1)
# Out: 1.5707963267948966    # "= pi / 2"
math.asin(1) / math.pi
# Out: 0.5

# Cosine and arc cosine:
math.cos(math.pi / 2)
# Out: 6.123233995736766e-17 
# Almost zero but not exactly because "pi" is a float with limited precision!

math.acos(1)
# Out: 0.0

# Tangent and arc tangent:
math.tan(math.pi/2)
# Out: 1.633123935319537e+16 
# Very large but not exactly "Inf" because "pi" is a float with limited precision

math.atan(math.inf)
# Out: 1.5707963267948966 # This is just "pi / 2"

math.atan(float('inf'))
# Out: 1.5707963267948966 # This is just "pi / 2"

Помимо math.atan существует также функция с двумя аргументами math.atan2 , которая вычисляет правильный квадрант и избегает ловушек деления на ноль:

math.atan2(1, 2)   # Equivalent to "math.atan(1/2)"
# Out: 0.4636476090008061 # ≈ 26.57 degrees, 1st quadrant

math.atan2(-1, -2) # Not equal to "math.atan(-1/-2)" == "math.atan(1/2)"
# Out: -2.677945044588987 # ≈ -153.43 degrees (or 206.57 degrees), 3rd quadrant

math.atan2(1, 0)   # math.atan(1/0) would raise ZeroDivisionError
# Out: 1.5707963267948966 # This is just "pi / 2"

Гиперболический синус, косинус и касательная

# Hyperbolic sine function
math.sinh(math.pi) # = 11.548739357257746
math.asinh(1)      # = 0.8813735870195429

# Hyperbolic cosine function
math.cosh(math.pi) # = 11.591953275521519
math.acosh(1)      # = 0.0

# Hyperbolic tangent function
math.tanh(math.pi) # = 0.99627207622075
math.atanh(0.5)    # = 0.5493061443340549

Константы

math модули включают в себя две часто используемые математические константы.

• math.pi - Математическая константа pi
• math.e - Математическая константа e (основа натурального логарифма)

>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045
>>>

Python 3.5 и выше имеют константы бесконечности и NaN («не число»). Более старый синтаксис передачи строки в float() прежнему работает.

math.inf == float('inf')
# Out: True

-math.inf == float('-inf')
# Out: True

# NaN never compares equal to anything, even itself
math.nan == float('nan')
# Out: False

Воображаемые числа

Воображаемые числа в Python представлены «j» или «J», заканчивающими целевой номер.

1j         # Equivalent to the square root of -1.
1j * 1j    # = (-1+0j)

Бесконечность и NaN («не число»)

Во всех версиях Python мы можем представить бесконечность и NaN («не число») следующим образом:

pos_inf = float('inf')     # positive infinity
neg_inf = float('-inf')    # negative infinity
not_a_num = float('nan')   # NaN ("not a number")

В Python 3.5 и выше мы также можем использовать определенные константы math.inf и math.nan :

pos_inf = math.inf
neg_inf = -math.inf
not_a_num = math.nan

Строковые представления отображаются как inf и -inf и nan :

pos_inf, neg_inf, not_a_num
# Out: (inf, -inf, nan)

Мы можем проверить либо положительную, либо отрицательную бесконечность с isinf метода isinf :

math.isinf(pos_inf)
# Out: True

math.isinf(neg_inf)
# Out: True

Мы можем точно проверить положительную бесконечность или отрицательную бесконечность путем прямого сравнения:

pos_inf == float('inf')    # or  == math.inf in Python 3.5+
# Out: True

neg_inf == float('-inf')   # or  == -math.inf in Python 3.5+
# Out: True

neg_inf == pos_inf
# Out: False

Python 3.2 и выше также позволяет проверять конечность:

math.isfinite(pos_inf)
# Out: False

math.isfinite(0.0)
# Out: True

Операторы сравнения работают как ожидалось для положительной и отрицательной бесконечности:

import sys

sys.float_info.max
# Out: 1.7976931348623157e+308  (this is system-dependent)

pos_inf > sys.float_info.max
# Out: True

neg_inf < -sys.float_info.max
# Out: True

Но если арифметическое выражение создает значение, большее максимального, которое может быть представлено как float , оно станет бесконечным:

pos_inf == sys.float_info.max * 1.0000001
# Out: True

neg_inf == -sys.float_info.max * 1.0000001
# Out: True

Однако деление на ноль не дает результата бесконечности (или, при необходимости, отрицательной бесконечности), а скорее вызывает исключение ZeroDivisionError .

try:
    x = 1.0 / 0.0
    print(x)
except ZeroDivisionError:
    print("Division by zero")

# Out: Division by zero

Арифметические операции на бесконечности дают бесконечные результаты или иногда NaN:

-5.0 * pos_inf == neg_inf
# Out: True

-5.0 * neg_inf == pos_inf
# Out: True

pos_inf * neg_inf == neg_inf
# Out: True

0.0 * pos_inf
# Out: nan

0.0 * neg_inf
# Out: nan

pos_inf / pos_inf
# Out: nan

NaN никогда не сравнится ни с чем, даже с самим собой. Мы можем протестировать его с isnan метода isnan :

not_a_num == not_a_num
# Out: False

math.isnan(not_a_num)
Out: True

NaN всегда сравнивается как «не равно», но не меньше или больше:

not_a_num != 5.0   # or any random value
# Out: True

not_a_num > 5.0   or   not_a_num < 5.0   or   not_a_num == 5.0
# Out: False

Арифметические операции на NaN всегда дают NaN. Это включает умножение на -1: нет отрицательного NaN.

5.0 * not_a_num
# Out: nan

float('-nan')
# Out: nan

-math.nan
# Out: nan

Существует одно тонкое различие между старыми версиями float NaN и бесконечности и константами math библиотеки Python 3.5+:

math.inf is math.inf, math.nan is math.nan
# Out: (True, True)

float('inf') is float('inf'), float('nan') is float('nan')
# Out: (False, False)

Pow для более быстрого возведения в степень

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

> python -m timeit 'for x in xrange(50000): b = x**3'
10 loops, best of 3: 51.2 msec per loop
> python -m timeit 'from math import pow' 'for x in xrange(50000): b = pow(x,3)' 
100 loops, best of 3: 9.15 msec per loop

Встроенный ** оператор часто пригодится, но если производительность имеет значение, используйте math.pow. Не забудьте отметить, однако, что pow возвращает float, даже если аргументы целые:

> from math import pow
> pow(5,5)
3125.0

Сложные числа и модуль cmath

Модуль cmath похож на math модуль, но определяет функции для сложной плоскости.

Прежде всего, комплексные числа являются числовым типом, который является частью языка Python, а не предоставлен классом библиотеки. Таким образом, нам не нужно import cmath для обычных арифметических выражений.

Заметим, что мы используем j (или J ), а не i .

z = 1 + 3j

Мы должны использовать 1j так как j будет именем переменной, а не числовым литералом.

1j * 1j
Out: (-1+0j)

1j ** 1j
# Out: (0.20787957635076193+0j)     # "i to the i"  ==  math.e ** -(math.pi/2)

Мы имеем real часть и imag (мнимую) часть, а также комплексное conjugate :

# real part and imaginary part are both float type
z.real, z.imag
# Out: (1.0, 3.0)

z.conjugate()
# Out: (1-3j)    # z.conjugate() == z.real - z.imag * 1j

Встроенные функции abs и complex также являются частью самого языка и не требуют импорта:

abs(1 + 1j)
# Out: 1.4142135623730951     # square root of 2

complex(1)
# Out: (1+0j)

complex(imag=1)
# Out: (1j)

complex(1, 1)
# Out: (1+1j)

complex функция может принимать строку, но она не может иметь пробелов:

complex('1+1j')
# Out: (1+1j)

complex('1 + 1j')
# Exception: ValueError: complex() arg is a malformed string

Но для большинства функций нам нужен модуль, например sqrt :

import cmath

cmath.sqrt(-1)
# Out: 1j

Естественно, поведение sqrt различно для сложных чисел и действительных чисел. В некоммерческой math квадратный корень отрицательного числа вызывает исключение:

import math

math.sqrt(-1)
# Exception: ValueError: math domain error

Для преобразования в полярные координаты и из них предусмотрены функции:

cmath.polar(1 + 1j)
# Out: (1.4142135623730951, 0.7853981633974483)    # == (sqrt(1 + 1), atan2(1, 1))

abs(1 + 1j), cmath.phase(1 + 1j)
# Out: (1.4142135623730951, 0.7853981633974483)    # same as previous calculation

cmath.rect(math.sqrt(2), math.atan(1))
# Out: (1.0000000000000002+1.0000000000000002j)

Математическое поле комплексного анализа выходит за рамки этого примера, но многие функции в комплексной плоскости имеют «ветвь разреза», обычно вдоль вещественной оси или мнимой оси. Большинство современных платформ поддерживают «подписанный ноль», как указано в IEEE 754, что обеспечивает непрерывность этих функций по обеим сторонам среза. Следующий пример из документации Python:

cmath.phase(complex(-1.0, 0.0))
# Out: 3.141592653589793

cmath.phase(complex(-1.0, -0.0))
# Out: -3.141592653589793

Модуль cmath также предоставляет множество функций с прямыми аналогами из math модуля.

В дополнение к sqrt существуют сложные версии exp , log , log10 , тригонометрические функции и их обратные ( sin , cos , tan , asin , acos , atan ) и гиперболические функции и их обратные ( sinh , cosh , tanh , asinh , acosh , atanh ). Обратите внимание, однако, нет сложного аналога math.atan2 , math.atan2 формы арктангенса.

cmath.log(1+1j)
# Out: (0.34657359027997264+0.7853981633974483j)

cmath.exp(1j * cmath.pi)
# Out: (-1+1.2246467991473532e-16j)   # e to the i pi == -1, within rounding error

Предусмотрены константы pi и e . Обратите внимание, что это float и не complex .

type(cmath.pi)
# Out: <class 'float'>

Модуль cmath также предоставляет сложные версии isinf и (для Python isfinite ) isfinite . См. « Бесконечность и NaN ». Комплексное число считается бесконечным, если его действительная часть или ее мнимая часть бесконечна.

cmath.isinf(complex(float('inf'), 0.0))
# Out: True

Аналогично, модуль cmath предоставляет сложную версию isnan . См. « Бесконечность и NaN ». Сложное число считается «не числом», если либо его действительная часть, либо ее мнимая часть «не является числом».

cmath.isnan(0.0, float('nan'))
# Out: True 

Обратите внимание, что нет cmath аналога math.inf и math.nan (от Python 3.5 и выше)

cmath.isinf(complex(0.0, math.inf))
# Out: True

cmath.isnan(complex(math.nan, 0.0))
# Out: True

cmath.inf
# Exception: AttributeError: module 'cmath' has no attribute 'inf'

В Python 3.5 и выше существует метод isclose как в cmath и в math модулях.

z = cmath.rect(*cmath.polar(1+1j))

z
# Out: (1.0000000000000002+1.0000000000000002j)

cmath.isclose(z, 1+1j)
# True