math — Matematiska funktioner

---

Denna modul ger tillgång till vanliga matematiska funktioner och konstanter, inklusive de som definieras av C-standarden.

Dessa funktioner kan inte användas med komplexa tal; använd funktionerna med samma namn från modulen cmath om du behöver stöd för komplexa tal. Distinktionen mellan funktioner som stöder komplexa tal och de som inte gör det görs eftersom de flesta användare inte vill lära sig så mycket matematik som krävs för att förstå komplexa tal. Om man får ett undantag i stället för ett komplext resultat kan man tidigare upptäcka det oväntade komplexa talet som används som parameter, så att programmeraren kan avgöra hur och varför det genererades från första början.

Följande funktioner tillhandahålls av denna modul. Om inte annat uttryckligen anges är alla returvärden flyttal.

Numerteoretiska funktioner
comb(n, k)	Antal sätt att välja k artiklar från n artiklar utan upprepning och utan ordning
factorial(n)	n faktoriell
gcd(*integers)	Största gemensamma divisor av heltalsargumenten
isqrt(n)	Integer kvadratrot av ett icke-negativt heltal n
lcm(*integers)	Minsta gemensamma multipel av heltalsargumenten
perm(n, k)	Antal sätt att välja k artiklar från n artiklar utan upprepning och med ordning
Aritmetik med flyttal
ceil(x)	Tak för x, det minsta heltal som är större än eller lika med x
fabs(x)	Absolut värde av x
floor(x)	Golv av x, det största heltalet mindre än eller lika med x
fma(x, y, z)	Kombinerad multiplicera-add-operation: (x * y) + z
fmod(x, y)	Resterande del av divisionen x / y
modf(x)	Bråkdelar och heltalsdelar av x
remainder(x, y)	Resterande del av x i förhållande till y
trunc(x)	Heltalsdel av x
Funktioner för manipulation av flyttal
copysign(x, y)	Magnituden (absolutvärdet) av x med tecknet för y
frexp(x)	Mantissa och exponent för x
isclose(a, b, rel_tol, abs_tol)	Kontrollera om värdena a och b ligger nära varandra
isfinite(x)	Kontrollera om x varken är oändligt eller NaN
isinf(x)	Kontrollera om x är en positiv eller negativ oändlighet
isnan(x)	Kontrollera om x är ett NaN (inte ett tal)
ldexp(x, i)	x * (2**i), invers av funktionen frexp()
nextafter(x, y, steps)	Flyttalsvärde steps stegar efter x mot y
ulp(x)	Värdet av den minst signifikanta biten i x
Potens-, exponential- och logaritmfunktioner
cbrt(x)	Kubrot av x
exp(x)	e upphöjd till makten x
exp2(x)	2 upphöjd till kraft x
expm1(x)	e upphöjt till potensen x, minus 1
log(x, base)	Logaritmen av x till den angivna basen (e som standard)
log1p(x)	Naturlig logaritm av 1+x (bas e)
log2(x)	Bas-2 logaritm av x
log10(x)	Bas-10 logaritmen av x
pow(x, y)	x upphöjd till makten y
sqrt(x)	Kvadratrot av x
Summa och produktfunktioner
dist(p, q)	Euklidiskt avstånd mellan två punkter p och q givet som en iterabel av koordinater
fsum(iterable)	Summan av värdena i indata iterable
hypot(*coordinates)	Euklidisk norm för en iterabel med koordinater
prod(iterable, start)	Produkt av element i indata iterable med ett start värde
sumprod(p, q)	Summan av produkterna från två iterabler p och q
Vinkelomvandling
degrees(x)	Konvertera vinkel x från radianer till grader
radianer(x)	Konvertera vinkel x från grader till radianer
Trigonometriska funktioner
acos(x)	Arc cosinus av x
asin(x)	Arc sinus av x
atan(x)	Arc tangent av x
atan2(y, x)	atan(y / x)
cos(x)	Cosinus av x
sin(x)	Sinus av x
tan(x)	Tangent av x
Hyperboliska funktioner
acosh(x)	Invers hyperbolisk cosinus av x
asinh(x)	Omvänd hyperbolisk sinus av x
atanh(x)	Omvänd hyperbolisk tangent till x
cosh(x)	Hyperbolisk cosinus av x
sinh(x)	Hyperbolisk sinus av x
tanh(x)	Hyperbolisk tangent till x
Särskilda funktioner
erf(x)	Felfunktion vid x
erfc(x)	Kompletterande felfunktion vid x
gamma(x)	Gammafunktion vid x
lgamma(x)	Naturlig logaritm av absolutvärdet av Gamma-funktionen vid x
Konstanter
pi	π = 3.141592…
e	e = 2.718281…
tau	τ = 2π = 6,283185…
inf	Positiv oändlighet
nan	”Inte ett tal” (NaN)

Nummerteoretiska funktioner

math.comb(n, k)

Returnera antalet sätt att välja k objekt från n objekt utan upprepning och utan ordning.

Utvärderas till n! / (k! * (n - k)!) när k <= n och utvärderas till noll när k > n.

Kallas även binomialkoefficienten eftersom den motsvarar koefficienten för den k:e termen i polynomutvecklingen av (1 + x)ⁿ.

Utlöser TypeError om något av argumenten inte är heltal. Utlöser ValueError om något av argumenten är negativa.

Tillagd i version 3.8.

math.factorial(n)

Returnerar faktoriellt av det icke-negativa heltalet n.

Ändrad i version 3.10: Floater med heltalsvärden (som 5.0) accepteras inte längre.

math.gcd(*integers)

Returnerar den största gemensamma divisorn av de angivna heltalsargumenten. Om något av argumenten inte är noll, är det returnerade värdet det största positiva heltal som är divisor till alla argument. Om alla argument är noll, är det returnerade värdet 0. gcd() utan argument returnerar 0.

Tillagd i version 3.5.

Ändrad i version 3.9: Stöd för ett godtyckligt antal argument har lagts till. Tidigare stöddes endast två argument.

math.isqrt(n)

Returnerar heltalets kvadratrot av det icke-negativa heltalet n. Detta är golvet i den exakta kvadratroten av n, eller motsvarande det största heltalet a som är sådant att a² ≤ n.

För vissa tillämpningar kan det vara mer praktiskt att ha det minsta heltalet a så att n ≤ a², eller med andra ord taket för den exakta kvadratroten av n. För positiva n kan detta beräknas med hjälp av a = 1 + isqrt(n - 1).

Tillagd i version 3.8.

math.lcm(*integers)

Returnerar den minsta gemensamma multipeln av de angivna heltalsargumenten. Om alla argument är olika noll är det returnerade värdet det minsta positiva heltalet som är en multipel av alla argument. Om något av argumenten är noll, är det returnerade värdet 0. lcm() utan argument returnerar 1.

Tillagd i version 3.9.

math.perm(n, k=None)

Returnera antalet sätt att välja k objekt från n objekt utan upprepning och med ordning.

Utvärderas till n! / (n - k)! när k <= n och utvärderas till noll när k > n.

Om k inte anges eller är None, är k standardvärdet för n och funktionen returnerar n!.

Utlöser TypeError om något av argumenten inte är heltal. Utlöser ValueError om något av argumenten är negativa.

Tillagd i version 3.8.

Aritmetik med flyttal

math.ceil(x)

Returnerar taket för x, det minsta heltalet som är större än eller lika med x. Om x inte är en float, delegeras till x.__ceil__, som bör returnera ett Integral-värde.

math.fabs(x)

Returnerar det absoluta värdet av x.

math.floor(x)

Returnerar golvet av x, det största heltalet mindre än eller lika med x. Om x inte är en float, delegeras till x.__floor__, som bör returnera ett Integral-värde.

math.fma(x, y, z)

Fusionerad multiplicera-add-operation. Returnerar (x * y) + z, beräknat som om det vore med oändlig precision och intervall följt av en enda avrundning till float-formatet. Denna operation ger ofta bättre noggrannhet än det direkta uttrycket (x * y) + z.

Denna funktion följer specifikationen för fusedMultiplyAdd-operationen som beskrivs i IEEE 754-standarden. Standarden lämnar ett fall implementationsdefinierat, nämligen resultatet av fma(0, inf, nan) och fma(inf, 0, nan). I dessa fall returnerar math.fma ett NaN och ger inte upphov till något undantag.

Tillagd i version 3.13.

math.fmod(x, y)

Returnerar restvärdet i flyttal av x / y, enligt definitionen av plattformens C-biblioteksfunktion fmod(x, y). Observera att Python-uttrycket x % y kanske inte returnerar samma resultat. Avsikten med C-standarden är att fmod(x, y) ska vara exakt (matematiskt; till oändlig precision) lika med x - n*y för något heltal n så att resultatet har samma tecken som x och storlek mindre än abs(y). Pythons x % y returnerar ett resultat med tecknet y istället, och kanske inte är exakt beräkningsbart för float-argument. Till exempel är fmod(-1e-100, 1e100) -1e-100, men resultatet av Pythons -1e-100 % 1e100 är 1e100-1e-100, som inte kan representeras exakt som en float, och avrundas till den överraskande 1e100. Av denna anledning är funktionen fmod() i allmänhet att föredra när man arbetar med flyttal, medan Pythons x % y är att föredra när man arbetar med heltal.

math.modf(x)

Returnerar bråktals- och heltalsdelarna av x. Båda resultaten har tecknet för x och är flyttal.

Observera att modf() har ett annat anrops-/returmönster än sina motsvarigheter i C: den tar ett enda argument och returnerar ett par värden, i stället för att returnera sitt andra returvärde via en ”utgångsparameter” (det finns inget sådant i Python).

math.remainder(x, y)

Returnerar restvärdet i IEEE 754-stil av x med avseende på y. För ändliga x och ändliga y som inte är noll är detta skillnaden x - n*y, där n är det närmaste heltalet till det exakta värdet av kvoten x / y. Om x / y ligger exakt mitt emellan två på varandra följande heltal, används det närmaste jämna heltalet för n. Resten r = rest(x, y) uppfyller således alltid abs(r) <= 0,5 * abs(y).

Specialfall följer IEEE 754: i synnerhet är remainder(x, math.inf) x för alla ändliga x, och remainder(x, 0) och remainder(math.inf, x) ger upphov till ValueError för alla icke-NaN x. Om resultatet av remainder-operationen är noll, kommer nollan att ha samma tecken som x.

På plattformar som använder IEEE 754 binär flyttal är resultatet av denna operation alltid exakt representativt: inget avrundningsfel införs.

Tillagd i version 3.7.

math.trunc(x)

Returnerar x med bråkdelen borttagen, så att heltalsdelen återstår. Detta avrundas mot 0: trunc() är likvärdigt med floor() för positiva x, och likvärdigt med ceil() för negativa x. Om x inte är en float, delegeras till x.__trunc__, som bör returnera ett Integral-värde.

För funktionerna ceil(), floor(), och modf(), notera att alla flyttal av tillräckligt stor storlek är exakta heltal. Pythons flyttal har vanligtvis inte mer än 53 bitars precision (samma som plattform C:s dubbeltyp), i vilket fall alla flyttal x med abs(x) >= 2**52 nödvändigtvis inte har några bråkdelar.

Funktioner för manipulation av flyttal

math.copysign(x, y)

Returnerar en float med magnituden (absolutvärdet) x men tecknet y. På plattformar som stöder signerade nollor returnerar copysign(1,0, -0,0) -1,0.

math.frexp(x)

Returnerar mantissa och exponent för x som paret (m, e). m är ett flyttal och e är ett heltal så att x == m * 2**e exakt. Om x är noll returneras (0,0, 0), annars 0,5 <= abs(m) < 1. Detta används för att ”plocka isär” den interna representationen av en float på ett portabelt sätt.

Observera att frexp() har ett annat anrops-/returmönster än sina motsvarigheter i C: den tar ett enda argument och returnerar ett par värden, i stället för att returnera sitt andra returvärde via en ”utgångsparameter” (det finns inget sådant i Python).

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

Returnerar True om värdena a och b ligger nära varandra och False i annat fall.

Huruvida två värden anses ligga nära varandra eller inte avgörs enligt givna absoluta och relativa toleranser. Om inga fel inträffar blir resultatet: abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).

rel_tol är den relativa toleransen - det är den maximalt tillåtna skillnaden mellan a och b, i förhållande till det större absoluta värdet av a eller b. Om du t.ex. vill ange en tolerans på 5 % anger du rel_tol=0,05. Standardtoleransen är 1e-09, vilket garanterar att de två värdena är lika inom cirka 9 decimaler. rel_tol måste vara icke-negativt och mindre än 1,0.

abs_tol är den absoluta toleransen; standardvärdet är 0,0 och det måste vara icke-negativt. Vid jämförelse av x med 0,0 beräknas isclose(x, 0) som abs(x) <= rel_tol * abs(x), vilket är falskt för alla x som inte är noll och rel_tol mindre än 1,0. Lägg därför till ett lämpligt positivt abs_tol-argument i anropet.

IEEE 754 specialvärdena NaN, inf och -inf kommer att hanteras enligt IEEE:s regler. Specifikt anses inte NaN ligga nära något annat värde, inklusive NaN. inf och -inf betraktas endast som nära sig själva.

Tillagd i version 3.5.

Se även

PEP 485 – En funktion för att testa ungefärlig likhet

math.isfinite(x)

Returnerar True om x varken är en oändlighet eller en NaN, och False annars. (Observera att 0.0 anses som ändligt.)

Tillagd i version 3.2.

math.isinf(x)

Returnerar True om x är en positiv eller negativ oändlighet, och False annars.

math.isnan(x)

Returnerar True om x är en NaN (inte ett tal), och False annars.

math.ldexp(x, i)

Returnerar x * (2**i). Detta är i princip inversen av funktionen frexp().

math.nextafter(x, y, steps=1)

Returnerar flyttalsvärdet steps steg efter x mot y.

Om x är lika med y returneras y, såvida inte steps är noll.

Exempel:

• math.nextafter(x, math.inf) går upp: mot positiv oändlighet.

• math.nextafter(x, -math.inf) går ner: mot minus oändligheten.

• math.nextafter(x, 0.0) går mot noll.

• math.nextafter(x, math.copysign(math.inf, x)) går bort från noll.

Se även math.ulp().

Tillagd i version 3.9.

Ändrad i version 3.12: Lagt till argumentet steps.

math.ulp(x)

Returnera värdet på den minst signifikanta biten i floaten x:

• Om x är ett NaN (inte ett tal), returneras x.

• Om x är negativ, returneras ulp(-x).

• Om x är en positiv oändlighet, returneras x.

• Om x är lika med noll, returneras den minsta positiva denormaliserade representativa floaten (mindre än den minsta positiva normaliserade floaten, sys.float_info.min).

• Om x är lika med den största positiva representativa floaten, returneras värdet av den minst signifikanta biten i x, så att den första floaten som är mindre än x är x - ulp(x).

• Annars (x är ett positivt ändligt tal), returnera värdet på den minst signifikanta biten i x, så att det första flyttalet som är större än x är x + ulp(x).

ULP står för ”Unit in the Last Place”.

Se även math.nextafter() och sys.float_info.epsilon.

Tillagd i version 3.9.

Potens-, exponential- och logaritmfunktioner

math.cbrt(x)

Returnerar kubikroten av x.

Tillagd i version 3.11.

math.exp(x)

Returnerar e upphöjt till potensen x, där e = 2,718281… är basen för naturliga logaritmer. Detta är vanligtvis mer exakt än math.e ** x eller pow(math.e, x).

math.exp2(x)

Returnera 2 upphöjt till potensen x.

Tillagd i version 3.11.

math.expm1(x)

Returnerar e upphöjt till potensen x, minus 1. Här är e basen för naturliga logaritmer. För små flyttal x kan subtraktionen i exp(x) - 1 resultera i en betydande förlust av precision; funktionen expm1() ger ett sätt att beräkna denna kvantitet med full precision:

>>> from math import exp, expm1
>>> exp(1e-5) - 1  # gives result accurate to 11 places
1.0000050000069649e-05
>>> expm1(1e-5)    # result accurate to full precision
1.0000050000166668e-05

Tillagd i version 3.2.

math.log(x[, base])

Med ett argument, returnerar den naturliga logaritmen av x (till basen e).

Med två argument, returnerar logaritmen för x till den angivna basen, beräknad som log(x)/log(bas).

math.log1p(x)

Returnerar den naturliga logaritmen av 1+x (bas e). Resultatet beräknas på ett sätt som är korrekt för x nära noll.

math.log2(x)

Returnerar bas-2 logaritmen av x. Detta är vanligtvis mer exakt än log(x, 2).

Tillagd i version 3.3.

Se även

int.bit_length() returnerar det antal bitar som krävs för att representera ett heltal i binär form, exklusive tecken och inledande nollor.

math.log10(x)

Returnerar bas-10 logaritmen av x. Detta är vanligtvis mer exakt än log(x, 10).

math.pow(x, y)

Returnera x upphöjt till potensen y. Undantagsfall följer IEEE 754-standarden så långt som möjligt. I synnerhet returnerar pow(1.0, x) och pow(x, 0.0) alltid 1.0, även när x är en nolla eller ett NaN. Om både x och y är ändliga, x är negativ och y inte är ett heltal är pow(x, y) odefinierad och ger upphov till ValueError.

Till skillnad från den inbyggda operatorn ** konverterar math.pow`() båda sina argument till typen float. Använd ** eller den inbyggda funktionen pow() för att beräkna exakta heltalspotenser.

Ändrad i version 3.11: Specialfallen pow(0.0, -inf) och pow(-0.0, -inf) ändrades till att returnera inf istället för att ge ValueError, för att överensstämma med IEEE 754.

math.sqrt(x)

Returnerar kvadratroten av x.

Summations- och produktfunktioner

math.dist(p, q)

Returnerar det euklidiska avståndet mellan två punkter p och q, var och en angiven som en sekvens (eller iterabel) av koordinater. De två punkterna måste ha samma dimension.

Ungefär motsvarande:

sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))

Tillagd i version 3.8.

math.fsum(iterable)

Returnerar en exakt summa i flyttal av värdena i iterabeln. Undviker förlust av precision genom att spåra flera mellanliggande partiella summor.

Algoritmens noggrannhet beror på aritmetiska garantier enligt IEEE-754 och det typiska fallet där avrundningsläget är halvjämnt. På vissa icke-Windows-versioner använder det underliggande C-biblioteket addition med utökad precision och kan ibland dubbelrunda en mellansumma, vilket gör att den minst signifikanta biten inte stämmer.

För ytterligare diskussion och två alternativa metoder, se ASPN cookbook recipes for accurate floating-point summation.

math.hypot(*coordinates)

Returnerar den euklidiska normen, sqrt(sum(x**2 for x in coordinates)). Detta är längden på vektorn från origo till den punkt som anges av koordinaterna.

För en tvådimensionell punkt (x, y) är detta likvärdigt med att beräkna hypotenusan i en rätvinklig triangel med hjälp av Pythagoras sats, sqrt(x*x + y*y).

Ändrad i version 3.8: Stöd för n-dimensionella punkter har lagts till. Tidigare stöddes endast det tvådimensionella fallet.

Ändrad i version 3.10: Förbättrat algoritmens noggrannhet så att det maximala felet är under 1 ulp (enhet på sista plats). Mer typiskt är att resultatet nästan alltid är korrekt avrundat till inom 1/2 ulp.

math.prod(iterable, *, start=1)

Beräkna produkten av alla element i indata iterable. Standardvärdet start för produkten är 1.

När iterabeln är tom returneras startvärdet. Denna funktion är särskilt avsedd för användning med numeriska värden och kan avvisa icke-numeriska typer.

Tillagd i version 3.8.

math.sumprod(p, q)

Returnerar summan av produkter av värden från två iterabler p och q.

Utlöser ValueError om inmatningarna inte har samma längd.

Ungefär motsvarande:

sum(map(operator.mul, p, q, strict=True))

För float- och mixed int/float-ingångar beräknas mellanprodukter och summor med utökad precision.

Tillagd i version 3.12.

Angulär konvertering

math.degrees(x)

Konvertera vinkel x från radianer till grader.

math.radians(x)

Konvertera vinkel x från grader till radianer.

Trigonometriska funktioner

math.acos(x)

Returnerar bågkosinus för x, i radianer. Resultatet ligger mellan 0 och pi.

math.asin(x)

Returnerar bågsinus för x, i radianer. Resultatet ligger mellan -pi/2 och pi/2.

math.atan(x)

Returnerar bågtangenten för x, i radianer. Resultatet ligger mellan -pi/2 och pi/2.

math.atan2(y, x)

Returnerar atan(y / x), i radianer. Resultatet ligger mellan -pi och pi. Vektorn i planet från origo till punkten (x, y) bildar denna vinkel med den positiva X-axeln. Poängen med atan2() är att tecknen på båda indata är kända för den, så att den kan beräkna rätt kvadrant för vinkeln. Till exempel är atan(1) och atan2(1, 1) båda pi/4, men atan2(-1, -1) är -3*pi/4.

math.cos(x)

Returnerar cosinus av x radianer.

math.sin(x)

Returnerar sinus av x radianer.

math.tan(x)

Returnerar tangenten av x radianer.

Hyperboliska funktioner

Hyperboliska funktioner är motsvarigheter till trigonometriska funktioner som baseras på hyperbler i stället för cirklar.

math.acosh(x)

Returnerar den inversa hyperboliska cosinus av x.

math.asinh(x)

Returnerar den inverterade hyperboliska sinus av x.

math.atanh(x)

Returnerar den omvända hyperboliska tangenten för x.

math.cosh(x)

Returnerar hyperbolisk cosinus av x.

math.sinh(x)

Returnerar den hyperboliska sinusformen av x.

math.tanh(x)

Returnerar den hyperboliska tangenten för x.

Särskilda funktioner

math.erf(x)

Returnera felsfunktionen vid x.

Funktionen erf() kan användas för att beräkna traditionella statistiska funktioner som t.ex. den kumulativa standardnormalfördelningen:

def phi(x):
    "Kumulativ fördelningsfunktion för standardnormalfördelningen
    returnera (1,0 + erf(x / sqrt(2,0)))) / 2.0

Tillagd i version 3.2.

math.erfc(x)

Returnerar den komplementära felfunktionen vid x. Den komplementära felfunktionen definieras som 1.0 - erf(x). Den används för stora värden på x där en subtraktion från ett skulle orsaka en förlust av signifikans.

Tillagd i version 3.2.

math.gamma(x)

Returnera Gamma-funktionen vid x.

Tillagd i version 3.2.

math.lgamma(x)

Returnerar den naturliga logaritmen av absolutvärdet av Gamma-funktionen vid x.

Tillagd i version 3.2.

Konstanter

math.pi

Den matematiska konstanten π = 3,141592…, med tillgänglig precision.

math.e

Den matematiska konstanten e = 2,718281…, med tillgänglig precision.

math.tau

Den matematiska konstanten τ = 6,283185…, med tillgänglig precision. Tau är en cirkelkonstant som är lika med 2π, förhållandet mellan en cirkels omkrets och dess radie. För att lära dig mer om Tau, kolla in Vi Harts video Pi is (still) Wrong, och börja fira Tau day genom att äta dubbelt så mycket paj!

Tillagd i version 3.6.

math.inf

En positiv oändlighet med flyttal. (För negativ oändlighet, använd -math.inf.) Motsvarar resultatet av float('inf').

Tillagd i version 3.5.

math.nan

Ett flyttalsvärde som ”inte är ett tal” (NaN). Motsvarar utmatningen från float('nan'). På grund av kraven i standarden IEEE-754 anses math.nan och float('nan') inte vara lika med något annat numeriskt värde, inklusive sig själva. För att kontrollera om ett tal är ett NaN, använd funktionen isnan() för att testa för NaN istället för is eller ==. Ett exempel:

>>> import math
>>> math.nan == math.nan
False
>>> float('nan') == float('nan')
False
>>> math.isnan(math.nan)
True
>>> math.isnan(float('nan'))
True

Tillagd i version 3.5.

Ändrad i version 3.11: Den är nu alltid tillgänglig.

Modulen math består mestadels av tunna omslag runt plattformens C-matematiska biblioteksfunktioner. Beteendet i undantagsfall följer Annex F i C99-standarden där så är lämpligt. Den nuvarande implementationen kommer att ge ValueError för ogiltiga operationer som sqrt(-1,0) eller log(0,0) (där C99 Annex F rekommenderar att man signalerar ogiltig operation eller dividerar med noll), och OverflowError för resultat som överflödar (till exempel exp(1000,0)). Ett NaN kommer inte att returneras från någon av funktionerna ovan om inte ett eller flera av inmatningsargumenten var ett NaN; i så fall kommer de flesta funktioner att returnera ett NaN, men (återigen enligt C99 Annex F) finns det några undantag från denna regel, till exempel pow(float('nan'), 0.0) eller hypot(float('nan'), float('inf')).

Observera att Python inte gör något försök att skilja signalerande NaNs från tysta NaNs, och beteendet för signalerande NaNs förblir ospecificerat. Typiskt beteende är att behandla alla NaN som om de vore tysta.

Se även

Modul cmath

Komplexa talversioner av många av dessa funktioner.