Python Language
Rekenmodule
Zoeken…
Afronding: rond, vloer, plafond, trunc
Naast de ingebouwde round functie biedt de math functies floor , ceil en 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 en round retourneren altijd een float .
round(1.3) # 1.0
round breekt altijd banden weg van nul.
round(0.5) # 1.0
round(1.5) # 2.0
floor , ceil en trunc retourneren altijd een Integral waarde, terwijl round een Integral waarde retourneert als deze met één argument wordt aangeroepen.
round(1.3) # 1
round(1.33, 1) # 1.3
round breekt banden naar het dichtstbijzijnde even getal. Dit corrigeert de neiging naar grotere getallen bij het uitvoeren van een groot aantal berekeningen.
round(0.5) # 0
round(1.5) # 2
Waarschuwing!
Zoals bij elke weergave met drijvende komma, kunnen sommige breuken niet exact worden weergegeven . Dit kan leiden tot enig onverwacht afrondingsgedrag.
round(2.675, 2) # 2.67, not 2.68!
Waarschuwing voor de verdieping, trunc en gehele getallenverdeling van negatieve getallen
Python (en C ++ en Java) ronden af van nul voor negatieve getallen. Overwegen:
>>> math.floor(-1.7)
-2.0
>>> -5 // 2
-3
logaritmen
math.log(x) geeft de natuurlijke (basis e ) logaritme van x .
math.log(math.e) # 1.0
math.log(1) # 0.0
math.log(100) # 4.605170185988092
math.log kan precisie verliezen met getallen dichtbij 1, vanwege de beperkingen van floating-point getallen. Om logs nauwkeurig in de buurt van 1 te berekenen, gebruikt u math.log1p , die de natuurlijke logaritme van 1 plus het argument evalueert:
math.log(1 + 1e-20) # 0.0
math.log1p(1e-20) # 1e-20
math.log10 kan worden gebruikt voor logboekbasis 10:
math.log10(10) # 1.0
Bij gebruik van twee argumenten geeft math.log(x, base) de logaritme van x in de gegeven base (dwz log(x) / log(base) .
math.log(100, 10) # 2.0
math.log(27, 3) # 3.0
math.log(1, 10) # 0.0
Tekens kopiëren
In Python 2.6 en hoger math.copysign(x, y) x met het teken van y . De geretourneerde waarde is altijd een 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, on a platform which supports signed zero
Trigonometrie
Berekening van de lengte van de hypotenusa
math.hypot(2, 4) # Just a shorthand for SquareRoot(2**2 + 4**2)
# Out: 4.47213595499958
Graden omzetten naar / van radialen
Alle math functies verwachten radialen, dus je moet graden omzetten in radialen:
math.radians(45) # Convert 45 degrees to radians
# Out: 0.7853981633974483
Alle resultaten van de inverse trigonometrische functies retourneren het resultaat in radialen, dus u moet het mogelijk terugzetten naar graden:
math.degrees(math.asin(1)) # Convert the result of asin to degrees
# Out: 90.0
Sinus-, cosinus-, tangens- en inverse functies
# 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 # This is just "pi / 2"
math.atan(float('inf'))
# Out: 1.5707963267948966 # This is just "pi / 2"
Afgezien van de math.atan er ook een twee-argument-functie math.atan2 , die het juiste kwadrant berekent en valkuilen van deling door nul vermijdt:
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"
Hyperbolische sinus, cosinus en tangens
# 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
constanten
math modules bevatten twee veelgebruikte wiskundige constanten.
-
math.pi- De wiskundige constante pi -
math.e- De wiskundige constante e (basis van natuurlijke logaritme)
>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045
>>>
Python 3.5 en hoger hebben constanten voor oneindig en NaN ("geen getal"). De oudere syntaxis van het doorgeven van een string aan float() werkt nog steeds.
math.inf == float('inf')
# Out: True
-math.inf == float('-inf')
# Out: True
# NaN never compares equal to anything, even itself
math.nan == float('nan')
# Out: False
Denkbeeldige nummers
Denkbeeldige getallen in Python worden voorgesteld door een "j" of "J" achter het doelnummer.
1j # Equivalent to the square root of -1.
1j * 1j # = (-1+0j)
Infinity en NaN ("not a number")
In alle versies van Python kunnen we oneindig en NaN ("geen nummer") als volgt vertegenwoordigen:
pos_inf = float('inf') # positive infinity
neg_inf = float('-inf') # negative infinity
not_a_num = float('nan') # NaN ("not a number")
In Python 3.5 en hoger kunnen we ook de gedefinieerde constanten math.inf en math.nan :
pos_inf = math.inf
neg_inf = -math.inf
not_a_num = math.nan
De tekenreeksrepresentaties worden weergegeven als inf en -inf en nan :
pos_inf, neg_inf, not_a_num
# Out: (inf, -inf, nan)
We kunnen testen op positieve of negatieve oneindigheid met de isinf methode:
math.isinf(pos_inf)
# Out: True
math.isinf(neg_inf)
# Out: True
We kunnen specifiek testen op positieve oneindigheid of op negatieve oneindigheid door directe vergelijking:
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
Met Python 3.2 en hoger kan ook worden gecontroleerd op eindigheid:
math.isfinite(pos_inf)
# Out: False
math.isfinite(0.0)
# Out: True
Vergelijkingsoperatoren werken zoals verwacht voor positieve en negatieve oneindigheid:
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
Maar als een rekenkundige uitdrukking een waarde produceert die groter is dan het maximum dat kan worden weergegeven als een float , wordt het oneindig:
pos_inf == sys.float_info.max * 1.0000001
# Out: True
neg_inf == -sys.float_info.max * 1.0000001
# Out: True
Deling door nul geeft echter geen resultaat van oneindigheid (of negatieve oneindigheid indien van toepassing), maar verhoogt eerder een ZeroDivisionError uitzondering.
try:
x = 1.0 / 0.0
print(x)
except ZeroDivisionError:
print("Division by zero")
# Out: Division by zero
Rekenkundige bewerkingen op oneindig geven gewoon oneindige resultaten, of soms 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 is nooit gelijk aan iets, zelfs niet aan zichzelf. We kunnen testen of het is met de isnan methode:
not_a_num == not_a_num
# Out: False
math.isnan(not_a_num)
Out: True
NaN is altijd te vergelijken als "niet gelijk", maar nooit kleiner dan of groter dan:
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
Rekenkundige bewerkingen op NaN geven altijd NaN. Dit omvat vermenigvuldiging met -1: er is geen "negatieve NaN".
5.0 * not_a_num
# Out: nan
float('-nan')
# Out: nan
-math.nan
# Out: nan
Er is een subtiel verschil tussen de oude float versies van NaN en infinity en de Python 3.5+ math bibliotheekconstanten:
math.inf is math.inf, math.nan is math.nan
# Out: (True, True)
float('inf') is float('inf'), float('nan') is float('nan')
# Out: (False, False)
Pow voor snellere exponentiatie
De timeit-module gebruiken vanaf de opdrachtregel:
> 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
De ingebouwde ** operator komt vaak van pas, maar als prestaties van essentieel belang zijn, gebruik dan math.pow. Houd er echter rekening mee dat pow floats retourneert, zelfs als de argumenten gehele getallen zijn:
> from math import pow
> pow(5,5)
3125.0
Complexe getallen en de cmath-module
De cmath module is vergelijkbaar met de math , maar definieert functies op de juiste manier voor het complexe vlak.
Allereerst zijn complexe getallen van een numeriek type dat deel uitmaakt van de Python-taal zelf en niet wordt verstrekt door een bibliotheekklasse. We hoeven dus geen import cmath te import cmath voor gewone rekenkundige uitdrukkingen.
Merk op dat we j (of J ) gebruiken en niet i .
z = 1 + 3j
We moeten 1j omdat j de naam van een variabele is in plaats van een numerieke letterlijke waarde.
1j * 1j
Out: (-1+0j)
1j ** 1j
# Out: (0.20787957635076193+0j) # "i to the i" == math.e ** -(math.pi/2)
Wij hebben de real deel en het imag (imaginaire) deel, evenals het complex 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
De ingebouwde functies abs en complex maken ook deel uit van de taal zelf en vereisen geen import:
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)
De complex functie kan een string bevatten, maar mag geen spaties bevatten:
complex('1+1j')
# Out: (1+1j)
complex('1 + 1j')
# Exception: ValueError: complex() arg is a malformed string
Maar voor de meeste functies hebben we de module nodig, bijvoorbeeld sqrt :
import cmath
cmath.sqrt(-1)
# Out: 1j
Natuurlijk is het gedrag van sqrt verschillend voor complexe getallen en reële getallen. In niet-complexe math roept de vierkantswortel van een negatief getal een uitzondering op:
import math
math.sqrt(-1)
# Exception: ValueError: math domain error
Er zijn functies beschikbaar voor het converteren van en naar poolcoördinaten:
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)
Het wiskundige veld van complexe analyse valt buiten het bestek van dit voorbeeld, maar veel functies in het complexe vlak hebben een "vertakkingssnede", meestal langs de reële as of de denkbeeldige as. De meeste moderne platforms ondersteunen "ondertekend nul" zoals gespecificeerd in IEEE 754, die continuïteit van die functies aan beide zijden van de vertakking biedt. Het volgende voorbeeld komt uit de Python-documentatie:
cmath.phase(complex(-1.0, 0.0))
# Out: 3.141592653589793
cmath.phase(complex(-1.0, -0.0))
# Out: -3.141592653589793
De cmath module biedt ook veel functies met directe tegenhangers van de math .
Naast sqrt zijn er complexe versies van exp , log , log10 , de trigonometrische functies en hun inversies ( sin , cos , tan , asin , acos , atan ), en de hyperbolische functies en hun inverses ( sinh , cosh , tanh , asinh , acosh , atanh ). Merk echter op dat er geen complexe tegenhanger is van math.atan2 , de vorm met twee argumenten van arctangent.
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
De constanten pi en e worden gegeven. Merk op dat deze float en niet complex .
type(cmath.pi)
# Out: <class 'float'>
De cmath module biedt ook complexe versies van isinf en (voor Python 3.2+) isfinite . Zie " Oneindig en NaN ". Een complex getal wordt als oneindig beschouwd als het werkelijke deel of het imaginaire deel ervan oneindig is.
cmath.isinf(complex(float('inf'), 0.0))
# Out: True
Evenzo biedt de cmath module een complexe versie van isnan . Zie " Oneindig en NaN ". Een complex getal wordt als "geen getal" beschouwd als het reële deel of het imaginaire deel ervan "geen getal" is.
cmath.isnan(0.0, float('nan'))
# Out: True
Merk op dat er geen cmath tegenhanger is van de constanten math.inf en math.nan (vanaf Python 3.5 en hoger)
cmath.isinf(complex(0.0, math.inf))
# Out: True
cmath.isnan(complex(math.nan, 0.0))
# Out: True
cmath.inf
# Exception: AttributeError: module 'cmath' has no attribute 'inf'
In Python 3.5 en hoger is er een isclose methode in zowel cmath als math .
z = cmath.rect(*cmath.polar(1+1j))
z
# Out: (1.0000000000000002+1.0000000000000002j)
cmath.isclose(z, 1+1j)
# True