Python Language
Enkla matematiska operatörer

Introduktion

Anmärkningar

Tillägg

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

Möjliga kombinationer (inbyggda typer):

• int och int (ger ett int )
• int och float (ger en float )
• int och complex (ger ett complex )
• float och float (ger ett float )
• float och complex (ger ett complex )
• complex och complex (ger ett complex )

Obs: operatören + används också för att sammanfoga strängar, listor och tuplingar:

"first string " + "second string"    # = 'first string second string'

[1, 2, 3] + [4, 5, 6]                # = [1, 2, 3, 4, 5, 6]

Subtraktion

a, b = 1, 2

# Using the "-" operator:
b - a                  # = 1


import operator        # contains 2 argument arithmetic functions
operator.sub(b, a)     # = 1

Möjliga kombinationer (inbyggda typer):

• int och int (ger ett int )
• int och float (ger en float )
• int och complex (ger ett complex )
• float och float (ger ett float )
• float och complex (ger ett complex )
• complex och complex (ger ett complex )

Multiplikation

a, b = 2, 3

a * b                  # = 6

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

Möjliga kombinationer (inbyggda typer):

• int och int (ger ett int )
• int och float (ger en float )
• int och complex (ger ett complex )
• float och float (ger ett float )
• float och complex (ger ett complex )
• complex och complex (ger ett complex )

Obs: operatören * används också för upprepad sammankoppling av strängar, listor och tuplingar:

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

Division

Python delar heltal när båda operanderna är heltal. Uppförandet hos Pythons divisionsoperatörer har ändrats från Python 2.x och 3.x (se även Heltalsdivision ).

a, b, c, d, e = 3, 2, 2.0, -3, 10

a / b                  # = 1 

a / c                  # = 1.5

d / b                  # = -2

b / a                  # = 0

d / e                  # = -1

import operator        # the operator module provides 2-argument arithmetic functions
operator.div(a, b)     # = 1
operator.__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

float(a) / b           # = 1.5
a / float(b)           # = 1.5

a // b                # = 1
a // c                # = 1.0

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

Möjliga kombinationer (inbyggda typer):

• int och int (ger ett int i Python 2 och ett float i Python 3)
• int och float (ger en float )
• int och complex (ger ett complex )
• float och float (ger ett float )
• float och complex (ger ett complex )
• complex och complex (ger ett complex )

Se PEP 238 för mer information.

Exponentation

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

En annan skillnad mellan den inbyggda pow och math.pow är att den inbyggda pow kan acceptera tre argument:

a, b, c = 2, 3, 2

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

Specialfunktioner

Funktionen math.sqrt(x) beräknar kvadratroten av 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)

För att beräkna andra rötter, till exempel en kubrot, höjer du numret till det ömsesidiga av rotgraden. Detta kan göras med någon av de exponentiella funktionerna eller operatörerna.

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

Funktionen math.exp(x) beräknar e ** x .

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

Funktionen math.expm1(x) beräknar e ** x - 1 . När x är liten ger detta betydligt bättre precision än 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...

logaritmer

Som standard math.log funktionen logaritmen för ett nummer, bas e. Du kan valfritt ange en bas som det andra argumentet.

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)

Speciella variationer av math.log funktionen finns för olika baser.

# 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)

Operationer på plats

Det är vanligt inom applikationer att behöva ha kod som denna:

a = a + 1

eller

a = a * 2

Det finns en effektiv genväg för dessa på plats operationer:

a += 1
# and
a *= 2

Varje matematisk operatör kan användas före '=' -tecknet för att göra en lokal operation:

• -= minska variabeln på plats
• += öka variabeln på plats
• *= multiplicera variabeln på plats
• /= dela variabeln på plats
• //= golvet delar variabeln på plats # Python 3
• %= returnera modulen för variabeln på plats
• **= höja till en kraft på plats

Andra operatörer finns på plats för bitvisa operatörer ( ^ , | etc)

Trigonometriska funktioner

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

Observera att math.hypot(x, y) också är längden på vektorn (eller det euklidiska avståndet) från ursprunget (0, 0) till punkten (x, y) .

För att beräkna det euklidiska avståndet mellan två punkter (x1, y1) & (x2, y2) du använda math.hypot enligt följande

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

För att konvertera från radianer -> grader och grader -> radianer använder man math.degrees och math.radians

math.degrees(a)
# Out: 57.29577951308232

math.radians(57.29577951308232)
# Out: 1.0

modul

Liksom på många andra språk använder Python % -operatören för att beräkna modul.

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

Eller genom att använda operator :

import operator

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

Du kan också använda negativa siffror.

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

Om du behöver hitta resultatet av heltalsdelning och modul kan du använda divmod som en genväg:

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