math-matematiska funktioner¶

Number-teoretiska och representationsfunktioner¶

math.ceil(x)¶

returnera taket på x, det minsta heltalet större än eller lika med x.Om x inte är en flottör, delegerar till x.__ceil__(), som ska returnera ett värdeIntegral.

math.comb(n, k)¶

returnera antalet sätt att välja k-objekt från N-objekt utan repetitionoch utan order.,

utvärderar tilln! / (k! * (n - k)!) närk <= n och utvärderar till noll närk > n.

kallas också binomialkoefficienten eftersom den är ekvivalent med koefficienten för K-TH-termen i polynomutvidgningen avuttrycket (1 + x) ** n.

höjerTypeError om något av argumenten inte är heltal.Höjer ValueError om något av argumenten är negativt.

math.copysign(x, y)¶math.fabs(x)¶

Return the absolute value of x.

math.factorial(x)¶

Return x factorial as an integer. Raises ValueError if x is not integral oris negative.

math.floor(x)¶math.fmod(x, y)¶

returnerafmod(x, y), enligt definitionen i platform C-biblioteket. Observera att uttrycket x % y kanske inte returnerar samma resultat. Avsikten med Cstandard är attfmod(x, y) är exakt (matematiskt; till infiniteprecision) lika medx - n*y för vissa heltal n så att resultatet harsamma tecken som x och magnitud mindre änabs(y)., Python ’s x % y returnerar ett resultat med tecknet på y istället, och kanske inte är exakt beräknbarför flytargument. Till exempel ärfmod(-1e-100, 1e100)-1e-100, men resultatet av Pythons-1e-100 % 1e100 är1e100-1e-100, som inte kan representeras exakt som en flottör, och rundor till den överraskande1e100. Forthis reason, function fmod() är i allmänhet att föredra när man arbetar medfloats, medan Pythons x % y är att föredra när man arbetar med heltal.,

math.frexp(x)¶math.fsum(iterable)¶

returnera en exakt flyttalssumma av värden i det tillåtna. Undviksloss av precision genom att spåra flera mellanliggande partiella summor:

>>> sum()0.9999999999999999>>> fsum()1.0

algoritmens noggrannhet beror på IEEE-754 aritmetiska garantier och dettypiska fallet där avrundningsläget är halv-jämnt., På vissa icke-Windowsbuilds använder det underliggande C-biblioteket utökat precisionstillägg och mayoccasionally dubbelrunda en mellansumma som gör att den är avstängd i sinsleast betydande bit.

För ytterligare diskussion och två alternativa tillvägagångssätt, se ASPN cookbookrecipes för exakt flyttal summering.

math.gcd(*heltal)¶

returnera den största gemensamma divisorn för de angivna heltalargumenten.Om något av argumenten är nonzero är det returnerade värdet det störstapositivt heltal som är en divisor av alla argument., Om alla argumentsare noll, då det returnerade värdet är 0. gcd()utan argumentsreturns0.

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

returnera True om värdena A och b ligger nära varandra ochFalse annars.,

huruvida två värden anses vara nära eller inte bestäms beroende pågivna absoluta och relativa toleranser.

rel_tol är den relativa toleransen – det är den maximala tillåtna skillnadenmellan A och b, i förhållande till det större absoluta värdet av A eller b.till exempel, för att ställa in en tolerans på 5%, passera rel_tol=0.05. Defaulttolerance är 1e-09, som försäkrar att de två värdena är sammamed ungefär 9 decimaler. rel_tol måste vara större än noll.

abs_tol är den minsta absoluta toleransen – användbar för jämförelser nearzero., abs_tol måste vara minst noll.

om inga fel uppstår blir resultatet:abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).

IEEE 754 särskilda värden förNaN,inf, och-inf behandlas enligt IEEE-reglerna. NaNär inte anseddnära något annat värde, inklusiveNaN. inf och -inf betraktas bara nära sig själva.

math.isfinite(x)¶

Return True if x is neither an infinity nor a NaN, andFalse otherwise. (Note that 0.0 is considered finite.)

math.isinf(x)¶

Return True if x is a positive or negative infinity, andFalse otherwise.,

math.isnan(x)¶

returneraTrue om x är en NaN (inte ett nummer), ochFalse annars.

math.isqrt(n)¶

returnera heltalet kvadratroten av det icke-negativa heltalet n. detta ärgolvet för den exakta kvadratroten av n, eller likvärdigt det största heltalet så att a2 ≤ n.

För vissa applikationer kan det vara bekvämare att ha minst heltal så att n ≤ a2, eller med andra ord taket på den exakta kvadratroten av rot av n., För positiv n kan detta beräknas meda = 1 + isqrt(n - 1).

math.lcm(*heltal)¶

returnera den minst vanliga multipel av de angivna heltalargumenten.Om alla argument är nonzero är det returnerade värdet det minstapositiva heltalet som är en multipel av alla argument. Om någon av argumentenär noll, är det returnerade värdet 0. lcm()utan argumentsreturns1.

math.ldexp(X, i)¶

returnera x * (2**i). Detta är i huvudsak inversen av funktionenfrexp().

math.modf(x)¶

returnera fraktions-och heltalsdelarna av x. båda resultaten bär signof x och är flöten.

returnera nästa flyttal efter x mot y.

om x är lika med y, returnera y.

exempel:

Se även math.ulp().

math.perm(n, k=None)¶

returnera antalet sätt att välja k-objekt från N objektutan upprepning och med ordning.

utvärderar tilln! / (n - k)! närk <= n och utvärderar till noll närk > n.

om k inte är angivet eller inte är något, återgår K som standard till nand funktionen n!.

höjerTypeError om något av argumenten inte är heltal.Höjer ValueError om något av argumenten är negativt.,

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

beräkna produkten av alla element i den inmatning som kan användas.Standardstartvärdet för produkten är 1.

När mätvärdet är tomt returnerar du startvärdet. Denna funktion är avsedd speciellt för användning med numeriska värden och kan avvisa icke-numeriska typer.

math.remainder(x, y)¶

returnera IEEE 754-stil resten av x med avseende på y., Forfinite x och finite nonzero y, Detta är skillnaden x - n*y,där n är det närmaste heltalet till det exakta värdet av kvoten x /y. Om x / y är exakt halvvägs mellan två på varandra följande heltal, används även heltal för n. Restenr = remainder(x,y) uppfyller således alltidabs(r) <= 0.5 * abs(y).,

specialfall följer IEEE 754: i synnerhet remainder(x, math.inf) isx för alla ändliga x, och remainder(x, 0) ochremainder(math.inf, x) höja ValueError för alla icke-NaN x.om resultatet av återstoden operationen är noll, kommer noll att hasamma tecken som x.

på plattformar som använder IEEE 754 binär flytpunkt är resultatet av dettaoperation alltid exakt representativt: inget avrundningsfel införs.

math.trunc(x)¶

returneraReal värde x trunkerat till ettIntegral (vanligtvis ett heltal). Delegater tillx.__trunc__().

math.ulp(x)¶

returnera värdet på den minst signifikanta biten av flottören x:

• om X är en NaN (inte ett tal), returnera x.

• om x är negativ, returneraulp(-x).

• om x är en positiv oändlighet, returnera x.,

• Om x är lika med noll, returnera den minsta positivedenormalized representeras float (mindre än det minsta positivenormalized flyta sys.float_info.min).

• om x är lika med den största positiva representabel float,returnera värdet av den minst signifikanta bit x, så att den förstafloat mindre än x är x - ulp(x).

• annars (x är ett positivt ändligt tal), returnera värdet på den minst betydande bit av x, så att den första flyta större än xisx + ulp(x).,

ULP står för ”Unit In The Last Place”.

Se ävenmath.nextafter() ochsys.float_info.epsilon.

Observera att frexp() och modf() har en annan samtal/tillbaka patternthan sin C-medel: de tar ett enda argument, och returnera ett par ofvalues, snarare än att återvända till sitt andra avkastning värde genom ett ”outputparameter’ (det finns inget sådant i Python).,

för funktionernaceil(),floor() ochmodf(), Observera att allfloating-punktnummer av tillräckligt stor storlek är exakta heltal.Python-flöten bär vanligtvis inte mer än 53 bitar av precision (samma som denplattform C dubbeltyp), i vilket fall som helst float x med abs(x) >= 2**52har nödvändigtvis inga fraktionerade bitar.