محاسبات ممیز شناور¶

math.ceil(x)¶

سقف x را برمی‌گرداند، یعنی کوچک‌ترین عدد صحیحی که بزرگ‌تر یا مساوی x است. اگر x شناور نباشد، به x.__ceil__ ارجاع داده می‌شود، که باید مقداری از نوع Integral برگرداند.

math.fabs(x)¶

قدر مطلق x را برمی‌گرداند.

math.floor(x)¶

کف x، یعنی بزرگ‌ترین عدد صحیح کوچک‌تر یا مساوی x را برمی‌گرداند. اگر x از نوع float نباشد، به x.__floor__ محول می‌شود، که باید مقداری از نوع Integral برگرداند.

math.fma(x, y, z)¶

عملیات ضرب-جمع ادغام‌شده (Fused multiply-add). (x * y) + z را برمی‌گرداند، گویی با دقت و دامنه‌ی بی‌نهایت محاسبه شده باشد و سپس یک گرد کردن واحد روی آن به قالب float انجام شده باشد. این عملیات معمولاً دقت بهتری نسبت به عبارت مستقیم (x * y) + z ارائه می‌دهد.

این تابع از مشخصات عملیات fusedMultiplyAdd پیروی می‌کند که در استاندارد IEEE 754 توصیف شده است. این استاندارد یک حالت را به‌صورت تعریف‌شده توسط پیاده‌سازی باقی گذاشته است، یعنی نتیجه‌ی fma(0, inf, nan) و fma(inf, 0, nan). در این حالت‌ها، math.fma یک NaN برمی‌گرداند و هیچ استثنایی را پرتاب نمی‌کند.

اضافه شده در نسخه‌ی 3.13.

math.fmax(x, y)¶

بزرگ‌ترین مقدار بین دو مقدار اعشاری را به دست می‌آورد و NaNها را به عنوان داده‌ی مفقود در نظر می‌گیرد.

وقتی هر دو عملوند (علامت‌دار) NaN یا صفر باشند، به ترتیب nan و 0 را برمی‌گرداند و علامت نتیجه توسط پیاده‌سازی تعریف می‌شود؛ یعنی fmax() نیازی به حساسیت نسبت به علامت چنین عملوندهایی ندارد (به ضمیمه F استاندارد C11، بندهای §F.10.0.3 و §F.10.9.2 مراجعه کنید).

اضافه شده در نسخه‌ی 3.15.

math.fmin(x, y)¶

کوچک‌ترین مقدار بین دو مقدار اعشاری را به دست آورید و مقادیر NaN را به عنوان داده‌ی گم‌شده در نظر بگیرید.

هنگامی که هر دو عملوند (علامت‌دار) NaN یا صفر باشند، به ترتیب nan و 0 را برمی‌گرداند و علامت نتیجه وابسته به پیاده‌سازی است؛ یعنی fmin() نیازی نیست نسبت به علامت چنین عملوندهایی حساس باشد (به ضمیمه‌ی F استاندارد C11، بخش‌های §F.10.0.3 و §F.10.9.3 مراجعه کنید).

اضافه شده در نسخه‌ی 3.15.

math.fmod(x, y)¶

باقی‌مانده‌ی ممیز شناور x / y را، همان‌طور که توسط تابع fmod(x, y) کتابخانه‌ی C سکو تعریف‌شده است، برمی‌گرداند. توجه داشته باشید که عبارت x % y در پایتون ممکن است همان نتیجه را برنگرداند. منظور استاندارد C این است که fmod(x, y) دقیقاً (از نظر ریاضی؛ با دقت نامتناهی) برابر با x - n*y برای عدد صحیحی n باشد، به‌گونه‌ای که نتیجه همان علامت x را داشته باشد و قدر مطلق آن کمتر از abs(y) باشد. در عوض، x % y در پایتون نتیجه‌ای با علامت y برمی‌گرداند و ممکن است برای آرگومان‌های ممیز شناور به‌طور دقیق قابل محاسبه نباشد. برای مثال، fmod(-1e-100, 1e100) برابر -1e-100 است، اما نتیجه‌ی -1e-100 % 1e100 در پایتون 1e100-1e-100 است که نمی‌توان آن را دقیقاً به‌عنوان یک عدد ممیز شناور بازنمایی کرد و به مقدار شگفت‌آور 1e100 گرد می‌شود. به همین دلیل، معمولاً هنگام کار با اعداد ممیز شناور تابع fmod() ترجیح داده می‌شود، در حالی که هنگام کار با اعداد صحیح، x % y در پایتون ترجیح داده می‌شود.

math.modf(x)¶

بخش کسری و بخش صحیح x را برمی‌گرداند. هر دو نتیجه علامت x را دارند و از نوع float هستند.

توجه داشته باشید که modf() الگوی فراخوانی/بازگشت متفاوتی نسبت به معادل‌های C خود دارد: این تابع یک آرگومان می‌گیرد و جفتی از مقادیر را برمی‌گرداند، به جای اینکه دومین مقدار بازگشتی خود را از طریق یک «پارامتر خروجی» برگرداند (چنین چیزی در پایتون وجود ندارد).

math.remainder(x, y)¶

باقی‌مانده‌ی x نسبت به y به‌سبک IEEE 754 را برمی‌گرداند. برای x متناهی و y متناهی غیرصفر، این مقدار، تفاضل x - n*y است، که در آن n نزدیک‌ترین عدد صحیح به مقدار دقیق خارج‌قسمت x / y است. اگر x / y دقیقاً در میانه‌ی دو عدد صحیح متوالی باشد، نزدیک‌ترین عدد صحیح زوج برای n استفاده می‌شود. بنابراین باقی‌مانده‌ی r = remainder(x, y) همواره شرط abs(r) <= 0.5 * abs(y) را برآورده می‌کند.

موارد خاص از IEEE 754 پیروی می‌کنند: به‌ویژه، remainder(x, math.inf) برای هر x متناهی برابر با x است، و remainder(x, 0) و remainder(math.inf, x) برای هر x که NaN نباشد، ValueError را پرتاب می‌کنند. اگر نتیجه‌ی عملیات باقی‌مانده صفر باشد، آن صفر همان علامت x را خواهد داشت.

در سکوهای استفاده‌کننده از ممیز شناور دودویی IEEE 754، نتیجه‌ی این عملیات همیشه به‌طور دقیق قابل بازنمایی است: هیچ خطای گردکردنی ایجاد نمی‌شود.

اضافه شده در نسخه‌ی 3.7.

math.trunc(x)¶

x را با حذف بخش کسری برمی‌گرداند و بخش صحیح آن را باقی می‌گذارد. این گرد کردن به سمت ۰ است: trunc() برای x مثبت معادل floor() و برای x منفی معادل ceil() است. اگر x از نوع float نباشد، به x.__trunc__ محول می‌شود، که باید یک مقدار Integral برگرداند.

برای توابع ceil()، floor() و modf()، توجه داشته باشید که همه‌ی اعداد ممیز شناور با بزرگی کافی، اعداد صحیح دقیق هستند. شناورهای پایتون معمولاً بیش از ۵۳ بیت دقت ندارند (همانند نوع double پلتفرم C)، که در این صورت هر شناور x با abs(x) >= 2**52 لزوماً هیچ بیت کسری ندارد.

توابع دستکاری اعداد ممیز شناور¶

math.copysign(x, y)¶

یک عدد اعشاری با بزرگی (قدر مطلق) x اما با علامت y برمی‌گرداند. در سکوهای پشتیبانی‌کننده از صفرهای علامت‌دار، copysign(1.0, -0.0) مقدار -1.0 را برمی‌گرداند.

math.frexp(x)¶

مانتیس و توان x را به‌صورت جفت (m, e) برمی‌گرداند. اگر x یک عدد متناهی و ناصفر باشد، آنگاه m یک عدد اعشاری با 0.5 <= abs(m) < 1.0 است و e یک عدد صحیح است، به‌طوری‌که x == m * 2**e دقیقاً برقرار باشد. در غیر این صورت، (x, 0) را برمی‌گرداند. این تابع برای «جدا کردن» نمایش داخلی یک عدد اعشاری به‌شکلی قابل‌انتقال استفاده می‌شود.

توجه داشته باشید که frexp() الگوی فراخوانی/بازگشت متفاوتی نسبت به معادل‌های C خود دارد: این تابع یک آرگومان می‌گیرد و یک جفت مقدار برمی‌گرداند، به جای اینکه دومین مقدار بازگشتی خود را از طریق یک «پارامتر خروجی» برگرداند (چنین چیزی در پایتون وجود ندارد).

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

اگر مقادیر a و b به هم نزدیک باشند، True و در غیر این صورت False برمی‌گرداند.

اینکه آیا دو مقدار نزدیک در نظر گرفته می‌شوند یا خیر، بر اساس رواداری‌های مطلق و نسبی داده‌شده تعیین می‌شود. اگر هیچ خطایی رخ ندهد، نتیجه به‌صورت abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol) خواهد بود.

rel_tol تحمل نسبی است — این مقدار حداکثر اختلاف مجاز بین a و b، نسبت به بزرگ‌ترین قدر مطلقِ a یا b است. برای مثال، برای تنظیم تحمل ۵٪، rel_tol=0.05 را ارسال کنید. تحمل پیش‌فرض 1e-09 است، که تضمین می‌کند دو مقدار تا حدود ۹ رقم اعشاری یکسان هستند. rel_tol باید غیرمنفی و کمتر از 1.0 باشد.

abs_tol تحمل مطلق است؛ مقدار پیش‌فرض آن 0.0 است و باید غیرمنفی باشد. هنگامی که x را با 0.0 مقایسه می‌کنید، isclose(x, 0) به‌صورت abs(x) <= rel_tol  * abs(x) محاسبه می‌شود، که برای هر x غیرصفر و rel_tol کمتر از 1.0، False است. بنابراین یک آرگومان abs_tol مثبت و مناسب به فراخوانی اضافه کنید.

مقادیر ویژه‌ی IEEE 754 شامل NaN، inf و -inf طبق قوانین IEEE پردازش می‌شوند. به‌طور مشخص، NaN به هیچ مقدار دیگری، از جمله NaN، نزدیک در نظر گرفته نمی‌شود. inf و -inf تنها به خودشان نزدیک در نظر گرفته می‌شوند.

اضافه شده در نسخه‌ی 3.5.

همچنین ببینید

PEP 485 -- تابعی برای آزمون برابری تقریبی

math.isfinite(x)¶

اگر x نه بی‌نهایت و نه NaN باشد، True را برمی‌گرداند و در غیر این صورت False را برمی‌گرداند. (توجه داشته باشید که 0.0 متناهی در نظر گرفته می‌شود.)

اضافه شده در نسخه‌ی 3.2.

math.isnormal(x)¶

اگر x یک عدد نرمال باشد، یعنی یک عدد متناهی غیرصفر که زیرنرمال نباشد (به issubnormal() مراجعه کنید)، True را برمی‌گرداند. در غیر این صورت False را برمی‌گرداند.

اضافه شده در نسخه‌ی 3.15.

math.issubnormal(x)¶

اگر x یک عدد زیرنرمال باشد، یعنی یک عدد متناهی غیرصفر با بزرگی کوچک‌تر از sys.float_info.min، True را برمی‌گرداند. در غیر این صورت False را برمی‌گرداند.

اضافه شده در نسخه‌ی 3.15.

math.isinf(x)¶

اگر x بی‌نهایت مثبت یا منفی باشد، True برمی‌گرداند و در غیر این صورت False برمی‌گرداند.

math.isnan(x)¶

اگر x یک NaN (نه یک عدد) باشد، True و در غیر این صورت False برمی‌گرداند.

math.ldexp(x, i)¶

مقدار x * (2**i) را برمی‌گرداند. این در اصل معکوس تابع frexp() است.

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

مقدار ممیز شناوری را برمی‌گرداند که steps گام بعد از x به سمت y قرار دارد.

اگر x برابر با y باشد، y را برمی‌گرداند، مگر اینکه steps صفر باشد.

مثال‌ها:

• math.nextafter(x, math.inf) به سمت بالا می‌رود: به سمت بی‌نهایت مثبت.

• math.nextafter(x, -math.inf) به سمت پایین می‌رود: به سوی منفی بی‌نهایت.

• math.nextafter(x, 0.0) به سمت صفر حرکت می‌کند.

• math.nextafter(x, math.copysign(math.inf, x)) از صفر دور می‌شود.

همچنین ببینید math.ulp().

اضافه شده در نسخه‌ی 3.9.

تغییر یافته در نسخه‌ی 3.12: آرگومان steps افزوده شد.

math.signbit(x)¶

اگر علامت x منفی باشد مقدار True و در غیر این صورت False را برمی‌گرداند.

این کار برای تشخیص بیت علامت اعداد صفر، بی‌نهایت‌ها و NaNها مفید است.

اضافه شده در نسخه‌ی 3.15.

math.ulp(x)¶

مقدار کم‌ارزش‌ترین بیت شناور x را برمی‌گرداند:

• اگر x یک NaN (عدد نامعتبر) باشد، x را برمی‌گرداند.

• اگر x منفی باشد، ulp(-x) را برمی‌گرداند.

• اگر x بی‌نهایت مثبت باشد، x را برمی‌گرداند.

• اگر x برابر با صفر باشد، کوچک‌ترین شناور مثبت غیرنرمال‌شده (denormalized) قابل‌بازنمایی را برمی‌گرداند (کوچک‌تر از کمینه شناور مثبت نرمال‌شده (normalized)، sys.float_info.min).

• اگر x برابر بزرگ‌ترین عدد اعشاری مثبت قابل نمایش باشد، مقدار کم‌ارزش‌ترین بیت x را برمی‌گرداند، به‌گونه‌ای که نخستین عدد اعشاری کوچک‌تر از x برابر x - ulp(x) باشد.

• در غیر این صورت (x یک عدد متناهی مثبت است)، مقدار کم‌ارزش‌ترین بیت x را برمی‌گرداند، به‌طوری که اولین عدد اعشاری بزرگ‌تر از x برابر x + ulp(x) باشد.

ULP مخفف «واحد در آخرین جایگاه» (Unit in the Last Place) است.

همچنین ببینید math.nextafter() و sys.float_info.epsilon.

اضافه شده در نسخه‌ی 3.9.

توابع توان، نمایی و لگاریتمی¶

math.cbrt(x)¶

ریشه سوم x را برمی‌گرداند.

اضافه شده در نسخه‌ی 3.11.

math.exp(x)¶

e به توان x را برمی‌گرداند، که در آن e = ۲٫۷۱۸۲۸۱... پایه‌ی لگاریتم طبیعی است. این معمولاً دقیق‌تر از math.e ** x یا pow(math.e, x) است.

math.exp2(x)¶

مقدار 2 به توان x را برمی‌گرداند.

اضافه شده در نسخه‌ی 3.11.

math.expm1(x)¶

e به توان x، منهای ۱ را برمی‌گرداند. در اینجا، e مبنای لگاریتم طبیعی است. برای مقادیر شناور کوچک x، تفریق در exp(x) - 1 می‌تواند منجر شود به از دست رفتن قابل‌توجه دقت; تابع expm1() راهی برای محاسبه این مقدار با دقت کامل فراهم می‌کند:

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

اضافه شده در نسخه‌ی 3.2.

math.log(x[, base])¶

با یک آرگومان، لگاریتم طبیعی x (در مبنای e) را برمی‌گرداند.

با دو آرگومان، لگاریتم x را در base داده‌شده برمی‌گرداند، که به‌صورت log(x)/log(base) محاسبه می‌شود.

math.log1p(x)¶

لگاریتم طبیعی 1+x (مبنای e) را برمی‌گرداند. نتیجه به شیوه‌ای محاسبه می‌شود که برای x نزدیک به صفر دقیق است.

math.log2(x)¶

لگاریتم x در مبنای ۲ را بازمی‌گرداند. این معمولاً از log(x, 2) دقیق‌تر است.

اضافه شده در نسخه‌ی 3.3.

همچنین ببینید

int.bit_length() تعداد بیت‌های لازم برای نمایش یک عدد صحیح در مبنای دو را، بدون احتساب علامت و صفرهای ابتدایی، برمی‌گرداند.

math.log10(x)¶

لگاریتم x در مبنای ۱۰ را برمی‌گرداند. این معمولاً دقیق‌تر از log(x, 10) است.

math.pow(x, y)¶

مقدار x به توان y را برمی‌گرداند. موارد استثنایی تا حد امکان از استاندارد IEEE 754 پیروی می‌کنند. به‌ویژه، pow(1.0, x) و pow(x, 0.0) همیشه 1.0 را برمی‌گردانند، حتی وقتی x صفر یا NaN باشد. اگر هر دو x و y متناهی باشند، x منفی باشد و y عدد صحیح نباشد، آنگاه pow(x, y) تعریف‌نشده است و ValueError را پرتاب می‌کند.

برخلاف عملگر توکار **، math.pow() هر دو آرگومان خود را به نوع float تبدیل می‌کند. برای محاسبه‌ی دقیق توان‌های عدد صحیح، از ** یا تابع توکار pow() استفاده کنید.

تغییر یافته در نسخه‌ی 3.11: برای سازگاری با IEEE 754، حالت‌های خاص pow(0.0, -inf) و pow(-0.0, -inf) تغییر داده شدند تا به‌جای پرتاب ValueError، inf را برگردانند.

math.sqrt(x)¶

ریشه دوم x را برمی‌گرداند.

توابع جمع‌بندی و حاصل‌ضرب¶

math.dist(p, q)¶

فاصله اقلیدسی بین دو نقطه p و q را برمی‌گرداند، که هر یک به‌صورت دنباله‌ای (یا پیمایش‌پذیری) از مختصات داده شده‌اند. دو نقطه باید بُعد یکسانی داشته باشند.

تقریباً معادل با:

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

اضافه شده در نسخه‌ی 3.8.

math.fsum(iterable)¶

مجموع دقیق ممیز شناور مقادیر موجود در پیمایش‌پذیر را برمی‌گرداند. با پیگیری چندین مجموع جزئی میانی، از کاهش دقت جلوگیری می‌کند.

دقت الگوریتم به تضمین‌های حساب IEEE-754 و حالت معمولی بستگی دارد که حالت گرد کردن آن نیمه‌زوج (half-even) است. در برخی ساخت‌های غیر ویندوزی، کتابخانه‌ی C زیربنایی از جمع با دقت گسترده استفاده می‌کند و ممکن است گاهی یک مجموع میانی را دو بار گرد کند که باعث می‌شود کم‌اهمیت‌ترین بیت آن نادرست باشد.

برای بحث بیشتر و دو رویکرد جایگزین، ASPN cookbook recipes for accurate floating-point summation.

math.hypot(*coordinates)¶

هنجار اقلیدسی را برمی‌گرداند، sqrt(sum(x**2 for x in coordinates)). این، طول بردار از مبدأ تا نقطه‌ای با مختصات داده‌شده است.

برای یک نقطه‌ی دوبعدی (x, y)، این معادل محاسبه‌ی وتر یک مثلث قائم‌الزاویه با استفاده از قضیه‌ی فیثاغورس است: sqrt(x*x + y*y).

تغییر یافته در نسخه‌ی 3.8: پشتیبانی از نقاط n-بعدی افزوده شد. پیش‌تر، تنها حالت دوبعدی پشتیبانی می‌شد.

تغییر یافته در نسخه‌ی 3.10: دقت الگوریتم بهبود یافت، به‌طوری که حداکثر خطا کمتر از ۱ ulp (واحد در آخرین جایگاه) است. در حالت معمول‌تر، نتیجه تقریباً همیشه به‌درستی با خطایی حداکثر ۱/۲ ulp گرد می‌شود.

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

حاصل‌ضرب تمام عناصر پیمایش‌پذیر ورودی را محاسبه می‌کند. مقدار پیش‌فرض start برای حاصل‌ضرب 1 است.

هنگامی که پیمایش‌پذیر خالی باشد، مقدار شروع برگردانده می‌شود. این تابع به‌طور خاص برای استفاده با مقادیر عددی در نظر گرفته شده است و ممکن است انواع غیرعددی را نپذیرد.

اضافه شده در نسخه‌ی 3.8.

math.sumprod(p, q)¶

مجموع حاصل‌ضرب مقادیر دو پیمایش‌پذیر p و q را برمی‌گرداند.

در صورتی که ورودی‌ها طول یکسانی نداشته باشند، ValueError پرتاب می‌شود.

تقریباً معادل با:

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

برای ورودی‌های اعشاری و ورودی‌های مختلط صحیح/اعشاری، حاصل‌ضرب‌ها و مجموع‌های میانی با دقت گسترده محاسبه می‌شوند.

اضافه شده در نسخه‌ی 3.12.

تبدیل زاویه‌ای¶

math.degrees(x)¶

زاویه‌ی x را از رادیان به درجه تبدیل می‌کند.

math.radians(x)¶

زاویه‌ی x را از درجه به رادیان تبدیل می‌کند.

توابع مثلثاتی¶

math.acos(x)¶

آرک‌کسینوس x را بر حسب رادیان برمی‌گرداند. نتیجه بین 0 و pi است.

math.asin(x)¶

آرک‌سینوس x را بر حسب رادیان بازمی‌گرداند. نتیجه بین -pi/2 و pi/2 است.

math.atan(x)¶

آرک‌تانژانت x را بر حسب رادیان برمی‌گرداند. نتیجه بین -pi/2 و pi/2 است.

math.atan2(y, x)¶

atan(y / x) را بر حسب رادیان برمی‌گرداند. نتیجه میان -pi و pi قرار دارد. بردار از مبدأ تا نقطه‌ی (x, y) در صفحه، این زاویه را با محور X مثبت می‌سازد. نکته‌ی atan2() این است که علامت‌های هر دو ورودی برای آن مشخص هستند، بنابراین می‌تواند ربع صحیح زاویه را محاسبه کند. برای مثال، atan(1) و atan2(1, 1) هر دو pi/4 هستند، اما atan2(-1, -1) برابر -3*pi/4 است.

math.cos(x)¶

کسینوس x بر حسب رادیان را برمی‌گرداند.

math.sin(x)¶

سینوس x بر حسب رادیان را برمی‌گرداند.

math.tan(x)¶

تانژانت x بر حسب رادیان را برمی‌گرداند.

توابع هذلولی¶

توابع هذلولی معادل‌هایی از توابع مثلثی هستند که به جای دایره‌ها، بر پایه هذلولی‌ها قرار دارند.

math.acosh(x)¶

کسینوس هذلولی معکوس x را برمی‌گرداند.

math.asinh(x)¶

سینوس هیپربولیک معکوس x را برمی‌گرداند.

math.atanh(x)¶

تانژانت هیپربولیک معکوس x را برمی‌گرداند.

math.cosh(x)¶

کسینوس هیپربولیک x را برمی‌گرداند.

math.sinh(x)¶

سینوس هیپربولیک x را برمی‌گرداند.

math.tanh(x)¶

تانژانت هذلولی x را برمی‌گرداند.

توابع ویژه¶

math.erf(x)¶

تابع خطا را در x برمی‌گرداند.

می‌توان از تابع erf() برای محاسبه‌ی توابع آماری مرسوم مانند توزیع تجمعی نرمال استاندارد استفاده کرد:

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

اضافه شده در نسخه‌ی 3.2.

math.erfc(x)¶

مقدار تابع خطای متمم را در x برمی‌گرداند. تابع خطای متمم به صورت 1.0 - erf(x) تعریف می‌شود. این تابع برای مقادیر بزرگ x استفاده می‌شود، جایی که تفریق از یک موجب از دست رفتن دقت (loss of significance) می‌شود.

اضافه شده در نسخه‌ی 3.2.

math.gamma(x)¶

تابع گاما را در x برمی‌گرداند.

اضافه شده در نسخه‌ی 3.2.

math.lgamma(x)¶

لگاریتم طبیعی قدر مطلق تابع گاما در x را برمی‌گرداند.

اضافه شده در نسخه‌ی 3.2.

توابع نظریه اعداد¶

برای سازگاری عقبگرد، ماژول math همچنین نام‌های مستعاری از توابع زیر از ماژول math.integer را فراهم می‌کند:

ثابت‌ها¶

math.pi¶

ثابت ریاضی π = ۳.۱۴۱۵۹۲...، تا دقت دردسترس.

math.e¶

ثابت ریاضی e = 2.718281...، تا دقت در دسترس.

math.tau¶

ثابت ریاضی τ = ۶.۲۸۳۱۸۵...، تا دقت در دسترس. تاو یک ثابت دایره برابر با ۲π است، نسبت محیط دایره به شعاع آن. برای آموختن بیشتر درباره‌ی تاو، ویدیوی Vi Hart با عنوان Pi is (still) Wrong را تماشا کنید و با خوردن دو برابر پای، جشن روز تاو را آغاز کنید!

اضافه شده در نسخه‌ی 3.6.

math.inf¶

بی‌نهایت مثبت از نوع ممیز شناور. (برای بی‌نهایت منفی، از -math.inf استفاده کنید.) معادل خروجی float('inf').

اضافه شده در نسخه‌ی 3.5.

math.nan¶

یک مقدار «غیرعدد» (NaN) از نوع ممیز شناور. معادل خروجی float('nan'). با توجه به الزامات استاندارد IEEE-754، math.nan و float('nan') برابر با هیچ مقدار عددی دیگری، از جمله خودشان، در نظر گرفته نمی‌شوند. برای بررسی اینکه آیا یک عدد NaN است یا نه، به جای is یا == از تابع isnan() برای آزمون NaN بودن استفاده کنید. مثال:

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

اضافه شده در نسخه‌ی 3.5.

تغییر یافته در نسخه‌ی 3.11: اکنون همواره در دسترس است.