Документация по Python

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

В: Документация по Python

Введение

Примеры

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

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

Синтаксис

Параметры

Примечания

Еще от кодкамп
Замечательно! Вы успешно подписались.
Добро пожаловать обратно! Вы успешно вошли
Вы успешно подписались на кодкамп.
Срок действия вашей ссылки истек.
Ура! Проверьте свою электронную почту на наличие волшебной ссылки для входа.
Успех! Ваша платежная информация обновлена.
Ваша платежная информация не была обновлена.