math --- Hàm toán học

---

Mô-đun này cung cấp quyền truy cập vào các hàm và hằng số toán học phổ biến, bao gồm cả các hàm và hằng số được xác định theo tiêu chuẩn C.

Các hàm này không thể sử dụng được với số phức; sử dụng các hàm cùng tên từ mô-đun cmath nếu bạn yêu cầu hỗ trợ cho số phức. Sự khác biệt giữa các hàm hỗ trợ số phức và các hàm không hỗ trợ được tạo ra vì hầu hết người dùng không muốn học nhiều toán học như yêu cầu để hiểu số phức. Việc nhận được một ngoại lệ thay vì một kết quả phức tạp cho phép phát hiện sớm hơn số phức không mong muốn được sử dụng làm tham số, để lập trình viên có thể xác định cách thức và lý do nó được tạo ra ngay từ đầu.

Các chức năng sau đây được cung cấp bởi mô-đun này. Trừ khi có ghi chú rõ ràng khác, tất cả các giá trị trả về đều là số float.

Number-theoretic functions
comb(n, k)	Số cách chọn vật phẩm k từ vật phẩm n mà không lặp lại và không có thứ tự
factorial(n)	n giai thừa
gcd(*integers)	Ước chung lớn nhất của các đối số nguyên
isqrt(n)	Căn bậc hai số nguyên của số nguyên không âm n
lcm(*integers)	bội số chung nhỏ nhất của các đối số nguyên
perm(n, k)	Số cách chọn các mục k từ các mục n mà không lặp lại và theo thứ tự
Floating point arithmetic
ceil(x)	Trần x, số nguyên nhỏ nhất lớn hơn hoặc bằng x
fabs(x)	Giá trị tuyệt đối của x
floor(x)	Tầng của x, số nguyên lớn nhất nhỏ hơn hoặc bằng x
fma(x, y, z)	Hoạt động cộng nhân hợp nhất: (x * y) + z
fmod(x, y)	Số dư của phép chia x / y
modf(x)	Phần phân số và phần nguyên của x
remainder(x, y)	Phần dư của x đối với y
trunc(x)	Phần nguyên của x
Floating point manipulation functions
copysign(x, y)	Độ lớn (giá trị tuyệt đối) của x mang dấu y
frexp(x)	Mantissa và số mũ của x
isclose(a, b, rel_tol, abs_tol)	Kiểm tra xem các giá trị a và b có gần nhau không
isfinite(x)	Kiểm tra xem x không phải là vô cực hay NaN
isinf(x)	Kiểm tra xem x là vô cực dương hay âm
isnan(x)	Kiểm tra xem x có phải là NaN (không phải số)
ldexp(x, i)	x * (2**i), nghịch đảo của hàm frexp()
nextafter(x, y, steps)	Giá trị dấu phẩy động steps bước sau x về phía y
ulp(x)	Giá trị của bit ít quan trọng nhất của x
Power, exponential and logarithmic functions
cbrt(x)	Căn bậc ba của x
exp(x)	e được nâng lên sức mạnh x
exp2(x)	2 được nâng lên sức mạnh x
expm1(x)	e tăng lên lũy thừa x, trừ 1
log(x, base)	Logarit của x đến cơ số đã cho (e theo mặc định)
log1p(x)	Logarit tự nhiên của 1+x (cơ số e)
log2(x)	Logarit cơ số 2 của x
log10(x)	Logarit cơ số 10 của x
pow(x, y)	x được nâng lên sức mạnh y
sqrt(x)	Căn bậc hai của x
Summation and product functions
dist(p, q)	Khoảng cách Euclide giữa hai điểm p và q được cho dưới dạng tọa độ lặp lại
fsum(iterable)	Tổng các giá trị trong iterable đầu vào
hypot(*coordinates)	Định mức Euclide của tọa độ có thể lặp lại
prod(iterable, start)	Tích của các phần tử trong iterable đầu vào có giá trị start
sumprod(p, q)	Tổng sản phẩm từ hai lần lặp p và q
Angular conversion
degrees(x)	Chuyển đổi góc x từ radian sang độ
radians(x)	Chuyển đổi góc x từ độ sang radian
Trigonometric functions
acos(x)	Arc cosin của x
asin(x)	Cung sin của x
atan(x)	Tiếp tuyến của x
atan2(y, x)	atan(y / x)
cos(x)	Cosin của x
sin(x)	Sin của x
tan(x)	Tiếp tuyến của x
Hyperbolic functions
acosh(x)	cosin hyperbol nghịch đảo của x
asinh(x)	Sin hyperbol nghịch đảo của x
atanh(x)	Tang hyperbol nghịch đảo của x
cosh(x)	cosin hyperbol của x
sinh(x)	Sin hyperbol của x
tanh(x)	Tiếp tuyến hyperbol của x
Special functions
erf(x)	Error function và x
erfc(x)	Complementary error function và x
gamma(x)	Gamma function và x
lgamma(x)	Logarit tự nhiên của giá trị tuyệt đối của Gamma function tại x
Constants
pi	π = 3,141592...
e	e = 2,718281...
tau	τ = 2π = 6,283185...
inf	dương vô cùng
nan	"Không phải số" (NaN)

Hàm lý thuyết số

math.comb(n, k)

Trả về số cách chọn các mục k từ các mục n không lặp lại và không có thứ tự.

Đánh giá là n! / (k! * (n - k)!) khi k <= n và đánh giá bằng 0 khi k > n.

Còn được gọi là hệ số nhị thức vì nó tương đương với hệ số của số hạng thứ k trong khai triển đa thức (1 + x)ⁿ.

Tăng TypeError nếu một trong hai đối số không phải là số nguyên. Tăng ValueError nếu một trong hai đối số âm.

Added in version 3.8.

math.factorial(n)

Trả về giai thừa của số nguyên không âm n.

Thay đổi trong phiên bản 3.10: Các số float có giá trị nguyên (như 5.0) không còn được chấp nhận.

math.gcd(*integers)

Trả về ước số chung lớn nhất của các đối số nguyên đã chỉ định. Nếu bất kỳ đối số nào khác 0 thì giá trị trả về là số nguyên dương lớn nhất là ước số của tất cả các đối số. Nếu tất cả đối số bằng 0 thì giá trị trả về là 0. gcd() không có đối số trả về 0.

Added in version 3.5.

Thay đổi trong phiên bản 3.9: Đã thêm hỗ trợ cho số lượng đối số tùy ý. Trước đây, chỉ có hai đối số được hỗ trợ.

math.isqrt(n)

Trả về căn bậc hai số nguyên của số nguyên không âm n. Đây là tầng của căn bậc hai chính xác của n, hay tương đương là số nguyên lớn nhất a sao cho a² ≤ n.

Đối với một số ứng dụng, có thể thuận tiện hơn nếu có a số nguyên nhỏ nhất sao cho n ≤ a², hay nói cách khác là trần của căn bậc hai chính xác của n. Đối với n dương, điều này có thể được tính bằng a = 1 + isqrt(n - 1).

Added in version 3.8.

math.lcm(*integers)

Trả về bội số chung nhỏ nhất của các đối số nguyên đã chỉ định. Nếu tất cả các đối số khác 0 thì giá trị trả về là số nguyên dương nhỏ nhất là bội số của tất cả các đối số. Nếu bất kỳ đối số nào bằng 0 thì giá trị trả về là 0. lcm() không có đối số trả về 1.

Added in version 3.9.

math.perm(n, k=None)

Trả về số cách chọn các mục k từ các mục n không lặp lại và có thứ tự.

Đánh giá là n! / (n - k)! khi k <= n và đánh giá bằng 0 khi k > n.

Nếu k không được chỉ định hoặc là None thì k mặc định là n và hàm trả về n!.

Tăng TypeError nếu một trong hai đối số không phải là số nguyên. Tăng ValueError nếu một trong hai đối số âm.

Added in version 3.8.

Số học dấu phẩy động

math.ceil(x)

Trả về mức trần của x, số nguyên nhỏ nhất lớn hơn hoặc bằng x. Nếu x không phải là float, hãy ủy quyền cho x.__ceil__, giá trị này sẽ trả về giá trị Integral.

math.fabs(x)

Trả về giá trị tuyệt đối của x.

math.floor(x)

Trả về giá trị sàn của x, số nguyên lớn nhất nhỏ hơn hoặc bằng x. Nếu x không phải là float, hãy ủy quyền cho x.__floor__, giá trị này sẽ trả về giá trị Integral.

math.fma(x, y, z)

Hợp nhất hoạt động nhân-cộng. Trả về (x * y) + z, được tính toán với độ chính xác và phạm vi vô hạn, sau đó là một vòng duy nhất ở định dạng float. Thao tác này thường mang lại độ chính xác cao hơn biểu thức trực tiếp (x * y) + z.

Hàm này tuân theo đặc điểm kỹ thuật của thao tác fusedMultiplyAdd được mô tả trong tiêu chuẩn IEEE 754. Tiêu chuẩn để lại một trường hợp được xác định khi triển khai, cụ thể là kết quả của fma(0, inf, nan) và fma(inf, 0, nan). Trong những trường hợp này, math.fma trả về NaN và không đưa ra bất kỳ ngoại lệ nào.

Added in version 3.13.

math.fmod(x, y)

Trả về phần dư dấu phẩy động của x / y, như được xác định bởi hàm thư viện nền tảng C fmod(x, y). Lưu ý rằng biểu thức Python x % y có thể không trả về kết quả tương tự. Mục đích của tiêu chuẩn C là fmod(x, y) phải chính xác (về mặt toán học; với độ chính xác vô hạn) bằng x - n*y đối với một số số nguyên n sao cho kết quả có cùng dấu với x và cường độ nhỏ hơn abs(y). Thay vào đó, x % y của Python trả về kết quả có dấu y và có thể không tính toán chính xác cho các đối số float. Ví dụ: fmod(-1e-100, 1e100) là -1e-100, nhưng kết quả của -1e-100 % 1e100 của Python là 1e100-1e-100, không thể biểu diễn chính xác dưới dạng float và làm tròn thành 1e100 đáng ngạc nhiên. Vì lý do này, hàm fmod() thường được ưu tiên khi làm việc với số float, trong khi x % y của Python được ưu tiên hơn khi làm việc với số nguyên.

math.modf(x)

Trả về phần phân số và phần nguyên của x. Cả hai kết quả đều mang dấu x và là số float.

Lưu ý rằng modf() có mẫu gọi/trả về khác với mẫu tương đương C của nó: nó nhận một đối số duy nhất và trả về một cặp giá trị, thay vì trả về giá trị trả về thứ hai thông qua 'tham số đầu ra' (không có điều đó trong Python).

math.remainder(x, y)

Trả về phần còn lại kiểu IEEE 754 của x đối với y. Đối với x hữu hạn và y hữu hạn khác 0, đây là hiệu x - n*y, trong đó n là số nguyên gần nhất với giá trị chính xác của thương x / y. Nếu x / y nằm chính xác ở giữa hai số nguyên liên tiếp thì số nguyên even gần nhất sẽ được sử dụng cho n. Do đó, r = remainder(x, y) còn lại luôn thỏa mãn abs(r) <= 0.5 * abs(y).

Các trường hợp đặc biệt tuân theo IEEE 754: cụ thể, remainder(x, math.inf) là x đối với mọi x hữu hạn, và remainder(x, 0) và remainder(math.inf, x) tăng ValueError cho mọi x không phải NaN. Nếu kết quả của phép tính số dư bằng 0 thì số 0 đó sẽ có cùng dấu với x.

Trên các nền tảng sử dụng dấu phẩy động nhị phân IEEE 754, kết quả của thao tác này luôn thể hiện chính xác: không có lỗi làm tròn nào được đưa ra.

Added in version 3.7.

math.trunc(x)

Trả về x đã loại bỏ phần phân số, để lại phần nguyên. Điều này làm tròn về 0: trunc() tương đương với floor() đối với x dương và tương đương với ceil() đối với x âm. Nếu x không phải là float, hãy ủy quyền cho x.__trunc__, giá trị này sẽ trả về giá trị Integral.

Đối với các hàm ceil(), floor() và modf(), hãy lưu ý rằng các số dấu phẩy động all có độ lớn đủ lớn là số nguyên chính xác. Các float trong Python thường có độ chính xác không quá 53 bit (giống như loại kép của nền tảng C), trong trường hợp đó, bất kỳ float x nào với abs(x) >= 2**52 nhất thiết phải không có bit phân số.

Hàm thao tác dấu phẩy động

math.copysign(x, y)

Trả về một float có độ lớn (giá trị tuyệt đối) là x nhưng có dấu là y. Trên nền tảng hỗ trợ số 0 có dấu, copysign(1.0, -0.0) trả về -1.0.

math.frexp(x)

Trả về phần định trị và số mũ của x dưới dạng cặp (m, e). m là một số float và e là một số nguyên sao cho x == m * 2**e chính xác. Nếu x bằng 0, trả về (0.0, 0), nếu không thì trả về 0.5 <= abs(m) < 1. Điều này được sử dụng để "tách rời" biểu diễn bên trong của phao theo cách di động.

Lưu ý rằng frexp() có mẫu gọi/trả về khác với mẫu tương đương C của nó: nó nhận một đối số duy nhất và trả về một cặp giá trị, thay vì trả về giá trị trả về thứ hai thông qua 'tham số đầu ra' (không có điều đó trong Python).

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

Trả về True nếu các giá trị a và b gần nhau và False nếu ngược lại.

Việc hai giá trị có được coi là gần nhau hay không được xác định theo dung sai tuyệt đối và tương đối đã cho. Nếu không có lỗi xảy ra thì kết quả sẽ là: abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).

rel_tol là dung sai tương đối -- đó là chênh lệch tối đa được phép giữa a và b, so với giá trị tuyệt đối lớn hơn của a hoặc b. Ví dụ: để đặt dung sai 5%, hãy chuyển rel_tol=0.05. Dung sai mặc định là 1e-09, đảm bảo rằng hai giá trị giống nhau trong khoảng 9 chữ số thập phân. rel_tol phải không âm và nhỏ hơn 1.0.

abs_tol là dung sai tuyệt đối; nó mặc định là 0.0 và nó phải không âm. Khi so sánh x với 0.0, isclose(x, 0) được tính là abs(x) <= rel_tol  * abs(x), tức là False đối với mọi x khác 0 và rel_tol nhỏ hơn 1.0. Vì vậy, hãy thêm đối số abs_tol tích cực thích hợp vào cuộc gọi.

Các giá trị đặc biệt IEEE 754 của NaN, inf và -inf sẽ được xử lý theo quy tắc IEEE. Cụ thể, NaN không được coi là gần với bất kỳ giá trị nào khác, kể cả NaN. inf và -inf chỉ được coi là gần gũi với nhau.

Added in version 3.5.

Xem thêm

PEP 485 -- Một hàm để kiểm tra sự bằng nhau gần đúng

math.isfinite(x)

Trả về True nếu x không phải là vô cực cũng không phải NaN và False nếu ngược lại. (Lưu ý rằng 0.0 is được coi là hữu hạn.)

Added in version 3.2.

math.isinf(x)

Trả về True nếu x là vô cực dương hoặc âm, và False nếu ngược lại.

math.isnan(x)

Trả về True nếu x là NaN (không phải số) và False nếu ngược lại.

math.ldexp(x, i)

Trả về x * (2**i). Đây thực chất là nghịch đảo của hàm frexp().

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

Trả về giá trị dấu phẩy động steps các bước sau x về phía y.

Nếu x bằng y, trả về y, trừ khi steps bằng 0.

Ví dụ:

• math.nextafter(x, math.inf) đi lên: tiến về cực dương.

• math.nextafter(x, -math.inf) giảm dần: về phía âm vô cực.

• math.nextafter(x, 0.0) tiến về không.

• math.nextafter(x, math.copysign(math.inf, x)) biến mất khỏi con số 0.

Xem thêm math.ulp().

Added in version 3.9.

Thay đổi trong phiên bản 3.12: Đã thêm đối số steps.

math.ulp(x)

Trả về giá trị của bit ít quan trọng nhất của float x:

• Nếu x là NaN (không phải số), hãy trả về x.

• Nếu x âm, trả về ulp(-x).

• Nếu x là số dương vô cực, trả về x.

• Nếu x bằng 0, trả về số float dương nhỏ nhất có thể biểu thị denormalized (nhỏ hơn số float normalized dương tối thiểu, sys.float_info.min).

• Nếu x bằng số float có thể biểu thị dương lớn nhất, hãy trả về giá trị của bit có trọng số nhỏ nhất của x, sao cho số float đầu tiên nhỏ hơn x là x - ulp(x).

• Ngược lại (x là số hữu hạn dương), trả về giá trị của bit có trọng số nhỏ nhất của x, sao cho số float đầu tiên lớn hơn x là x + ulp(x).

ULP là viết tắt của "Đơn vị ở vị trí cuối cùng".

Xem thêm math.nextafter() và sys.float_info.epsilon.

Added in version 3.9.

Hàm lũy thừa, hàm mũ và hàm logarit

math.cbrt(x)

Trả về căn bậc ba của x.

Added in version 3.11.

math.exp(x)

Trả về e lũy thừa x, trong đó e = 2,718281... là cơ số của logarit tự nhiên. Điều này thường chính xác hơn math.e ** x hoặc pow(math.e, x).

math.exp2(x)

Trả về 2 được nâng lên lũy thừa x.

Added in version 3.11.

math.expm1(x)

Trả về e lũy thừa x, trừ 1. Ở đây e là cơ số của logarit tự nhiên. Đối với các số float nhỏ x, phép trừ trong exp(x) - 1 có thể dẫn đến significant loss of precision; hàm expm1() cung cấp một cách để tính toán đại lượng này với độ chính xác hoàn toàn:

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

Với một đối số, trả về logarit tự nhiên của x (theo cơ số e).

Với hai đối số, trả về logarit của x cho base đã cho, được tính bằng log(x)/log(base).

math.log1p(x)

Trả về logarit tự nhiên của 1+x (cơ số e). Kết quả được tính toán một cách chính xác cho x gần bằng 0.

math.log2(x)

Trả về logarit cơ số 2 của x. Điều này thường chính xác hơn log(x, 2).

Added in version 3.3.

Xem thêm

int.bit_length() trả về số bit cần thiết để biểu diễn một số nguyên ở dạng nhị phân, không bao gồm dấu và các số 0 đứng đầu.

math.log10(x)

Trả về logarit cơ số 10 của x. Điều này thường chính xác hơn log(x, 10).

math.pow(x, y)

Trả về x được nâng lên lũy thừa y. Các trường hợp đặc biệt tuân theo tiêu chuẩn IEEE 754 ở mức tối đa có thể. Đặc biệt, pow(1.0, x) và pow(x, 0.0) luôn trả về 1.0, ngay cả khi x bằng 0 hoặc NaN. Nếu cả x và y đều hữu hạn, x là số âm và y không phải là số nguyên thì pow(x, y) không được xác định và tăng ValueError.

Không giống như toán tử ** tích hợp sẵn, math.pow() chuyển đổi cả hai đối số của nó thành kiểu float. Sử dụng ** hoặc hàm pow() tích hợp để tính lũy thừa số nguyên chính xác.

Thay đổi trong phiên bản 3.11: Các trường hợp đặc biệt pow(0.0, -inf) và pow(-0.0, -inf) đã được thay đổi để trả về inf thay vì tăng ValueError, để thống nhất với IEEE 754.

math.sqrt(x)

Trả về căn bậc hai của x.

Tổng hợp và chức năng sản phẩm

math.dist(p, q)

Trả về khoảng cách Euclide giữa hai điểm p và q, mỗi điểm được cho dưới dạng một chuỗi (hoặc có thể lặp) tọa độ. Hai điểm phải có cùng chiều.

Gần tương đương với:

sqrt(sum((px - qx) ** 2.0 cho px, qx ở dạng zip(p, q)))

Added in version 3.8.

math.fsum(iterable)

Trả về tổng giá trị dấu phẩy động chính xác trong iterable. Tránh mất độ chính xác bằng cách theo dõi nhiều tổng riêng phần trung gian.

Độ chính xác của thuật toán phụ thuộc vào sự đảm bảo số học của IEEE-754 và trường hợp điển hình trong đó chế độ làm tròn là một nửa chẵn. Trên một số bản dựng không phải Windows, thư viện C cơ bản sử dụng phép cộng có độ chính xác mở rộng và đôi khi có thể làm tròn gấp đôi một tổng trung gian khiến tổng đó bị sai lệch ở bit ít quan trọng nhất.

Để thảo luận thêm và hai cách tiếp cận thay thế, hãy xem ASPN cookbook recipes for accurate floating-point summation.

math.hypot(*coordinates)

Trả về chuẩn Euclide, sqrt(sum(x**2 for x in coordinates)). Đây là độ dài của vectơ từ gốc đến điểm được cho bởi tọa độ.

Đối với điểm hai chiều (x, y), điều này tương đương với việc tính cạnh huyền của một tam giác vuông bằng định lý Pythagore, sqrt(x*x + y*y).

Thay đổi trong phiên bản 3.8: Đã thêm hỗ trợ cho các điểm n chiều. Trước đây chỉ hỗ trợ trường hợp hai chiều.

Thay đổi trong phiên bản 3.10: Cải thiện độ chính xác của thuật toán để sai số tối đa dưới 1 ulp (đơn vị ở vị trí cuối cùng). Thông thường hơn, kết quả hầu như luôn được làm tròn chính xác trong vòng 1/2 ulp.

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

Tính tích của tất cả các phần tử trong iterable đầu vào. Giá trị start mặc định cho sản phẩm là 1.

Khi iterable trống, trả về giá trị bắt đầu. Hàm này được thiết kế đặc biệt để sử dụng với các giá trị số và có thể từ chối các loại không phải số.

Added in version 3.8.

math.sumprod(p, q)

Trả về tổng các tích của các giá trị từ hai lần lặp p và q.

Tăng ValueError nếu đầu vào không có cùng độ dài.

Gần tương đương với:

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

Đối với đầu vào float và int/float hỗn hợp, các tích và tổng trung gian được tính toán với độ chính xác cao hơn.

Added in version 3.12.

Chuyển đổi góc

math.degrees(x)

Chuyển đổi góc x từ radian sang độ.

math.radians(x)

Chuyển đổi góc x từ độ sang radian.

Hàm lượng giác

math.acos(x)

Trả về cung cosin của x, tính bằng radian. Kết quả là giữa 0 và pi.

math.asin(x)

Trả về sin cung của x, tính bằng radian. Kết quả là giữa -pi/2 và pi/2.

math.atan(x)

Trả về tang tiếp tuyến của x, tính bằng radian. Kết quả là giữa -pi/2 và pi/2.

math.atan2(y, x)

Trả về atan(y / x), tính bằng radian. Kết quả là giữa -pi và pi. Vectơ trong mặt phẳng đi từ gốc đến điểm (x, y) tạo góc này với trục X dương. Điểm nổi bật của atan2() là dấu hiệu của cả hai đầu vào đều được biết đến, vì vậy nó có thể tính toán góc phần tư chính xác cho góc. Ví dụ: atan(1) và atan2(1, 1) đều là pi/4, nhưng atan2(-1, -1) là -3*pi/4.

math.cos(x)

Trả về cosin của x radian.

math.sin(x)

Trả về sin của x radian.

math.tan(x)

Trả về tang của radian x.

Hàm hyperbol

Hyperbolic functions là các hàm lượng giác tương tự dựa trên hyperbol thay vì vòng tròn.

math.acosh(x)

Trả về cosin hyperbol nghịch đảo của x.

math.asinh(x)

Trả về sin hyperbol nghịch đảo của x.

math.atanh(x)

Trả về tang hyperbol nghịch đảo của x.

math.cosh(x)

Trả về cosin hyperbol của x.

math.sinh(x)

Trả về sin hyperbol của x.

math.tanh(x)

Trả về tang hyperbol của x.

Chức năng đặc biệt

math.erf(x)

Trả lại error function tại x.

Hàm erf() có thể được sử dụng để tính toán các hàm thống kê truyền thống như cumulative standard normal distribution:

def phi(x):
    'Hàm phân phối tích lũy cho phân phối chuẩn chuẩn hóa'
    trả về (1.0 + erf(x / sqrt(2.0))) / 2.0

Added in version 3.2.

math.erfc(x)

Trả về hàm lỗi bổ sung tại x. Zz001zz được định nghĩa là 1.0 - erf(x). Nó được sử dụng cho các giá trị lớn của x trong đó phép trừ từ một sẽ gây ra loss of significance.

Added in version 3.2.

math.gamma(x)

Trả lại Gamma function tại x.

Added in version 3.2.

math.lgamma(x)

Trả về logarit tự nhiên của giá trị tuyệt đối của hàm Gamma tại x.

Added in version 3.2.

Hằng số

math.pi

Hằng số toán học π = 3,141592..., với độ chính xác sẵn có.

math.e

Hằng số toán học e = 2,718281..., với độ chính xác sẵn có.

math.tau

Hằng số toán học τ = 6,283185..., với độ chính xác sẵn có. Tau là hằng số đường tròn bằng 2π, tỷ lệ giữa chu vi và bán kính của đường tròn. Để tìm hiểu thêm về Tau, hãy xem video Pi is (still) Wrong của Vi Hart và bắt đầu ăn mừng Tau day bằng cách ăn số bánh nhiều gấp đôi!

Added in version 3.6.

math.inf

Một dấu phẩy động dương vô cực. (Đối với âm vô cực, hãy sử dụng -math.inf.) Tương đương với đầu ra của float('inf').

Added in version 3.5.

math.nan

Giá trị dấu phẩy động "không phải số" (NaN). Tương đương với đầu ra của float('nan'). Do các yêu cầu của IEEE-754 standard, math.nan và float('nan') không được coi là bằng bất kỳ giá trị số nào khác, kể cả chính chúng. Để kiểm tra xem một số có phải là NaN hay không, hãy sử dụng hàm isnan() để kiểm tra NaN thay vì is hoặc ==. Ví dụ:

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

Thay đổi trong phiên bản 3.11: Bây giờ nó luôn có sẵn.

Mô-đun math bao gồm hầu hết các trình bao bọc mỏng xung quanh các hàm thư viện toán học nền tảng C. Hành vi trong các trường hợp đặc biệt tuân theo Phụ lục F của tiêu chuẩn C99 khi thích hợp. Việc triển khai hiện tại sẽ tăng ValueError cho các hoạt động không hợp lệ như sqrt(-1.0) hoặc log(0.0) (trong đó C99 Phụ lục F khuyến nghị báo hiệu hoạt động không hợp lệ hoặc chia cho 0) và OverflowError cho các kết quả tràn (ví dụ: exp(1000.0)). NaN sẽ không được trả về từ bất kỳ hàm nào ở trên trừ khi một hoặc nhiều đối số đầu vào là NaN; trong trường hợp đó, hầu hết các hàm sẽ trả về NaN, nhưng (một lần nữa tuân theo C99 Phụ lục F) có một số trường hợp ngoại lệ đối với quy tắc này, ví dụ: pow(float('nan'), 0.0) hoặc hypot(float('nan'), float('inf')).

Lưu ý rằng Python không nỗ lực phân biệt NaN báo hiệu với NaN yên tĩnh và hành vi dành cho NaN báo hiệu vẫn chưa được chỉ định. Hành vi điển hình là đối xử với tất cả NaN như thể chúng im lặng.

Xem thêm

Mô-đun cmath

Phiên bản số phức của nhiều hàm này.