Python Language
Einfache mathematische Operatoren

Einführung

Bemerkungen

Zusatz

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ögliche Kombinationen (eingebaute Typen):

• int und int (gibt ein int )
• int und float (gibt einen float )
• int und complex (ergibt einen complex )
• float und float (gibt einen float )
• float und complex (ergibt einen complex )
• complex und complex (ergibt einen complex )

Hinweis: Der Operator + wird auch zum Verketten von Zeichenfolgen, Listen und Tupeln verwendet:

"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ögliche Kombinationen (eingebaute Typen):

• int und int (gibt ein int )
• int und float (gibt einen float )
• int und complex (ergibt einen complex )
• float und float (gibt einen float )
• float und complex (ergibt einen complex )
• complex und complex (ergibt einen complex )

Multiplikation

a, b = 2, 3

a * b                  # = 6

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

Mögliche Kombinationen (eingebaute Typen):

• int und int (gibt ein int )
• int und float (gibt einen float )
• int und complex (ergibt einen complex )
• float und float (gibt einen float )
• float und complex (ergibt einen complex )
• complex und complex (ergibt einen complex )

Hinweis: Der Operator * wird auch für die wiederholte Verkettung von Zeichenfolgen, Listen und Tupeln verwendet:

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

Einteilung

Python führt eine Ganzzahldivision aus, wenn beide Operanden Ganzzahlen sind. Das Verhalten der Divisionsoperatoren von Python hat sich gegenüber Python 2.x und 3.x geändert (siehe auch Integer Division ).

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ögliche Kombinationen (eingebaute Typen):

• int und int (ergibt ein int in Python 2 und ein float in Python 3)
• int und float (gibt einen float )
• int und complex (ergibt einen complex )
• float und float (gibt einen float )
• float und complex (ergibt einen complex )
• complex und complex (ergibt einen complex )

Weitere Informationen finden Sie in PEP 238 .

Exponentierung

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

Ein weiterer Unterschied zwischen dem eingebauten pow und math.pow besteht darin, dass der eingebaute pow drei Argumente akzeptieren kann:

a, b, c = 2, 3, 2

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

Spezialfunktionen

Die Funktion math.sqrt(x) berechnet die Quadratwurzel von 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)

Um andere Wurzeln zu berechnen, z. B. eine Würfelwurzel, erhöhen Sie die Anzahl auf den Kehrwert des Wurzelgrades. Dies kann mit jeder der Exponentialfunktionen oder dem Operator erfolgen.

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

Die Funktion math.exp(x) berechnet e ** x .

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

Die Funktion math.expm1(x) berechnet e ** x - 1 . Wenn x klein ist, ergibt sich eine deutlich bessere Genauigkeit als 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...

Logarithmen

Standardmäßig berechnet die Funktion math.log den Logarithmus einer Zahl, Basis e. Sie können optional eine Basis als zweites Argument angeben.

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)

Es gibt spezielle Varianten der math.log Funktion für verschiedene Basen.

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

Inplace-Operationen

In Anwendungen ist es üblich, Code wie folgt zu haben:

a = a + 1

oder

a = a * 2

Es gibt eine effektive Verknüpfung für diese Vor-Ort-Operationen:

a += 1
# and
a *= 2

Jeder mathematische Operator kann vor dem Zeichen '=' verwendet werden, um eine Inplace-Operation durchzuführen:

• -= dekrementiere die Variable an Ort und Stelle
• += Inkrementieren Sie die Variable an Ort und Stelle
• *= Multipliziere die Variable an Ort und Stelle
• /= teilen Sie die Variable an Ort und Stelle
• //= Boden teilen die Variable in Platz # Python 3
• %= Gibt den Modul der Variablen an Ort und Stelle zurück
• **= zu einer Kraft vor Ort erhöhen

Es gibt andere Operatoren für die bitweisen Operatoren ( ^ , | etc).

Trigonometrische Funktionen

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

Beachten Sie, dass math.hypot(x, y) auch die Länge des Vektors (oder die euklidische Entfernung) vom Ursprung (0, 0) bis zum Punkt (x, y) .

Um den euklidischen Abstand zwischen zwei Punkten (x1, y1) & (x2, y2) zu berechnen (x2, y2) Sie math.hypot wie folgt verwenden

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

Um aus Radiant -> Grad und Grad -> Radiant zu konvertieren, verwenden Sie math.degrees und math.radians

math.degrees(a)
# Out: 57.29577951308232

math.radians(57.29577951308232)
# Out: 1.0

Modul

Wie in vielen anderen Sprachen verwendet Python den Operator % zur Berechnung des Moduls.

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

Oder mit dem operator Modul:

import operator

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

Sie können auch negative Zahlen verwenden.

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

Wenn Sie das Ergebnis der Ganzzahldivision und des Moduls ermitteln müssen, können Sie die divmod Funktion als Abkürzung verwenden:

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