Базовые математические операторы

Введение

Примеры

  • 7

    прибавление

     a, b = 1, 2
    
    # Using the "+" operator:
    a + b                  # = 3
    
    # Using the "in-place" "+=" operator to add and assign:
    a += b                 # a = 3 (equivalent to a = a + b)
    
    import operator        # contains 2 argument arithmetic functions for the examples
    
    operator.add(a, b)     # = 5  since a is set to 3 right before this line
    
    # The "+=" operator is equivalent to: 
    a = operator.iadd(a, b)    # a = 5 since a is set to 3 right before this line
    
     

    Возможные комбинации (встроенные типы):

    • int и int (дает int )
    • int и float (дает float )
    • int и complex (дает complex )
    • float и float (дает float )
    • float и complex (дает complex )
    • complex и complex (дает complex )

    Примечание: + оператор также используется для конкатенации строк, списков и кортежей:

     "first string " + "second string"    # = 'first string second string'
    
    [1, 2, 3] + [4, 5, 6]                # = [1, 2, 3, 4, 5, 6] 
  • 2

    Вычитание

     a, b = 1, 2
    
    # Using the "-" operator:
    b - a                  # = 1
    
    
    import operator        # contains 2 argument arithmetic functions
    operator.sub(b, a)     # = 1
     

    Возможные комбинации (встроенные типы):

    • int и int (дает int )
    • int и float (дает float )
    • int и complex (дает complex )
    • float и float (дает float )
    • float и complex (дает complex )
    • complex и complex (дает complex )
  • 2

    умножение

     a, b = 2, 3
    
    a * b                  # = 6
    
    import operator
    operator.mul(a, b)     # = 6
    
     

    Возможные комбинации (встроенные типы):

    • int и int (дает int )
    • int и float (дает float )
    • int и complex (дает complex )
    • float и float (дает float )
    • float и complex (дает complex )
    • complex и complex (дает complex )

    Примечание: * оператор также используется для повторного конкатенации строк, списков и кортежей:

     3 * 'ab'  # = 'ababab'
    3 * ('a', 'b')  # = ('a', 'b', 'a', 'b', 'a', 'b') 
  • 11

    разделение

    Python выполняет целочисленное деление, когда оба операнда являются целыми числами. Поведение операторов деления Python изменились с 2.x и 3.x Python (также см https://codecamp.ru/documentation/python/809/incompatibilities-moving-from-python-2-to-python-3/ 2797 / целочисленное деление ).

     a, b, c, d, e = 3, 2, 2.0, -3, 10
    
     
    В Python 2 результат оператора '/' зависит от типа числителя и знаменателя. a / b # = 1 a / c # = 1,5 d / b # = -2 b / a # = 0 d / e # = -1 Обратите внимание, что поскольку `a` и` b` являются `int`s, Результатом является `int`. Результат всегда округляется до нуля. Поскольку `c` является float, результатом` a / c` является `float`. Вы также можете использовать модуль оператора: оператор оператора # # модуль оператора предоставляет арифметические функции с двумя аргументами operator.div (a, b) # = 1 оператор .__ div __ (a, b) # = 1

    Что делать, если вы хотите разделить поплавки:

    Рекомендуемые:

     from __future__ import division # applies Python 3 style division to the entire module
    a / b                  # = 1.5 
    a // b                 # = 1
    
     

    Хорошо (если вы не хотите применять ко всему модулю):

     a / (b * 1.0)          # = 1.5
    1.0 * a / b            # = 1.5
    a / b * 1.0            # = 1.0    (careful with order of operations)
    
    from operator import truediv
    truediv(a, b)          # = 1.5
    
     

    Не рекомендуется (может вызывать TypeError, например, если аргумент сложный):

     float(a) / b           # = 1.5
    a / float(b)           # = 1.5
    
    
     
    Оператор «//» в Python 2 вызывает разделение по этажам независимо от типа. a // b # = 1 a // c # = 1.0

    В Python 3, / оператор выполняет «истинные» разделения независимо от типа. // оператор выполняет вольные деление и поддерживает тип.

     a / b                  # = 1.5 
    e / b                  # = 5.0
    a // b                 # = 1
    a // c                 # = 1.0
    
    import operator            # the operator module provides 2-argument arithmetic functions
    operator.truediv(a, b)     # = 1.5
    operator.floordiv(a, b)    # = 1
    operator.floordiv(a, c)    # = 1.0
    
     

    Возможные комбинации (встроенные типы):

    • int и int (дает int в Python 2 и float в Python 3)
    • int и float (дает float )
    • int и complex (дает complex )
    • float и float (дает float )
    • float и complex (дает complex )
    • complex и complex (дает complex )

    См PEP 238 для получения дополнительной информации.

  • 6

    возведения

     a, b = 2, 3
    
    (a ** b)               # = 8
    pow(a, b)              # = 8
    
    import math
    math.pow(a, b)         # = 8.0 (always float; does not allow complex results)
    
    import operator
    operator.pow(a, b)     # = 8
    
     

    Еще одно различия между встроенным pow и math.pow является то , что встроенный pow может принимать три аргумента:

     a, b, c = 2, 3, 2
    
    pow(2, 3, 2)           # 0, calculates (2 ** 3) % 2, but as per Python docs,
                           #    does so more efficiently
    
     

    Специальные функции

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

     import math
    import cmath
    c = 4
    math.sqrt(c)           # = 2.0 (always float; does not allow complex results)
    cmath.sqrt(c)          # = (2+0j) (always complex)
    
     

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

      import math
     x = 8
     math.pow(x, 1/3) # evaluates to 2.0
     x**(1/3) # evaluates to 2.0
    
     

    Функция math.exp(x) вычисляет e ** x .

     math.exp(0)  # 1.0
    math.exp(1)  # 2.718281828459045 (e)
    
     

    Функция math.expm1(x) вычисляет e ** x - 1 . Когда x мала, то это дает значительно лучшую точность , чем math.exp(x) - 1 .

     math.expm1(0)       # 0.0
    
    math.exp(1e-6) - 1  # 1.0000004999621837e-06
    math.expm1(1e-6)    # 1.0000005000001665e-06
    # exact result      # 1.000000500000166666708333341666... 
  • 2

    Логарифмы

    По умолчанию math.log функция вычисляет логарифм числа, по основанию е. Вы можете при желании указать базу в качестве второго аргумента.

     import math
    import cmath
    
    math.log(5)         # = 1.6094379124341003
    # optional base argument. Default is math.e
    math.log(5, math.e) # = 1.6094379124341003
    cmath.log(5)        # = (1.6094379124341003+0j)
    math.log(1000, 10)   # 3.0 (always returns float)
    cmath.log(1000, 10)  # (3+0j)
    
     

    Специальные вариации math.log функции существуют для различных оснований.

     # Logarithm base e - 1 (higher precision for low values)
    math.log1p(5)       # = 1.791759469228055
    
    # Logarithm base 2
    math.log2(8)        # = 3.0
    
    # Logarithm base 10
    math.log10(100)     # = 2.0
    cmath.log10(100)    # = (2+0j) 
  • 3

    Операции на месте

    В приложениях обычно требуется такой код:

     a = a + 1
    
     

    или же

     a = a * 2
    
     

    Для этих операций на месте есть эффективный ярлык:

     a += 1
    # and
    a *= 2
    
     

    Любой математический оператор может использоваться перед символом '=' для выполнения операции на месте:

    • -= декремент переменной в месте
    • += Приращение переменной в месте
    • *= Умножить переменную на месте
    • /= Разделить переменную на месте
    • //= пол разделить переменную на месте # Python 3
    • %= Возвращают модуль переменной вместо
    • **= поднять на мощность в месте

    Другие в месте операторов существуют для поразрядных операторов ( ^ , | и т.д.)

  • 4

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

     a, b = 1, 2
    
    import math
    
    math.sin(a)  # returns the sine of 'a' in radians
    # Out: 0.8414709848078965
    
    math.cosh(b)  # returns the inverse hyperbolic cosine of 'b' in radians
    # Out: 3.7621956910836314
    
    math.atan(math.pi)  # returns the arc tangent of 'pi' in radians
    # Out: 1.2626272556789115
    
    math.hypot(a, b) # returns the Euclidean norm, same as math.sqrt(a*a + b*b)
    # Out: 2.23606797749979
    
     

    Обратите внимание , что math.hypot(x, y) также длина вектора (или евклидово расстояние) от начала координат (0, 0) до точки (x, y) .

    Для вычисления евклидова расстояния между двумя точками (x1, y1) и (x2, y2) можно использовать math.hypot следующих

     math.hypot(x2-x1, y2-y1) 

    Для преобразования из радиана -> степеней и степеней -> радиан соответственно использовать math.degrees и math.radians

     math.degrees(a)
    # Out: 57.29577951308232
    
    math.radians(57.29577951308232)
    # Out: 1.0 
  • 2

    модуль

    Как и во многих других языках, Python использует % оператор для вычисления модуля.

     3 % 4     # 3
    10 % 2    # 0
    6 % 4     # 2
    
     

    Или с помощью operator модуля:

     import operator
    
    operator.mod(3 , 4)     # 3
    operator.mod(10 , 2)    # 0
    operator.mod(6 , 4)     # 2
    
     

    Вы также можете использовать отрицательные числа.

     -9 % 7     # 5
    9 % -7     # -5
    -9 % -7    # -2
    
     

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

    quotient, remainder = divmod(9, 4)
    # quotient = 2, remainder = 1 as 4 * 2 + 1 == 9

Синтаксис

Параметры

Примечания