math — Mathematical functions

---

Bu modül, C standardı tarafından tanımlanan matematiksel fonksiyonlara erişim sağlar.

Bu fonksiyonlar karmaşık sayılarla kullanılamaz; karmaşık sayılar için desteğe ihtiyacınız varsa cmath modülündeki aynı isimli fonksiyonları kullanın. Karmaşık sayıları destekleyen ve desteklemeyen fonksiyonlar arasındaki ayrım, çoğu kullanıcının karmaşık sayıları anlamak için gereken kadar matematik öğrenmek istememesi nedeniyle yapılmıştır. Karmaşık bir sonuç yerine bir istisna almak, parametre olarak kullanılan beklenmedik karmaşık sayının daha erken tespit edilmesini sağlar, böylece programcı ilk etapta nasıl ve neden üretildiğini belirleyebilir.

Aşağıdaki fonksiyonlar bu modül tarafından sağlanır. Aksi açıkça belirtilmedikçe, tüm dönüş değerleri floattır.

Number-theoretic functions
comb(n, k)	Number of ways to choose k items from n items without repetition and without order
factorial(n)	n factorial
gcd(*integers)	Greatest common divisor of the integer arguments
isqrt(n)	Integer square root of a nonnegative integer n
lcm(*integers)	Least common multiple of the integer arguments
perm(n, k)	Number of ways to choose k items from n items without repetition and with order
Floating point arithmetic
ceil(x)	Ceiling of x, the smallest integer greater than or equal to x
fabs(x)	Absolute value of x
floor(x)	Floor of x, the largest integer less than or equal to x
fma(x, y, z)	Fused multiply-add operation: (x * y) + z
fmod(x, y)	Remainder of division x / y
modf(x)	Fractional and integer parts of x
remainder(x, y)	Remainder of x with respect to y
trunc(x)	Integer part of x
Floating point manipulation functions
copysign(x, y)	Magnitude (absolute value) of x with the sign of y
frexp(x)	Mantissa and exponent of x
isclose(a, b, rel_tol, abs_tol)	Check if the values a and b are close to each other
isfinite(x)	Check if x is neither an infinity nor a NaN
isinf(x)	Check if x is a positive or negative infinity
isnan(x)	Check if x is a NaN (not a number)
ldexp(x, i)	x * (2**i), inverse of function frexp()
nextafter(x, y, steps)	Floating-point value steps steps after x towards y
ulp(x)	Value of the least significant bit of x
Power, exponential and logarithmic functions
cbrt(x)	Cube root of x
exp(x)	e raised to the power x
exp2(x)	2 raised to the power x
expm1(x)	e raised to the power x, minus 1
log(x, base)	Logarithm of x to the given base (e by default)
log1p(x)	Natural logarithm of 1+x (base e)
log2(x)	Base-2 logarithm of x
log10(x)	Base-10 logarithm of x
pow(x, y)	x raised to the power y
sqrt(x)	Square root of x
Summation and product functions
dist(p, q)	Euclidean distance between two points p and q given as an iterable of coordinates
fsum(iterable)	Sum of values in the input iterable
hypot(*coordinates)	Euclidean norm of an iterable of coordinates
prod(iterable, start)	Product of elements in the input iterable with a start value
sumprod(p, q)	Sum of products from two iterables p and q
Angular conversion
degrees(x)	Convert angle x from radians to degrees
radians(x)	Convert angle x from degrees to radians
Trigonometric functions
acos(x)	Arc cosine of x
asin(x)	Arc sine of x
atan(x)	Arc tangent of x
atan2(y, x)	atan(y / x)
cos(x)	Cosine of x
sin(x)	Sine of x
tan(x)	Tangent of x
Hyperbolic functions
acosh(x)	Inverse hyperbolic cosine of x
asinh(x)	Inverse hyperbolic sine of x
atanh(x)	Inverse hyperbolic tangent of x
cosh(x)	Hyperbolic cosine of x
sinh(x)	Hyperbolic sine of x
tanh(x)	Hyperbolic tangent of x
Special functions
erf(x)	Error function at x
erfc(x)	Complementary error function at x
gamma(x)	Gamma function at x
lgamma(x)	Natural logarithm of the absolute value of the Gamma function at x
Constants
pi	π = 3.141592…
e	e = 2.718281…
tau	τ = 2π = 6.283185…
inf	Positive infinity
nan	“Not a number” (NaN)

Number-theoretic functions

math.comb(n, k)

Tekrarlama ve sıralama olmaksızın n öğe arasından k öğeyi seçmenin yollarının sayısını döndürür.

n! / (k! * (n - k)!) değerini k <= n olduğunda verir ve k > n olduğunda sıfır olarak değerlendirir.

Binom katsayısı olarak da adlandırılır. Çünkü (1 + x)ⁿ polinom açılımındaki k. terimin katsayısına eşittir.

Herhangi bir argümanın tamsayı olmaması durumunda TypeError fırlatır. Herhangi bir argümanın negatif olması durumunda ValueError fırlatır.

Added in version 3.8.

math.factorial(n)

n faktöriyeli tamsayı olarak döndürür. n tamsayı değil veya negatifse ValueError fırlatır.

3.10 sürümünde değişti: Floats with integral values (like 5.0) are no longer accepted.

math.gcd(*integers)

Belirtilen tamsayı bağımsız değişkenlerinin en büyük ortak bölenini döndürür. Bağımsız değişkenlerden herhangi biri sıfır değilse, döndürülen değer tüm bağımsız değişkenlerin bölenleri olan en büyük pozitif tamsayıdır. Tüm bağımsız değişkenler sıfırsa, döndürülen değer 0 olur. bağımsız değişkenler olmadan gcd() fonksiyonu 0 değerini döndürür.

Added in version 3.5.

3.9 sürümünde değişti: İsteğe bağlı sayıda bağımsız değişken için destek eklendi. Önceden sadece iki argüman destekleniyordu.

math.isqrt(n)

Negatif olmayan n tamsayısının tamsayı karekökünü döndürür. Bu, n tam karekökünün tabanıdır veya eşdeğer olarak a² ≤ n olacak şekilde en büyük a tamsayısıdır.

Bazı uygulamalar için, n ≤ a² olacak şekilde en küçük a tamsayısına veya başka bir deyişle n’nin tam karekökünün tavanına sahip olmak daha uygun olabilir. Pozitif n için bu, a = 1 + isqrt(n - 1) kullanılarak hesaplanabilir.

Added in version 3.8.

math.lcm(*integers)

Belirtilen tamsayı bağımsız değişkenlerinin en küçük ortak katını döndürür. Tüm bağımsız değişkenler sıfır değilse, döndürülen değer tüm bağımsız değişkenlerin katı olan en küçük pozitif tamsayıdır. Bağımsız değişkenlerden herhangi biri sıfırsa, döndürülen değer 0 olur. Bağımsız değişkenler olmadan lcm() işlevi 1 değerini döndürür.

Added in version 3.9.

math.perm(n, k=None)

Tekrarlama olmadan ve sırayla n öğe arasından k öğeyi seçmenin yollarının sayısını döndürür.

n! / (k! * (n - k)!) değerini k <= n olduğunda verir ve k > n olduğunda sıfır olarak değerlendirir.

If k is not specified or is None, then k defaults to n and the function returns n!.

Herhangi bir argümanın tamsayı olmaması durumunda TypeError fırlatır. Herhangi bir argümanın negatif olması durumunda ValueError fırlatır.

Added in version 3.8.

Floating point arithmetic

math.ceil(x)

x’in tavanını, yani x’ten büyük veya ona eşit en küçük tamsayıyı döndürür. Eğer x bir float değilse, bir Integral değeri döndürmesi gereken x.__ceil__’e delege eder.

math.fabs(x)

x’in mutlak değerini döndürür.

math.floor(x)

x*’ten küçük veya ona eşit en büyük tamsayı olan x’in tabanını döndürür. Eğer x bir ondalıklı sayı değilse, bir Integral değeri döndürmesi gereken x.__floor__ değerini vermelidir.

math.fma(x, y, z)

Fused multiply-add operation. Return (x * y) + z, computed as though with infinite precision and range followed by a single round to the float format. This operation often provides better accuracy than the direct expression (x * y) + z.

This function follows the specification of the fusedMultiplyAdd operation described in the IEEE 754 standard. The standard leaves one case implementation-defined, namely the result of fma(0, inf, nan) and fma(inf, 0, nan). In these cases, math.fma returns a NaN, and does not raise any exception.

Added in version 3.13.

math.fmod(x, y)

Platform C kütüphanesi tarafından tanımlandığı gibi fmod(x, y) döndürür. Python ifadesinin x % y aynı sonucu döndürmeyebileceğini unutmayın. C standardının amacı, fmod(x, y) ifadesinin tam olarak (matematiksel olarak; sonsuz hassasiyette) n tamsayısı için x - n*y değerine eşit olmasıdır, böylece sonuç x ile aynı işarete ve abs(y) değerinden daha küçük bir büyüklüğe sahip olur. Python’un x % y değeri bunun yerine y işaretine sahip bir sonuç döndürür ve ondalıklı sayı bağımsız değişkenler için tam olarak hesaplanabilir olmayabilir. Örneğin, fmod(-1e-100, 1e100) sonucu -1e-100 ‘dür, ancak Python`un -1e-100 % 1e100 sonucu 1e100-1e-100 ‘dür, bu da tam olarak bir ondalıklı sayı olarak gösterilemez ve şaşırtıcı 1e100 değerine yuvarlanır. Bu nedenle, floatlarla çalışırken genellikle fmod() fonksiyonu tercih edilirken, tamsayılarla çalışırken Python’un x % y fonksiyonu tercih edilir.

math.modf(x)

x*’in kesirli ve tamsayı kısımlarını döndürür. Her iki sonuç da x işaretini taşır ve kayan değerdir.

Note that modf() has a different call/return pattern than its C equivalents: it takes a single argument and return a pair of values, rather than returning its second return value through an ‘output parameter’ (there is no such thing in Python).

math.remainder(x, y)

x*’in y’ye göre IEEE 754 tarzı kalanını döndürür. Sonlu x ve sonlu sıfır olmayan y için bu, x - n*y farkıdır; burada n, x / y bölümünün tam değerine en yakın tamsayıdır. Eğer x / y ardışık iki tamsayının tam ortası ise, n için en yakın çift tamsayı kullanılır. Kalan r = remainder(x, y) böylece her zaman abs(r) <= 0.5 * abs(y) sağlar.

Özel durumlar IEEE 754’ü takip eder: özellikle, remainder(x, math.inf) herhangi bir sonlu x için x’dir ve remainder(x, 0) ve remainder(math.inf, x) NaN olmayan herhangi bir x için ValueError yükseltir. Eğer kalan işleminin sonucu sıfır ise, bu sıfır x ile aynı işarete sahip olacaktır.

On platforms using IEEE 754 binary floating point, the result of this operation is always exactly representable: no rounding error is introduced.

Added in version 3.7.

math.trunc(x)

Kesirli kısmı çıkarılmış ve tamsayı kısmı bırakılmış x döndürür. Bu 0’a yuvarlanır: trunc() pozitif x için floor() ve negatif x için ceil() ile eşdeğerdir. Eğer x bir float değilse, bir Integral değeri döndürmesi gereken x.__trunc__’a delege eder.

ceil(), floor() ve modf() fonksiyonları için, yeterince büyük büyüklükteki tüm kayan noktalı sayıların tam tamsayı olduğunu unutmayın. Python kayan noktalı sayıları tipik olarak 53 bitten fazla hassasiyet taşımaz (C platformundaki double tipiyle aynıdır), bu durumda abs(x) >= 2**52 olan herhangi bir x kayan noktalı sayısı zorunlu olarak kesirli bitlere sahip değildir.

Floating point manipulation functions

math.copysign(x, y)

Büyüklüğü (mutlak değeri) x olan ancak işareti y olan bir ondalıklı sayı döndürür. İşaretli sıfırları destekleyen platformlarda, copysign(1.0, -0.0) -1.0 döndürür.

math.frexp(x)

x*’in mantissa ve üssünü (m, e) çifti olarak döndürür. m bir ondalıklı sayı ve e bir tamsayıdır, bu yüzden x == m * 2**e doğru olarak eşittir. Eğer x sıfır ise (0.0, 0), aksi takdirde 0.5 <= abs(m) < 1 döndürür. Bu, bir ondalıklı sayının iç temsilini taşınabilir bir şekilde “ayırmak” için kullanılır.

Note that frexp() has a different call/return pattern than its C equivalents: it takes a single argument and return a pair of values, rather than returning its second return value through an ‘output parameter’ (there is no such thing in Python).

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

Eğer a ve b değerleri birbirine yakınsa True, değilse False döndürür.

Whether or not two values are considered close is determined according to given absolute and relative tolerances. If no errors occur, the result will be: abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).

rel_tol is the relative tolerance – it is the maximum allowed difference between a and b, relative to the larger absolute value of a or b. For example, to set a tolerance of 5%, pass rel_tol=0.05. The default tolerance is 1e-09, which assures that the two values are the same within about 9 decimal digits. rel_tol must be nonnegative and less than 1.0.

abs_tol is the absolute tolerance; it defaults to 0.0 and it must be nonnegative. When comparing x to 0.0, isclose(x, 0) is computed as abs(x) <= rel_tol  * abs(x), which is False for any x and rel_tol less than 1.0. So add an appropriate positive abs_tol argument to the call.

IEEE 754 özel değerleri olan NaN, inf ve -inf IEEE kurallarına göre ele alınacaktır. Özellikle, NaN, NaN dahil olmak üzere başka hiçbir değere yakın kabul edilmez. inf ve -inf yalnızca kendilerine yakın kabul edilir.

Added in version 3.5.

Ayrıca bakınız

PEP 485 – Yaklaşık eşitliği test etmek için bir fonksiyon

math.isfinite(x)

Eğer x sonsuz bir değer ya da NaN ise True, aksi takdirde False döndürür. (0.0 sonlu olarak kabul edilir.)

Added in version 3.2.

math.isinf(x)

Eğer x pozitif veya negatif bir sonsuz ise True, aksi takdirde False döndürür.

math.isnan(x)

Eğer x bir NaN (sayı değil) ise True, aksi takdirde False döndürür.

math.ldexp(x, i)

x * (2**i) döndürür. Bu aslında frexp() fonksiyonunun tersidir.

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

Return the floating-point value steps steps after x towards y.

If x is equal to y, return y, unless steps is zero.

Örnekler:

• math.nextafter(x, math.inf) yukarı gider: pozitif sonsuza doğru.

• math.nextafter(x, -math.inf) aşağı iner: eksi sonsuza doğru.

• math.nextafter(x, 0.0) sıfıra doğru gider.

• math.nextafter(x, math.copysign(math.inf, x)) sıfırdan uzaklaşır.

Ayrıca bakınız math.ulp().

Added in version 3.9.

3.12 sürümünde değişti: Added the steps argument.

math.ulp(x)

float x öğesinin en az anlamlı bitinin değerini döndürür:

• Eğer x bir NaN (sayı değil) ise True, aksi takdirde False döndürür.

• Eğer x negatif ise, ulp(-x) döndürür.

• Eğer x pozitif bir sonsuzluk ise, x değerini döndürür.

• Eğer x sıfıra eşitse, temsil edilebilir en küçük pozitif normalize floatı döndürür (minimum pozitif normalize floattan daha küçük, sys.float_info.min).

• Eğer x pozitif olarak temsil edilebilen en büyük float değerine eşitse, x değerinden küçük olan ilk float değeri x - ulp(x) olacak şekilde x değerinin en küçük anlamlı bitinin değerini döndürür.

• Aksi takdirde (x pozitif bir sonlu sayıdır), x’in en az anlamlı bitinin değerini döndürür, öyle ki x’ten büyük ilk float x + ulp(x) olur.

ULP, “Son Yerdeki Birim” anlamına gelmektedir.

Ayrıca bakınız math.nextafter() ve sys.float_info.epsilon.

Added in version 3.9.

Power, exponential and logarithmic functions

math.cbrt(x)

x*’in küp kökünü döndürür.

Added in version 3.11.

math.exp(x)

e’yi x kuvvetine yükseltilmiş olarak döndürür, burada e = 2.718281… doğal logaritma tabanıdır. Bu genellikle math.e ** x veya pow(math.e, x) değerinden daha doğrudur.

math.exp2(x)

2’nin x kuvvetine yükseltilmiş halini döndürür.

Added in version 3.11.

math.expm1(x)

Return e raised to the power x, minus 1. Here e is the base of natural logarithms. For small floats x, the subtraction in exp(x) - 1 can result in a significant loss of precision; the expm1() function provides a way to compute this quantity to 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

Added in version 3.2.

math.log(x[, base])

Bir bağımsız değişkenle, x’in doğal logaritmasını döndürür (e tabanına göre).

İki bağımsız değişkenle, log(x)/log(taban) şeklinde hesaplanan x değerinin verilen taban değerine göre logaritmasını döndürür.

math.log1p(x)

1+x’in (e tabanı) doğal logaritmasını döndürür. Sonuç, sıfıra yakın x için doğru olacak şekilde hesaplanır.

math.log2(x)

x*’in 2 taban logaritmasını döndürür. Bu genellikle log(x, 2) değerinden daha doğrudur.

Added in version 3.3.

Ayrıca bakınız

int.bit_length(), işaret ve baştaki sıfırlar hariç olmak üzere, bir tamsayıyı ikili olarak temsil etmek için gerekli bit sayısını döndürür.

math.log10(x)

x ‘in 10 tabanında logaritmasını döndürür. Bu genellikle log(x, 10) ‘dan daha doğrudur.

math.pow(x, y)

Return x raised to the power y. Exceptional cases follow the IEEE 754 standard as far as possible. In particular, pow(1.0, x) and pow(x, 0.0) always return 1.0, even when x is a zero or a NaN. If both x and y are finite, x is negative, and y is not an integer then pow(x, y) is undefined, and raises ValueError.

Yerleşik ** operatörünün aksine, math.pow() her iki argümanını da float türüne dönüştürür. Tam sayı kuvvetlerini hesaplamak için ** veya yerleşik pow() fonksiyonunu kullanın.

3.11 sürümünde değişti: Özel durumlar pow(0.0, -inf) ve pow(-0.0, -inf), IEEE 754 ile tutarlılık için ValueError` yükseltmek yerine inf döndürmek üzere değiştirildi.

math.sqrt(x)

x’in karekökünü döndürür.

Summation and product functions

math.dist(p, q)

Her biri bir koordinat dizisi (veya yinelenebilir) olarak verilen iki p ve q noktası arasındaki Öklid mesafesini döndürür. İki nokta aynı boyuta sahip olmalıdır.

Kabaca şuna eşdeğerdir:

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

Added in version 3.8.

math.fsum(iterable)

Return an accurate floating-point sum of values in the iterable. Avoids loss of precision by tracking multiple intermediate partial sums.

Algoritmanın doğruluğu IEEE-754 aritmetik garantilerine ve yuvarlama modunun yarı-çift olduğu tipik duruma bağlıdır. Bazı Windows dışı yapılarda, temel C kütüphanesi genişletilmiş hassasiyetli toplama kullanır ve bazen bir ara toplamı çift yuvarlayarak en az anlamlı bitinde eksik olmasına neden olabilir.

For further discussion and two alternative approaches, see the ASPN cookbook recipes for accurate floating-point summation.

math.hypot(*coordinates)

Öklid normunu döndürür, sqrt(sum(x**2 for x in coordinates)). Bu, vektörün orijinden koordinatlar tarafından verilen noktaya olan uzunluğudur.

İki boyutlu bir (x, y) noktası için bu, Pisagor teoremi sqrt(x*x + y*y) kullanılarak bir dik üçgenin hipotenüsünün hesaplanmasına eşdeğerdir.

3.8 sürümünde değişti: n boyutlu noktalar için destek eklendi. Önceden sadece iki boyutlu durum destekleniyordu.

3.10 sürümünde değişti: Algoritmanın doğruluğu, maksimum hata 1 ulp’nin (son sıradaki birim) altında olacak şekilde geliştirildi. Daha tipik olarak, sonuç neredeyse her zaman 1/2 ulp içinde doğru şekilde yuvarlanır.

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

Girdi iterable içindeki tüm elemanların çarpımını hesaplar. Çarpım için varsayılan başlangıç değeri 1 ‘dir.

Yinelenebilir boş olduğunda, başlangıç değerini döndürür. Bu fonksiyon özellikle sayısal değerlerle kullanılmak üzere tasarlanmıştır ve sayısal olmayan türleri reddedebilir.

Added in version 3.8.

math.sumprod(p, q)

Return the sum of products of values from two iterables p and q.

Raises ValueError if the inputs do not have the same length.

Kabaca şuna eşdeğerdir:

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

For float and mixed int/float inputs, the intermediate products and sums are computed with extended precision.

Added in version 3.12.

Açısal dönüşüm

math.degrees(x)

Açıyı x radyandan dereceye dönüştürür.

math.radians(x)

Açıyı x dereceden radyana dönüştürür.

Trigonometrik fonksiyonlar

math.acos(x)

Radyan cinsinden x’in yay kosinüsünü döndürür. Sonuç 0 ile pi arasındadır.

math.asin(x)

Radyan cinsinden x’in yay sinüsünü döndürür. Sonuç -pi/2 ile pi/2 arasındadır.

math.atan(x)

Radyan cinsinden x’in yay tanjantını döndürür. Sonuç -pi/2 ile pi/2 arasındadır.

math.atan2(y, x)

Radyan cinsinden atan(y / x) döndürür. Sonuç -pi ile pi arasındadır. Düzlemde orijinden (x, y) noktasına kadar olan vektör, pozitif X ekseni ile bu açıyı yapar. atan2() ‘nin amacı, her iki girdinin de işaretlerinin bilinmesidir, böylece açı için doğru kadranı hesaplayabilir. Örneğin, atan(1) ve atan2(1, 1) her ikisi de pi/4 ‘tür, ancak atan2(-1, -1) ise -3*pi/4 ‘tür.

math.cos(x)

x radyanın kosinüsünü döndürür.

math.sin(x)

x radyanın sinüsünü döndürür.

math.tan(x)

x radyanın tanjantını döndürür.

Hiberbolik fonksiyonlar

Hyperbolic functions are analogs of trigonometric functions that are based on hyperbolas instead of circles.

math.acosh(x)

x’in ters hiperbolik kosinüsünü döndürür.

math.asinh(x)

x’in ters hiperbolik sinüsünü döndürür.

math.atanh(x)

x’in ters hiperbolik tanjantını döndürür.

math.cosh(x)

x’in hiperbolik kosinüsünü döndürür.

math.sinh(x)

x’in hiperbolik sinüsünü döndürür.

math.tanh(x)

x’in hiperbolik tanjantını döndürür.

Özel fonksiyonlar

math.erf(x)

x adresindeki hata fonksiyonunu döndürür.

The erf() function can be used to compute traditional statistical functions such as the cumulative standard normal distribution:

def phi(x):
    'Cumulative distribution function for the standard normal distribution'
    return (1.0 + erf(x / sqrt(2.0))) / 2.0

Added in version 3.2.

math.erfc(x)

x ‘de tamamlayıcı hata fonksiyonunu döndürür. Tamamlayıcı hata fonksiyonu 1.0 - erf(x) olarak tanımlanır. Birbirinden çıkarmanın anlamlılık kaybına neden olacağı büyük x değerleri için kullanılır.

Added in version 3.2.

math.gamma(x)

x adresindeki Gamma fonksiyonunu döndürür.

Added in version 3.2.

math.lgamma(x)

Gama fonksiyonunun x’deki mutlak değerinin doğal logaritmasını döndürür.

Added in version 3.2.

Sabitler

math.pi

Matematiksel sabit π = 3.141592…, mevcut hassasiyete göre.

math.e

Matematiksel sabit e = 2,718281…, mevcut hassasiyete göre.

math.tau

Matematiksel sabit τ = 6.283185…, mevcut hassasiyete göre. Tau, bir dairenin çevresinin yarıçapına oranı olan 2π’ye eşit bir daire sabitidir. Tau hakkında daha fazla bilgi edinmek için Vi Hart’ın Pi (hala) Yanlış videosuna göz atın ve Tau gününü iki kat daha fazla turta yiyerek kutlamaya başlayın!

Added in version 3.6.

math.inf

Bir kayan noktalı pozitif sonsuzluk. (Negatif sonsuzluk için -math.inf kullanın.) float('inf') çıktısına eşdeğerdir.

Added in version 3.5.

math.nan

A floating-point “not a number” (NaN) value. Equivalent to the output of float('nan'). Due to the requirements of the IEEE-754 standard, math.nan and float('nan') are not considered to equal to any other numeric value, including themselves. To check whether a number is a NaN, use the isnan() function to test for NaNs instead of is or ==. Example:

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

Added in version 3.5.

3.11 sürümünde değişti: Artık her zaman kullanılabilir.

CPython uygulama ayrıntısı: math modülü çoğunlukla platform C matematik kütüphanesi fonksiyonları etrafındaki ince sarmalayıcılardan oluşur. İstisnai durumlarda davranış, uygun olan yerlerde C99 standardının Ek F’sini takip eder. Mevcut uygulama, sqrt(-1.0) veya log(0.0) gibi geçersiz işlemler için :exc:ValueError (C99 Annex F geçersiz işlem veya sıfıra bölme sinyalini önerir) ve taşan sonuçlar için OverflowError (örneğin, exp(1000.0)) yükseltir. Girdi argümanlarından biri veya daha fazlası NaN olmadığı sürece yukarıdaki fonksiyonların hiçbirinden NaN döndürülmeyecektir; bu durumda, çoğu fonksiyon bir NaN döndürecektir, ancak (yine C99 Ek F’yi takip ederek) bu kuralın bazı istisnaları vardır, örneğin pow(float('nan'), 0.0) veya hypot(float('nan'), float('inf')).

Python’un sinyal veren NaN’ları sessiz NaN’lardan ayırt etmek için hiçbir çaba göstermediğini ve sinyal veren NaN’lar için davranışın belirtilmediğini unutmayın. Tipik davranış, tüm NaN’lara sessizmiş gibi davranmaktır.

Ayrıca bakınız

Modül cmath

Bu fonksiyonların çoğunun karmaşık sayı versiyonları.