Введение
Примеры
Округление: круг, пол, потолок, ствол
В дополнение к встроенной 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
