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

Введение

Примеры

Округление: круг, пол, потолок, ствол

В дополнение к встроенной 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

`floor`,` ceil`, `trunc` и` round` всегда возвращают `float`. round (1.3) # 1.0 `round` всегда разрывает связи от нуля. раунд (0,5) # 1,0 раунд (1,5) # 2,0 `floor`,` ceil` и `trunc` всегда возвращают значение` Integral`, тогда как `round` возвращает значение` Integral`, если вызывается с одним аргументом. round (1.3) # 1 round (1.33, 1) # 1.3 `round` разрывает связи в направлении ближайшего четного числа. Это исправляет смещение в сторону больших чисел при выполнении большого количества вычислений. раунд (0,5) # 0 раунд (1,5) # 2 Предупреждение!

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

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

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

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 (x, base)` дает логарифм `x` в данном` base` (то есть `log (x) / log (base)`. 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, на платформе, которая поддерживает нулевой знак

тригонометрия Расчет длины гипотенузы

 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 # Это просто "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 - математическая константа пи
math.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 никогда не сравнивается ни с чем, даже сам 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 методом:

 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 способом:

 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 и бесконечности и Python 3.5+ math библиотеки констант:

math.inf - это math.inf, math.nan - это math.nan # Out: (True, True) float('inf') - это float('inf'), float('nan') - это 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 , два аргумента-форма арктангенса.

 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 3.2+) 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 # Исключение: AttributeError: модуль 'cmath' не имеет атрибута ' инф»

В 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