Mô-đun cung cấp hỗ trợ cho số học dấu phẩy động thập phân được làm tròn chính xác nhanh chóng. Nó cung cấp một số lợi thế so với kiểu dữ liệu
Số thập phân “dựa trên một mô hình dấu phẩy động được thiết kế có tính đến con người và nhất thiết phải có một nguyên tắc hướng dẫn tối quan trọng – máy tính phải cung cấp một phép tính số học hoạt động giống như phép tính số học mà mọi người học ở trường. ” – đoạn trích từ đặc tả số học thập phân
Số thập phân có thể được biểu diễn chính xác. Ngược lại, các số như
>>> Decimal["1e9999999999999999999"] Traceback [most recent call last]: File "", line 1, in decimal.InvalidOperation: []
7 và>>> Decimal["1e9999999999999999999"] Traceback [most recent call last]: File "", line 1, in decimal.InvalidOperation: []
8 không có biểu diễn chính xác ở dạng dấu phẩy động nhị phân. Người dùng cuối thường không mong đợi>>> Decimal["1e9999999999999999999"] Traceback [most recent call last]: File "", line 1, in decimal.InvalidOperation: []
9 hiển thị dưới dạng>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']
0 giống như với dấu phẩy động nhị phânTính chính xác chuyển sang số học. Trong dấu phẩy động thập phân,
>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']
1 chính xác bằng 0. Trong dấu phẩy động nhị phân, kết quả là>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']
2. Trong khi gần bằng 0, sự khác biệt ngăn cản thử nghiệm bình đẳng đáng tin cậy và sự khác biệt có thể tích lũy. Vì lý do này, số thập phân được ưa thích hơn trong các ứng dụng kế toán có bất biến đẳng thức nghiêm ngặtMô-đun thập phân kết hợp một khái niệm về các vị trí quan trọng sao cho
>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']
3 là>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']
4. Số 0 ở cuối được giữ để biểu thị tầm quan trọng. Đây là cách trình bày thông thường cho các ứng dụng tiền tệ. Đối với phép nhân, cách tiếp cận “sách giáo khoa” sử dụng tất cả các số liệu trong các bội số. Chẳng hạn,>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']
5 cho>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']
6 trong khi>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']
7 cho>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']
8Không giống như dấu phẩy động nhị phân dựa trên phần cứng, mô-đun thập phân có độ chính xác có thể thay đổi của người dùng [mặc định là 28 vị trí] có thể lớn đến mức cần thiết cho một vấn đề nhất định
>>> from decimal import * >>> getcontext[].prec = 6 >>> Decimal[1] / Decimal[7] Decimal['0.142857'] >>> getcontext[].prec = 28 >>> Decimal[1] / Decimal[7] Decimal['0.1428571428571428571428571429']
Cả dấu phẩy động nhị phân và thập phân đều được triển khai theo các tiêu chuẩn đã công bố. Trong khi kiểu float có sẵn chỉ thể hiện một phần khiêm tốn khả năng của nó, thì mô-đun thập phân thể hiện tất cả các phần bắt buộc của tiêu chuẩn. Khi cần, lập trình viên có toàn quyền kiểm soát việc làm tròn và xử lý tín hiệu. Điều này bao gồm một tùy chọn để thực thi số học chính xác bằng cách sử dụng các ngoại lệ để chặn bất kỳ hoạt động không chính xác nào
Mô-đun thập phân được thiết kế để hỗ trợ “không ảnh hưởng, cả số học thập phân không làm tròn chính xác [đôi khi được gọi là số học dấu phẩy động] và số học dấu phẩy động làm tròn. ” – đoạn trích từ đặc tả số học thập phân
Thiết kế mô-đun tập trung vào ba khái niệm. số thập phân, ngữ cảnh cho số học và tín hiệu
Một số thập phân là bất biến. Nó có dấu, chữ số hệ số và số mũ. Để duy trì ý nghĩa, các chữ số của hệ số không cắt bớt các số 0 ở cuối. Số thập phân cũng bao gồm các giá trị đặc biệt như
>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']9,
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']0 và
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1. Tiêu chuẩn cũng phân biệt giữa
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']2 với
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']3
Bối cảnh cho số học là môi trường chỉ định độ chính xác, quy tắc làm tròn, giới hạn số mũ, cờ biểu thị kết quả của phép toán và trình hỗ trợ bẫy xác định xem tín hiệu có được coi là ngoại lệ hay không. Các tùy chọn làm tròn bao gồm , , , , , , và
Tín hiệu là nhóm các điều kiện đặc biệt phát sinh trong quá trình tính toán. Tùy thuộc vào nhu cầu của ứng dụng, các tín hiệu có thể bị bỏ qua, được coi là thông tin hoặc được coi là ngoại lệ. Các tín hiệu trong mô-đun thập phân là. , , , , , , , và
Đối với mỗi tín hiệu, có một cờ và trình kích hoạt bẫy. Khi bắt gặp một tín hiệu, cờ của tín hiệu đó được đặt thành một, sau đó, nếu trình kích hoạt bẫy được đặt thành một, thì một ngoại lệ sẽ được đưa ra. Cờ dính, vì vậy người dùng cần đặt lại chúng trước khi theo dõi phép tính
Xem thêm
Đặc tả số học thập phân chung của IBM, Đặc tả số học thập phân chung
Hướng dẫn bắt đầu nhanh
Cách bắt đầu thông thường để sử dụng số thập phân là nhập mô-đun, xem ngữ cảnh hiện tại và, nếu cần, đặt các giá trị mới cho độ chính xác, làm tròn hoặc bật bẫy
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision
Các trường hợp thập phân có thể được xây dựng từ các số nguyên, chuỗi, số float hoặc bộ dữ liệu. Việc xây dựng từ một số nguyên hoặc số float thực hiện chuyển đổi chính xác giá trị của số nguyên hoặc số float đó. Số thập phân bao gồm các giá trị đặc biệt như
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1 viết tắt của “Không phải là số”, số dương và số âm
>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']9 và
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']2
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']
Nếu tín hiệu bị mắc kẹt, việc vô tình trộn số thập phân và số float trong hàm tạo hoặc so sánh thứ tự sẽ tạo ra một ngoại lệ
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True
Mới trong phiên bản 3. 3
Tầm quan trọng của Số thập phân mới chỉ được xác định bởi số lượng chữ số đầu vào. Độ chính xác của ngữ cảnh và làm tròn chỉ phát huy tác dụng trong các phép toán số học
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']
If the internal limits of the C version are exceeded, constructing a decimal raises
>>> Decimal["1e9999999999999999999"] Traceback [most recent call last]: File "", line 1, in decimal.InvalidOperation: []
Changed in version 3. 3
Decimals interact well with much of the rest of Python. Here is a small decimal floating point flying circus
>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']
Và một số hàm toán học cũng có sẵn cho Số thập phân
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']
The
>>> myothercontext = Context[prec=60, rounding=ROUND_HALF_DOWN] >>> setcontext[myothercontext] >>> Decimal[1] / Decimal[7] Decimal['0.142857142857142857142857142857142857142857142857142857142857'] >>> ExtendedContext Context[prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[]] >>> setcontext[ExtendedContext] >>> Decimal[1] / Decimal[7] Decimal['0.142857143'] >>> Decimal[42] / Decimal[0] Decimal['Infinity'] >>> setcontext[BasicContext] >>> Decimal[42] / Decimal[0] Traceback [most recent call last]: File "", line 1, in -toplevel- Decimal[42] / Decimal[0] DivisionByZero: x / 07 method rounds a number to a fixed exponent. This method is useful for monetary applications that often round results to a fixed number of places
>>> Decimal['7.325'].quantize[Decimal['.01'], rounding=ROUND_DOWN] Decimal['7.32'] >>> Decimal['7.325'].quantize[Decimal['1.'], rounding=ROUND_UP] Decimal['8']
As shown above, the function accesses the current context and allows the settings to be changed. This approach meets the needs of most applications
For more advanced work, it may be useful to create alternate contexts using the Context[] constructor. To make an alternate active, use the function
In accordance with the standard, the module provides two ready to use standard contexts, and . The former is especially useful for debugging because many of the traps are enabled
>>> myothercontext = Context[prec=60, rounding=ROUND_HALF_DOWN] >>> setcontext[myothercontext] >>> Decimal[1] / Decimal[7] Decimal['0.142857142857142857142857142857142857142857142857142857142857'] >>> ExtendedContext Context[prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[]] >>> setcontext[ExtendedContext] >>> Decimal[1] / Decimal[7] Decimal['0.142857143'] >>> Decimal[42] / Decimal[0] Decimal['Infinity'] >>> setcontext[BasicContext] >>> Decimal[42] / Decimal[0] Traceback [most recent call last]: File "", line 1, in -toplevel- Decimal[42] / Decimal[0] DivisionByZero: x / 0
Contexts also have signal flags for monitoring exceptional conditions encountered during computations. The flags remain set until explicitly cleared, so it is best to clear the flags before each set of monitored computations by using the
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision03 method
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision0
The flags entry shows that the rational approximation to
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision04 was rounded [digits beyond the context precision were thrown away] and that the result is inexact [some of the discarded digits were non-zero]
Individual traps are set using the dictionary in the
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision05 field of a context
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision1
Most programs adjust the current context only once, at the beginning of the program. And, in many applications, data is converted to with a single cast inside a loop. With context set and decimals created, the bulk of the program manipulates the data no differently than with other Python numeric types
Decimal objects
class decimal. Decimal[value='0' , context=None]Construct a new object based from value
value can be an integer, string, tuple, , or another object. If no value is given, returns
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision10. If value is a string, it should conform to the decimal numeric string syntax after leading and trailing whitespace characters, as well as underscores throughout, are removed
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision2
Other Unicode decimal digits are also permitted where
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision11 appears above. These include decimal digits from various other alphabets [for example, Arabic-Indic and Devanāgarī digits] along with the fullwidth digits
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision12 through
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision13
If value is a , it should have three components, a sign [
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision15 for positive or
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision16 for negative], a of digits, and an integer exponent. For example,
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision18 returns
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision19
If value is a , the binary floating point value is losslessly converted to its exact decimal equivalent. This conversion can often require 53 or more digits of precision. For example,
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision21 converts to
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision22
The context precision does not affect how many digits are stored. That is determined exclusively by the number of digits in value. For example,
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision23 records all five zeros even if the context precision is only three
The purpose of the context argument is determining what to do if value is a malformed string. If the context traps , an exception is raised; otherwise, the constructor returns a new Decimal with the value of
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1
Once constructed, objects are immutable
Changed in version 3. 2. The argument to the constructor is now permitted to be a instance.
Changed in version 3. 3. arguments raise an exception if the trap is set. By default the trap is off.
Changed in version 3. 6. Underscores are allowed for grouping, as with integral and floating-point literals in code.
Decimal floating point objects share many properties with the other built-in numeric types such as and . All of the usual math operations and special methods apply. Likewise, decimal objects can be copied, pickled, printed, used as dictionary keys, used as set elements, compared, sorted, and coerced to another type [such as or ]
There are some small differences between arithmetic on Decimal objects and arithmetic on integers and floats. When the remainder operator
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision34 is applied to Decimal objects, the sign of the result is the sign of the dividend rather than the sign of the divisor
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision3
The integer division operator
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision35 behaves analogously, returning the integer part of the true quotient [truncating towards zero] rather than its floor, so as to preserve the usual identity
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision36
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision4
The
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision34 and
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision35 operators implement the
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision39 and
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision40 operations [respectively] as described in the specification
Decimal objects cannot generally be combined with floats or instances of in arithmetic operations. an attempt to add a to a , for example, will raise a . However, it is possible to use Python’s comparison operators to compare a instance
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision46 with another number
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision47. Điều này tránh kết quả khó hiểu khi thực hiện so sánh bình đẳng giữa các số loại khác nhau
Changed in version 3. 2. Mixed-type comparisons between instances and other numeric types are now fully supported.
In addition to the standard numeric properties, decimal floating point objects also have a number of specialized methods
adjusted[]Return the adjusted exponent after shifting out the coefficient’s rightmost digits until only the lead digit remains.
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision49 returns seven. Used for determining the position of the most significant digit with respect to the decimal pointas_integer_ratio[]
Return a pair
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision50 of integers that represent the given instance as a fraction, in lowest terms and with a positive denominator
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision5
The conversion is exact. Raise OverflowError on infinities and ValueError on NaNs
New in version 3. 6
as_tuple[]Return a representation of the number.
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision52canonical[]
Return the canonical encoding of the argument. Currently, the encoding of a instance is always canonical, so this operation returns its argument unchanged
compare[other , context=None]Compare the values of two Decimal instances. returns a Decimal instance, and if either operand is a NaN then the result is a NaN
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision6so sánh_signal[khác , bối cảnh=None]
Hoạt động này giống hệt với phương pháp, ngoại trừ tất cả các tín hiệu NaN. Nghĩa là, nếu không có toán hạng nào là NaN báo hiệu thì bất kỳ toán hạng NaN yên tĩnh nào cũng được coi như thể đó là NaN báo hiệu
so_total[khác , bối cảnh=None]So sánh hai toán hạng bằng cách sử dụng biểu diễn trừu tượng của chúng thay vì giá trị số của chúng. Tương tự như phương pháp, nhưng kết quả cho tổng thứ tự trên các trường hợp. Hai trường hợp có cùng giá trị số nhưng cách biểu diễn khác nhau so sánh không bằng nhau theo thứ tự này
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision7
NaN yên tĩnh và báo hiệu cũng được bao gồm trong tổng số thứ tự. Kết quả của hàm này là
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision10 nếu cả hai toán hạng có cùng biểu diễn,
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision60 nếu toán hạng đầu tiên có tổng thứ tự thấp hơn toán hạng thứ hai và
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision61 nếu toán hạng thứ nhất có tổng thứ tự cao hơn toán hạng thứ hai. Xem thông số kỹ thuật để biết chi tiết về tổng số đơn đặt hàng
Hoạt động này không bị ảnh hưởng bởi ngữ cảnh và yên tĩnh. không có cờ nào được thay đổi và không có phép làm tròn nào được thực hiện. Là một ngoại lệ, phiên bản C có thể tăng InvalidOperation nếu toán hạng thứ hai không thể được chuyển đổi chính xác
so sánh_total_mag[khác , bối cảnh=None]So sánh hai toán hạng bằng cách sử dụng biểu diễn trừu tượng của chúng thay vì giá trị của chúng như trong , nhưng bỏ qua dấu của từng toán hạng.
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision63 tương đương với
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision64
Hoạt động này không bị ảnh hưởng bởi ngữ cảnh và yên tĩnh. không có cờ nào được thay đổi và không có phép làm tròn nào được thực hiện. Là một ngoại lệ, phiên bản C có thể tăng InvalidOperation nếu toán hạng thứ hai không thể được chuyển đổi chính xác
liên hợp[]Chỉ trả về self, phương thức này chỉ tuân theo Đặc tả thập phân
copy_abs[]Trả về giá trị tuyệt đối của đối số. Hoạt động này không bị ảnh hưởng bởi bối cảnh và yên tĩnh. không có cờ nào được thay đổi và không có phép làm tròn nào được thực hiện
copy_negate[]Trả về phủ định của đối số. Hoạt động này không bị ảnh hưởng bởi bối cảnh và yên tĩnh. không có cờ nào được thay đổi và không có phép làm tròn nào được thực hiện
copy_sign[khác , bối cảnh=None]Trả về một bản sao của toán hạng thứ nhất với dấu được đặt giống với dấu của toán hạng thứ hai. Ví dụ
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision8
Hoạt động này không bị ảnh hưởng bởi ngữ cảnh và yên tĩnh. không có cờ nào được thay đổi và không có phép làm tròn nào được thực hiện. Là một ngoại lệ, phiên bản C có thể tăng InvalidOperation nếu toán hạng thứ hai không thể được chuyển đổi chính xác
Trả về giá trị của hàm số mũ [tự nhiên]
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision65 tại số đã cho. Kết quả được làm tròn chính xác bằng cách sử dụng chế độ làm tròn
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision9classmethod from_float[f]
Hàm tạo thay thế chỉ chấp nhận các thể hiện của hoặc
Lưu ý
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision69 không giống với
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision70. kể từ 0. 1 không thể biểu diễn chính xác trong dấu phẩy động nhị phân, giá trị được lưu dưới dạng giá trị biểu diễn gần nhất là
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision71. Giá trị tương đương ở dạng thập phân là
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision72
Ghi chú
Từ Python 3. 2 trở đi, một thể hiện cũng có thể được xây dựng trực tiếp từ một
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']0
Mới trong phiên bản 3. 1
fma[khác , thứ ba, context=None]Hợp nhất nhân-thêm. Trả về self*other+thứ ba mà không làm tròn sản phẩm trung gian self*other
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']1is_canonical[]
Trả về nếu đối số là hợp quy và ngược lại. Hiện tại, một phiên bản luôn ở dạng chuẩn, vì vậy thao tác này luôn trả về
is_finite[]Trả về nếu đối số là một số hữu hạn và nếu đối số là vô hạn hoặc NaN
is_infinite[]Trả về nếu đối số là vô cực dương hoặc âm và ngược lại
is_nan[]Trả về nếu đối số là NaN [im lặng hoặc báo hiệu] và ngược lại
is_normal[bối cảnh=Không có]Trả về nếu đối số là một số hữu hạn bình thường. Trả về nếu đối số bằng 0, không bình thường, vô hạn hoặc NaN
is_qnan[]Trả về nếu đối số là một NaN yên tĩnh và ngược lại
is_signed[]Trả về nếu đối số có dấu âm và ngược lại. Lưu ý rằng cả số không và NaN đều có thể mang dấu
is_snan[]Trả về nếu đối số là NaN báo hiệu và ngược lại
is_subnormal[bối cảnh=Không có]Trả về nếu đối số không bình thường và ngược lại
is_zero[]Trả về nếu đối số là số 0 [dương hoặc âm] và ngược lại
ln[bối cảnh=Không có]Trả về logarit tự nhiên [cơ số e] của toán hạng. Kết quả được làm tròn chính xác bằng cách sử dụng chế độ làm tròn
log10[bối cảnh=Không có]Trả về logarit cơ số 10 của toán hạng. Kết quả được làm tròn chính xác bằng cách sử dụng chế độ làm tròn
logb[bối cảnh=Không có]Đối với một số khác 0, trả về số mũ đã điều chỉnh của toán hạng của nó làm ví dụ. Nếu toán hạng là số 0 thì hàm
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']00 được trả về và cờ được nâng lên. Nếu toán hạng là vô cùng thì trả về
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']02logic_and[khác , bối cảnh=None]
là một phép toán logic nhận hai toán hạng logic [xem ]. Kết quả là
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']04 chữ số của hai toán hạnglogic_invert[bối cảnh=Không có]
là một phép toán logic. Kết quả là nghịch đảo chữ số của toán hạng
logic_or[khác , bối cảnh=None]là một phép toán logic nhận hai toán hạng logic [xem ]. Kết quả là
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']07 chữ số của hai toán hạnglogic_xor[khác , bối cảnh=None]
là một phép toán logic nhận hai toán hạng logic [xem ]. Kết quả là loại trừ chữ số hoặc của hai toán hạng
tối đa[khác , bối cảnh=None]Giống như
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']09 ngoại trừ quy tắc làm tròn ngữ cảnh được áp dụng trước khi quay lại và các giá trị
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1 được báo hiệu hoặc bỏ qua [tùy thuộc vào ngữ cảnh và liệu chúng đang báo hiệu hay không]max_mag[khác , bối cảnh=None]
Tương tự như phương pháp, nhưng việc so sánh được thực hiện bằng cách sử dụng các giá trị tuyệt đối của toán hạng
phút[khác , bối cảnh=None]Giống như
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']12 ngoại trừ quy tắc làm tròn ngữ cảnh được áp dụng trước khi quay lại và các giá trị
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1 được báo hiệu hoặc bỏ qua [tùy thuộc vào ngữ cảnh và liệu chúng đang báo hiệu hay không]min_mag[khác , bối cảnh=None]
Tương tự như phương pháp, nhưng việc so sánh được thực hiện bằng cách sử dụng các giá trị tuyệt đối của toán hạng
next_minus[bối cảnh=Không có]Trả về số lớn nhất có thể biểu thị trong ngữ cảnh đã cho [hoặc trong ngữ cảnh của luồng hiện tại nếu không có ngữ cảnh nào được cung cấp] nhỏ hơn toán hạng đã cho
next_plus[bối cảnh=Không có]Trả về số nhỏ nhất có thể biểu diễn trong ngữ cảnh đã cho [hoặc trong ngữ cảnh của luồng hiện tại nếu không có ngữ cảnh nào được cung cấp] lớn hơn toán hạng đã cho
next_toward[khác , bối cảnh=None]Nếu hai toán hạng không bằng nhau, hãy trả về số gần toán hạng thứ nhất theo hướng của toán hạng thứ hai. Nếu cả hai toán hạng đều bằng nhau về số lượng, hãy trả về một bản sao của toán hạng đầu tiên với dấu được đặt giống với dấu của toán hạng thứ hai
chuẩn hóa[bối cảnh=Không có]Bình thường hóa số bằng cách loại bỏ các số 0 ở cuối bên phải và chuyển đổi bất kỳ kết quả nào bằng
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision10 thành
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']16. Được sử dụng để tạo ra các giá trị chuẩn cho các thuộc tính của một lớp tương đương. Ví dụ:
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']17 và
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']18 đều chuẩn hóa thành giá trị tương đương
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']19số_lớp[bối cảnh=Không có]
Trả về một chuỗi mô tả lớp của toán hạng. Giá trị trả về là một trong mười chuỗi sau
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']
20, chỉ ra rằng toán hạng là âm vô cùng>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']
21, chỉ ra rằng toán hạng là một số bình thường âm>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']
22, chỉ ra rằng toán hạng là âm và không bình thường>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']
23, cho biết toán hạng là số 0 âm>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']
24, cho biết toán hạng là số 0 dương>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']
25, chỉ ra rằng toán hạng là dương và không bình thường>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']
26, chỉ ra rằng toán hạng là một số bình thường dương>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']
27, chỉ ra rằng toán hạng là dương vô cùng>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']
28, chỉ ra rằng toán hạng là một NaN yên tĩnh [Không phải là một số]>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']
29, chỉ ra rằng toán hạng là một NaN báo hiệu
Trả về một giá trị bằng toán hạng đầu tiên sau khi làm tròn và có số mũ của toán hạng thứ hai
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']2
Không giống như các thao tác khác, nếu độ dài của hệ số sau thao tác lượng tử hóa lớn hơn độ chính xác, thì an được báo hiệu. Điều này đảm bảo rằng, trừ khi có điều kiện lỗi, số mũ được lượng tử hóa luôn bằng số mũ của toán hạng bên phải
Also unlike other operations, quantize never signals Underflow, even if the result is subnormal and inexact
Nếu số mũ của toán hạng thứ hai lớn hơn số mũ của toán hạng thứ nhất thì có thể cần phải làm tròn. Trong trường hợp này, chế độ làm tròn được xác định bởi đối số
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']31 nếu được đưa ra, ngược lại bởi đối số
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']32 đã cho;
Một lỗi được trả về bất cứ khi nào số mũ kết quả lớn hơn
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']33 hoặc nhỏ hơn
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']34cơ số[]
Trả về
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']35, cơ số [cơ số] mà lớp thực hiện tất cả các phép tính của nó. Bao gồm để tương thích với đặc điểm kỹ thuậtremainder_near[khác , bối cảnh=None]
Trả lại phần còn lại từ việc chia bản thân cho người khác. Điều này khác với
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']37 ở chỗ dấu của phần dư được chọn sao cho giá trị tuyệt đối của nó là nhỏ nhất. Chính xác hơn, giá trị trả về là
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']38 trong đó
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']39 là số nguyên gần nhất với giá trị chính xác của
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']40 và nếu hai số nguyên gần bằng nhau thì số chẵn được chọn
Nếu kết quả bằng không thì dấu của nó sẽ là dấu của tự
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']3xoay[khác , bối cảnh=None]
Trả về kết quả xoay các chữ số của toán hạng thứ nhất theo một lượng được chỉ định bởi toán hạng thứ hai. Toán hạng thứ hai phải là một số nguyên trong phạm vi -precision đến precision. Giá trị tuyệt đối của toán hạng thứ hai cho biết số vị trí cần xoay. Nếu toán hạng thứ hai là dương thì phép quay sang trái; . Hệ số của toán hạng đầu tiên được đệm ở bên trái với độ chính xác từ 0 đến độ dài nếu cần. Dấu và số mũ của toán hạng đầu tiên không thay đổi
same_quantum[other , bối cảnh=None]Kiểm tra xem bản thân và người khác có cùng số mũ hay cả hai đều là
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1
Hoạt động này không bị ảnh hưởng bởi ngữ cảnh và yên tĩnh. không có cờ nào được thay đổi và không có phép làm tròn nào được thực hiện. Là một ngoại lệ, phiên bản C có thể tăng InvalidOperation nếu toán hạng thứ hai không thể được chuyển đổi chính xác
scaleb[khác , bối cảnh=None]Trả về toán hạng đầu tiên với số mũ được điều chỉnh bởi toán hạng thứ hai. Tương tự, trả về toán hạng đầu tiên nhân với
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']42. Toán hạng thứ hai phải là một số nguyênchuyển[khác , bối cảnh=None]
Trả về kết quả của việc dịch chuyển các chữ số của toán hạng thứ nhất theo một lượng được chỉ định bởi toán hạng thứ hai. Toán hạng thứ hai phải là một số nguyên trong phạm vi -precision đến precision. Giá trị tuyệt đối của toán hạng thứ hai cho biết số lượng vị trí cần dịch chuyển. Nếu toán hạng thứ hai là số dương thì phép dịch chuyển sang trái; . Các chữ số được chuyển vào hệ số là số không. Dấu và số mũ của toán hạng đầu tiên không thay đổi
sqrt[bối cảnh=Không có]Trả lại căn bậc hai của đối số về độ chính xác đầy đủ
to_eng_string[bối cảnh=Không có]Chuyển đổi thành chuỗi, sử dụng ký hiệu kỹ thuật nếu cần số mũ
Ký hiệu kỹ thuật có số mũ là bội số của 3. Điều này có thể để lại tối đa 3 chữ số ở bên trái của vị trí thập phân và có thể yêu cầu thêm một hoặc hai số 0 ở cuối
Ví dụ: điều này chuyển đổi
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']43 thành
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']44to_integral[làm tròn=Không có, context=None]
Tương tự với phương pháp. Tên
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']46 đã được giữ để tương thích với các phiên bản cũ hơnto_integral_exact[làm tròn=Không có, context=None]
Làm tròn đến số nguyên gần nhất, báo hiệu hoặc nếu thích hợp nếu làm tròn xảy ra. Chế độ làm tròn được xác định bởi tham số
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']31 nếu được cung cấp, nếu không thì bởi
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']32 đã cho. Nếu không có tham số nào được cung cấp thì chế độ làm tròn của ngữ cảnh hiện tại được sử dụngto_integral_value[làm tròn=Không có, context=None]
Làm tròn đến số nguyên gần nhất mà không báo hiệu hoặc. Nếu được cung cấp, áp dụng làm tròn;
toán hạng logic
Các phương thức
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']03,
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']05,
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']06 và
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']08 mong đợi các đối số của chúng là toán hạng logic. Toán hạng logic là một thực thể có số mũ và dấu đều bằng 0 và có tất cả các chữ số là
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision15 hoặc
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision16
đối tượng ngữ cảnh
Bối cảnh là môi trường cho các hoạt động số học. Chúng chi phối độ chính xác, đặt quy tắc làm tròn, xác định tín hiệu nào được coi là ngoại lệ và giới hạn phạm vi cho số mũ
Mỗi luồng có bối cảnh hiện tại của riêng nó được truy cập hoặc thay đổi bằng cách sử dụng các chức năng và
thập phân. getcontext[]Trả về bối cảnh hiện tại cho chuỗi hoạt động
thập phân. setcontext[c]Đặt bối cảnh hiện tại cho chuỗi hoạt động thành c
Bạn cũng có thể sử dụng câu lệnh và hàm để tạm thời thay đổi ngữ cảnh hoạt động
thập phân. localcontext[ctx=None , \*\*kwargs]Trả về trình quản lý ngữ cảnh sẽ đặt ngữ cảnh hiện tại cho luồng đang hoạt động thành một bản sao của ctx khi vào câu lệnh with và khôi phục ngữ cảnh trước đó khi thoát khỏi câu lệnh with. Nếu không có ngữ cảnh nào được chỉ định, một bản sao của ngữ cảnh hiện tại sẽ được sử dụng. Đối số kwargs được sử dụng để đặt các thuộc tính của ngữ cảnh mới
Ví dụ: đoạn mã sau đặt độ chính xác thập phân hiện tại thành 42 vị trí, thực hiện phép tính và sau đó tự động khôi phục ngữ cảnh trước đó
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']4
Sử dụng các đối số từ khóa, mã sẽ như sau
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']5
Tăng nếu kwargs cung cấp thuộc tính không hỗ trợ. Tăng hoặc nếu kwargs cung cấp giá trị không hợp lệ cho một thuộc tính
Đã thay đổi trong phiên bản 3. 11. hiện hỗ trợ đặt thuộc tính ngữ cảnh thông qua việc sử dụng đối số từ khóa.
Các bối cảnh mới cũng có thể được tạo bằng cách sử dụng hàm tạo được mô tả bên dưới. Ngoài ra, mô-đun cung cấp ba bối cảnh được tạo sẵn
lớp thập phân. Bối cảnh cơ bảnĐây là ngữ cảnh tiêu chuẩn được xác định bởi Đặc tả số học thập phân chung. Độ chính xác được đặt thành chín. Làm tròn được đặt thành. Tất cả cờ bị xóa. Tất cả các bẫy được bật [được coi là ngoại lệ] ngoại trừ , và
Do nhiều bẫy được bật nên bối cảnh này rất hữu ích để gỡ lỗi
lớp thập phân. Ngữ cảnh mở rộngĐây là ngữ cảnh tiêu chuẩn được xác định bởi Đặc tả số học thập phân chung. Độ chính xác được đặt thành chín. Làm tròn được đặt thành. Tất cả cờ bị xóa. Không có bẫy nào được kích hoạt [để không phát sinh ngoại lệ trong quá trình tính toán]
Bởi vì các bẫy bị vô hiệu hóa, ngữ cảnh này hữu ích cho các ứng dụng muốn có giá trị kết quả là
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1 hoặc
>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']9 thay vì đưa ra các ngoại lệ. Điều này cho phép một ứng dụng hoàn thành một lần chạy khi có các điều kiện có thể làm dừng chương trìnhlớp thập phân. Ngữ cảnh mặc định
Bối cảnh này được nhà xây dựng sử dụng làm nguyên mẫu cho các bối cảnh mới. Thay đổi một trường [độ chính xác như vậy] có tác dụng thay đổi mặc định cho các ngữ cảnh mới được tạo bởi hàm tạo
Bối cảnh này hữu ích nhất trong môi trường đa luồng. Thay đổi một trong các trường trước khi chuỗi bắt đầu có tác dụng đặt giá trị mặc định trên toàn hệ thống. Không nên thay đổi các trường sau khi các luồng đã bắt đầu vì nó sẽ yêu cầu đồng bộ hóa luồng để ngăn các điều kiện tương tranh
Trong các môi trường luồng đơn, tốt nhất là không sử dụng ngữ cảnh này. Thay vào đó, chỉ cần tạo bối cảnh một cách rõ ràng như được mô tả bên dưới
Các giá trị mặc định là
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']79=______22_______80,
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']31=, và bật bẫy cho , , và
Ngoài ba ngữ cảnh được cung cấp, các ngữ cảnh mới có thể được tạo bằng hàm tạo
lớp thập phân. Bối cảnh[prec=Không có, rounding=None, Emin=None, Emax=None, capitals=None, clamp=None, flags=None, traps=None]Tạo bối cảnh mới. Nếu một trường không được chỉ định hoặc là, các giá trị mặc định được sao chép từ. Nếu trường cờ không được chỉ định hoặc là , tất cả các cờ sẽ bị xóa
prec là một số nguyên trong phạm vi [_______18_______16, ] đặt độ chính xác cho các phép toán số học trong ngữ cảnh
Tùy chọn làm tròn là một trong những hằng số được liệt kê trong phần
Các trường bẫy và cờ liệt kê mọi tín hiệu sẽ được đặt. Nói chung, bối cảnh mới chỉ nên đặt bẫy và để trống cờ
Các trường Emin và Emax là các số nguyên xác định các giới hạn bên ngoài cho phép đối với số mũ. Emin phải nằm trong khoảng [,
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision15], Emax trong khoảng [
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision15, ]
Trường chữ hoa là
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision15 hoặc
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision16 [mặc định]. Nếu được đặt thành
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision16, số mũ được in bằng chữ hoa ____22_______99; .
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True01
Trường kẹp là
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision15 [mặc định] hoặc
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision16. Nếu được đặt thành
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision16, số mũ
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True00 của một trường hợp có thể biểu thị trong ngữ cảnh này bị giới hạn nghiêm ngặt trong phạm vi
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True07. Nếu kẹp là
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision15 thì tình trạng yếu hơn sẽ xảy ra. số mũ đã điều chỉnh của phiên bản nhiều nhất là
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']33. Khi clamp là
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision16, một số bình thường lớn, nếu có thể, sẽ bị giảm số mũ và một số 0 tương ứng được thêm vào hệ số của nó, để phù hợp với các ràng buộc về số mũ; . Ví dụ
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']6
Giá trị kẹp của
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision16 cho phép tương thích với các định dạng trao đổi thập phân có chiều rộng cố định được chỉ định trong IEEE 754
Lớp này định nghĩa một số phương thức có mục đích chung cũng như một số lượng lớn các phương thức để thực hiện số học trực tiếp trong một ngữ cảnh nhất định. Ngoài ra, đối với mỗi phương pháp được mô tả ở trên [ngoại trừ phương pháp
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True15 và
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True16] đều có một phương pháp tương ứng. For example, for a instance
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True19 and instance
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision46,
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True22 is equivalent to
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True23. Mỗi phương thức chấp nhận một số nguyên Python [một thể hiện của ] ở bất kỳ đâu mà một thể hiện Thập phân được chấp nhậnclear_flags[]
Đặt lại tất cả các cờ thành
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision15clear_traps[]
Đặt lại tất cả các bẫy thành
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision15
Mới trong phiên bản 3. 3
bản sao[]Trả lại một bản sao của ngữ cảnh
copy_decimal[num]Trả về một bản sao của ví dụ thập phân num
create_decimal[num]Tạo một thể hiện Thập phân mới từ num nhưng sử dụng self làm ngữ cảnh. Không giống như hàm tạo, độ chính xác của ngữ cảnh, phương thức làm tròn, cờ và bẫy được áp dụng cho chuyển đổi
Điều này rất hữu ích vì các hằng số thường được cung cấp cho độ chính xác cao hơn mức cần thiết của ứng dụng. Một lợi ích khác là làm tròn ngay lập tức loại bỏ các hiệu ứng ngoài ý muốn từ các chữ số vượt quá độ chính xác hiện tại. Trong ví dụ sau, sử dụng đầu vào không được làm tròn có nghĩa là việc thêm 0 vào tổng có thể thay đổi kết quả
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']7
Phương pháp này thực hiện thao tác đánh số của đặc tả IBM. Nếu đối số là một chuỗi, không được phép có khoảng trắng ở đầu hoặc cuối hoặc dấu gạch dưới
create_decimal_from_float[f]Tạo một thể hiện Thập phân mới từ một float f nhưng làm tròn bằng cách sử dụng self làm ngữ cảnh. Không giống như phương thức lớp, độ chính xác của ngữ cảnh, phương thức làm tròn, cờ và bẫy được áp dụng cho chuyển đổi
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']8
Mới trong phiên bản 3. 1
Etiny[]Trả về giá trị bằng _______23_______30 là giá trị số mũ tối thiểu cho kết quả không bình thường. Khi tràn xảy ra, số mũ được đặt thành
Etop[]Trả về một giá trị bằng
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True32
Cách tiếp cận thông thường để làm việc với số thập phân là tạo các thể hiện và sau đó áp dụng các phép toán số học diễn ra trong ngữ cảnh hiện tại cho chuỗi hoạt động. Một cách tiếp cận khác là sử dụng các phương thức ngữ cảnh để tính toán trong một ngữ cảnh cụ thể. Các phương thức tương tự như các phương thức dành cho lớp và chỉ được kể lại ngắn gọn ở đây
abs[x]Trả về giá trị tuyệt đối của x
add[x , y]Trả về tổng của x và y
chính tắc[x]Trả về cùng một đối tượng thập phân x
so sánh[x , y]So sánh x và y bằng số
so sánh_signal[x , y]So sánh các giá trị của hai toán hạng bằng số
so_total[x , y]So sánh hai toán hạng sử dụng biểu diễn trừu tượng của chúng
so_total_mag[x , y]So sánh hai toán hạng bằng biểu diễn trừu tượng của chúng, bỏ qua dấu
copy_abs[x]Trả về một bản sao của x với dấu được đặt thành 0
copy_negate[x]Trả về một bản sao của x với dấu đảo ngược
copy_sign[x , y]Sao chép dấu từ y sang x
chia[x , y]Trả về x chia cho y
divide_int[x , y]Trả về x chia cho y, rút gọn thành một số nguyên
divmod[x , y]Chia hai số và trả về phần nguyên của kết quả
exp[x]Trả về
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True35fma[x , y, z]
Trả về x nhân với y, cộng với z
is_canonical[x]Trả về
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision75 nếu x là chính tắc; is_finite[x]
Trả về
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision75 nếu x hữu hạn; is_infinite[x]
Trả về
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision75 nếu x là vô hạn; is_nan[x]
Trả về
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision75 nếu x là qNaN hoặc sNaN; is_normal[x]
Trả về
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision75 nếu x là số bình thường; is_qnan[x]
Trả về
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision75 nếu x là NaN yên tĩnh; is_signed[x]
Trả về
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision75 nếu x âm; is_snan[x]
Trả về
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision75 nếu x là NaN báo hiệu; is_subnormal[x]
Returns
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision75 if x is subnormal; otherwise returns
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision76is_zero[x]
Trả về
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision75 nếu x là số không; ln[x]
Trả về logarit tự nhiên [cơ số e] của x
log10[x]Trả về logarit cơ số 10 của x
logb[x]Trả về số mũ của độ lớn MSD của toán hạng
logic_and[x , y]Áp dụng phép toán logic và giữa các chữ số của mỗi toán hạng
logic_invert[x]Đảo ngược tất cả các chữ số trong x
logic_or[x , y]Áp dụng phép toán logic hoặc giữa các chữ số của mỗi toán hạng
logic_xor[x , y]Áp dụng phép toán logic xor giữa các chữ số của mỗi toán hạng
max[x , y]So sánh hai giá trị bằng số và trả về giá trị lớn nhất
max_mag[x , y]So sánh các giá trị bằng số với dấu của chúng bị bỏ qua
phút[x , y]So sánh hai giá trị bằng số và trả về giá trị nhỏ nhất
min_mag[x , y]So sánh các giá trị bằng số với dấu của chúng bị bỏ qua
trừ[x]Dấu trừ tương ứng với toán tử trừ tiền tố một ngôi trong Python
nhân lên[x , y]Trả về tích của x và y
next_minus[x]Trả về số đại diện lớn nhất nhỏ hơn x
next_plus[x]Trả về số biểu diễn nhỏ nhất lớn hơn x
next_toward[x , y]Trả về số gần x nhất, theo hướng về phía y
chuẩn hóa[x]Rút gọn x về dạng đơn giản nhất
số_lớp[x]Trả về một dấu hiệu của lớp x
cộng[x]Plus tương ứng với toán tử cộng tiền tố một ngôi trong Python. Thao tác này áp dụng độ chính xác của ngữ cảnh và làm tròn, vì vậy đây không phải là thao tác nhận dạng
sức mạnh[x , y, modulo=None]Đưa
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision46 về lũy thừa của
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision47, rút gọn modulo
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True58 nếu đã cho
Với hai đối số, tính toán
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True59. Nếu
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision46 âm thì
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision47 phải nguyên. Kết quả sẽ không chính xác trừ khi
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision47 là tích phân và kết quả là hữu hạn và có thể được biểu thị chính xác bằng các chữ số 'chính xác'. Chế độ làm tròn của bối cảnh được sử dụng. Kết quả luôn được làm tròn chính xác trong phiên bản Python
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True63 dẫn đến
>>> Decimal['7.325'].quantize[Decimal['.01'], rounding=ROUND_DOWN] Decimal['7.32'] >>> Decimal['7.325'].quantize[Decimal['1.'], rounding=ROUND_UP] Decimal['8']3 và nếu
>>> Decimal['7.325'].quantize[Decimal['.01'], rounding=ROUND_DOWN] Decimal['7.32'] >>> Decimal['7.325'].quantize[Decimal['1.'], rounding=ROUND_UP] Decimal['8']3 không bị mắc kẹt, thì kết quả là
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True66
Đã thay đổi trong phiên bản 3. 3. Mô-đun C tính toán theo cách làm tròn chính xác và các hàm. Kết quả được xác định rõ nhưng chỉ "hầu như luôn được làm tròn chính xác".
Với ba đối số, tính toán
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True70. Đối với dạng ba đối số, các hạn chế sau đối với các đối số được giữ
cả ba đối số phải là tích phân
ít nhất một trong số
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision46 hoặc>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision47 phải khác không
Giá trị thu được từ
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True75 bằng với giá trị có thể thu được bằng cách tính toán
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True70 với độ chính xác không giới hạn, nhưng được tính toán hiệu quả hơn. Số mũ của kết quả bằng 0, bất kể số mũ của
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision46,
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision47 và
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True58. Kết quả luôn chính xácsố lượng hóa[x , y]
Trả về một giá trị bằng x [làm tròn], có số mũ là y
cơ số[]Chỉ trả về 10, vì đây là Số thập phân,. ]
phần còn lại[x , y]Trả về phần còn lại từ phép chia số nguyên
Dấu của kết quả, nếu khác không, giống như dấu của số bị chia ban đầu
remainder_near[x , y]Trả về
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True80, trong đó n là số nguyên gần giá trị chính xác nhất của
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True81 [nếu kết quả là 0 thì dấu của nó sẽ là dấu của x]xoay[x , y]
Trả về một bản sao được xoay x, y lần
same_quantum[x , y]Trả về
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision75 nếu hai toán hạng có cùng số mũscaleb[x , y]
Trả về toán hạng đầu tiên sau khi thêm giá trị thứ hai exp của nó
ca[x , y]Trả về một bản sao đã dịch chuyển của x, y lần
sqrt[x]Căn bậc hai của một số không âm với độ chính xác theo ngữ cảnh
trừ[x , y]Return the difference between x and y
to_eng_string[x]Chuyển đổi thành chuỗi, sử dụng ký hiệu kỹ thuật nếu cần số mũ
Ký hiệu kỹ thuật có số mũ là bội số của 3. Điều này có thể để lại tối đa 3 chữ số ở bên trái của vị trí thập phân và có thể yêu cầu thêm một hoặc hai số 0 ở cuối
to_integral_exact[x]Làm tròn thành một số nguyên
to_sci_string[x]Chuyển đổi một số thành một chuỗi bằng cách sử dụng ký hiệu khoa học
hằng số
Các hằng số trong phần này chỉ liên quan đến mô-đun C. Chúng cũng được bao gồm trong phiên bản Python thuần túy để tương thích
32-bit
64-bit
thập phân. MAX_PREC>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True83
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True84thập phân. MAX_EMAX
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True83
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True84thập phân. MIN_EMIN
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True87
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True88thập phân. MIN_ETINY
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True89
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True90thập phân. HAVE_THREADS
Giá trị là
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision75. Không dùng nữa, vì Python giờ đây luôn có chủ đề
Không dùng nữa kể từ phiên bản 3. 9
thập phân. HAVE_CONTEXTVARGiá trị mặc định là
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision75. Nếu Python là , thì phiên bản C sử dụng ngữ cảnh cục bộ luồng thay vì bối cảnh cục bộ coroutine và giá trị là
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision76. Điều này nhanh hơn một chút trong một số tình huống ngữ cảnh lồng nhau
Mới trong phiên bản 3. 9. đã nhập ngược về 3. 7 và 3. 8.
chế độ làm tròn
thập phân. ROUND_CEILINGVòng về phía
>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']9thập phân. ROUND_DOWN
Làm tròn về số không
thập phân. ROUND_FLOORVòng về phía
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']0thập phân. ROUND_HALF_DOWN
Làm tròn đến gần nhất với các mối quan hệ tiến về 0
thập phân. ROUND_HALF_EVENLàm tròn đến gần nhất với các mối quan hệ sẽ đến số nguyên chẵn gần nhất
thập phân. ROUND_HALF_UPLàm tròn đến gần nhất với các mối quan hệ đi từ số không
thập phân. ROUND_UPLàm tròn từ số 0
thập phân. ROUND_05UPLàm tròn từ 0 nếu chữ số cuối cùng sau khi làm tròn về 0 sẽ là 0 hoặc 5;
tín hiệu
Tín hiệu đại diện cho các điều kiện phát sinh trong quá trình tính toán. Mỗi cái tương ứng với một cờ ngữ cảnh và một trình kích hoạt bẫy ngữ cảnh
Cờ ngữ cảnh được đặt bất cứ khi nào gặp điều kiện. Sau khi tính toán, các cờ có thể được kiểm tra cho các mục đích thông tin [ví dụ: để xác định xem một phép tính có chính xác hay không]. Sau khi kiểm tra các cờ, đảm bảo xóa tất cả các cờ trước khi bắt đầu tính toán tiếp theo
Nếu trình kích hoạt bẫy của ngữ cảnh được đặt cho tín hiệu, thì điều kiện sẽ gây ra một ngoại lệ Python được đưa ra. Ví dụ: nếu bẫy được đặt, thì một ngoại lệ sẽ xuất hiện khi gặp điều kiện
lớp thập phân. Đã kẹpĐã thay đổi số mũ để phù hợp với các ràng buộc biểu diễn
Thông thường, hiện tượng kẹp xảy ra khi một số mũ nằm ngoài giới hạn
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True99 và
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']33 của ngữ cảnh. Nếu có thể, số mũ được giảm xuống cho phù hợp bằng cách thêm các số 0 vào hệ sốlớp thập phân. DecimalException
Lớp cơ sở cho các tín hiệu khác và một lớp con của
lớp thập phân. DivisionByZeroBáo hiệu phép chia một số không vô hạn cho 0
Có thể xảy ra với phép chia, phép chia modulo hoặc khi nâng một số lên lũy thừa âm. Nếu tín hiệu này không bị giữ lại, trả về
>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']9 hoặc
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']0 với dấu hiệu được xác định bởi đầu vào của phép tínhlớp thập phân. Không chính xác
Cho biết đã xảy ra làm tròn và kết quả không chính xác
Tín hiệu khi các chữ số khác 0 bị loại bỏ trong quá trình làm tròn. Kết quả làm tròn được trả về. Cờ hoặc bẫy tín hiệu được sử dụng để phát hiện khi kết quả không chính xác
lớp thập phân. Thao tác không hợp lệMột hoạt động không hợp lệ đã được thực hiện
Cho biết rằng một hoạt động được yêu cầu không có ý nghĩa. Nếu không bị mắc kẹt, trả về
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1. nguyên nhân có thể bao gồm
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']9lớp thập phân. Tràn
tràn số
Cho biết số mũ lớn hơn
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']33 sau khi làm tròn. Nếu không bị mắc kẹt, kết quả phụ thuộc vào chế độ làm tròn, kéo vào trong đến số hữu hạn có thể biểu diễn lớn nhất hoặc làm tròn ra ngoài thành
>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']9. Trong cả hai trường hợp, và cũng được báo hiệulớp thập phân. Làm tròn
Làm tròn xảy ra mặc dù có thể không có thông tin nào bị mất
Báo hiệu bất cứ khi nào làm tròn loại bỏ chữ số; . Nếu không bị mắc kẹt, trả về kết quả không thay đổi. Tín hiệu này được sử dụng để phát hiện mất chữ số có nghĩa
lớp thập phân. Không bình thườngSố mũ thấp hơn
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True99 trước khi làm tròn
Xảy ra khi kết quả hoạt động không bình thường [số mũ quá nhỏ]. Nếu không bị mắc kẹt, trả về kết quả không thay đổi
lớp thập phân. TrànDòng dưới số với kết quả được làm tròn thành 0
Xảy ra khi một kết quả không bình thường được đẩy về 0 bằng cách làm tròn. và cũng được báo hiệu
lớp thập phân. FloatOperationKích hoạt ngữ nghĩa chặt chẽ hơn để trộn số float và số thập phân
Nếu tín hiệu không bị bẫy [mặc định], thì cho phép trộn số float và Số thập phân trong hàm tạo và tất cả các toán tử so sánh. Cả chuyển đổi và so sánh đều chính xác. Bất kỳ sự xuất hiện nào của một hoạt động hỗn hợp đều được ghi lại một cách âm thầm bằng cách đặt trong các cờ ngữ cảnh. Chuyển đổi rõ ràng có hoặc không đặt cờ
Mặt khác [tín hiệu bị bẫy], chỉ có các phép so sánh đẳng thức và chuyển đổi rõ ràng là im lặng. Tất cả các hoạt động hỗn hợp khác tăng
Bảng dưới đây tóm tắt hệ thống phân cấp tín hiệu
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True0
Ghi chú dấu phẩy động
Giảm thiểu lỗi làm tròn với độ chính xác cao hơn
Việc sử dụng dấu phẩy động thập phân giúp loại bỏ lỗi biểu diễn thập phân [giúp có thể biểu diễn chính xác
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']20];
Ảnh hưởng của sai số làm tròn có thể được khuếch đại bằng cách cộng hoặc trừ các đại lượng gần như bù trừ dẫn đến mất ý nghĩa. Knuth cung cấp hai ví dụ hướng dẫn trong đó số học dấu phẩy động được làm tròn với độ chính xác không đủ gây ra sự phá vỡ các thuộc tính kết hợp và phân phối của phép cộng
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True1
Mô-đun cho phép khôi phục danh tính bằng cách mở rộng độ chính xác đủ để tránh mất ý nghĩa
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True2
Giá trị đặc biệt
Hệ thống số cho mô-đun cung cấp các giá trị đặc biệt bao gồm
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1,
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']24,
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']0,
>>> data = list[map[Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split[]]] >>> max[data] Decimal['9.25'] >>> min[data] Decimal['0.03'] >>> sorted[data] [Decimal['0.03'], Decimal['1.00'], Decimal['1.34'], Decimal['1.87'], Decimal['2.35'], Decimal['3.45'], Decimal['9.25']] >>> sum[data] Decimal['19.29'] >>> a,b,c = data[:3] >>> str[a] '1.34' >>> float[a] 1.34 >>> round[a, 1] Decimal['1.3'] >>> int[a] 1 >>> a * 5 Decimal['6.70'] >>> a * b Decimal['2.5058'] >>> c % a Decimal['0.77']9 và hai số không,
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']3 và
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']2
Vô cực có thể được xây dựng trực tiếp với.
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']02. Ngoài ra, chúng có thể phát sinh từ việc chia cho 0 khi tín hiệu không bị mắc kẹt. Tương tự như vậy, khi tín hiệu không bị mắc kẹt, vô cực có thể là kết quả của việc làm tròn vượt quá giới hạn của số lớn nhất có thể biểu thị
Các vô hạn được ký [affine] và có thể được sử dụng trong các phép tính số học khi chúng được coi là các số rất lớn, không xác định. Chẳng hạn, thêm một hằng số vào vô cùng sẽ cho một kết quả vô hạn khác
Một số hoạt động không xác định và trả về
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1 hoặc nếu tín hiệu bị kẹt, hãy đưa ra một ngoại lệ. Ví dụ:
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']34 trả về
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1 có nghĩa là “không phải là số”. Loại
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1 này không hoạt động và sau khi được tạo, sẽ chạy qua các tính toán khác và luôn dẫn đến một
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1 khác. Hành vi này có thể hữu ích đối với một loạt phép tính đôi khi thiếu đầu vào — nó cho phép phép tính tiếp tục trong khi gắn cờ các kết quả cụ thể là không hợp lệ
Một biến thể là
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']24 phát tín hiệu thay vì giữ im lặng sau mỗi lần vận hành. Đây là một giá trị trả về hữu ích khi một kết quả không hợp lệ cần làm gián đoạn phép tính để xử lý đặc biệt
Hành vi của các toán tử so sánh của Python có thể hơi ngạc nhiên khi có liên quan đến
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1. Một bài kiểm tra về sự bằng nhau khi một trong các toán hạng là một giá trị yên tĩnh hoặc có tín hiệu
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1 luôn trả về [ngay cả khi thực hiện
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']42], trong khi một bài kiểm tra về sự bất bình đẳng luôn trả về. Một nỗ lực để so sánh hai Số thập phân bằng cách sử dụng bất kỳ toán tử nào trong số các toán tử
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']44,
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']45,
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']46 hoặc
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']47 sẽ tăng tín hiệu nếu một trong hai toán hạng là
>>> getcontext[].prec = 28 >>> Decimal[2].sqrt[] Decimal['1.414213562373095048801688724'] >>> Decimal[1].exp[] Decimal['2.718281828459045235360287471'] >>> Decimal['10'].ln[] Decimal['2.302585092994045684017991455'] >>> Decimal['10'].log10[] Decimal['1']1 và trả về nếu tín hiệu này không bị mắc kẹt. Lưu ý rằng đặc tả số học thập phân chung không chỉ định hành vi so sánh trực tiếp; . 7]. Để đảm bảo tuân thủ các tiêu chuẩn nghiêm ngặt, hãy sử dụng các phương pháp
>>> from decimal import * >>> getcontext[] Context[prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero, InvalidOperation]] >>> getcontext[].prec = 7 # Set a new precision54 và
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']53 thay thế
Các số 0 có dấu có thể là kết quả của các phép tính nằm dưới. Họ giữ dấu hiệu sẽ có kết quả nếu phép tính được thực hiện với độ chính xác cao hơn. Vì độ lớn của chúng bằng 0 nên cả số 0 dương và âm đều được coi là bằng nhau và dấu của chúng là thông tin
Ngoài hai số 0 có dấu phân biệt nhưng bằng nhau, còn có nhiều cách biểu diễn khác nhau của số 0 với độ chính xác khác nhau nhưng có giá trị tương đương. Điều này cần một chút thời gian để làm quen. For an eye accustomed to normalized floating point representations, it is not immediately obvious that the following calculation returns a value equal to zero
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True3
Làm việc với chủ đề
Hàm truy cập một đối tượng khác nhau cho mỗi luồng. Có ngữ cảnh luồng riêng biệt có nghĩa là các luồng có thể thực hiện các thay đổi [chẳng hạn như
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']56] mà không can thiệp vào các luồng khác
Tương tự như vậy, chức năng tự động gán mục tiêu của nó cho luồng hiện tại
Nếu chưa được gọi trước đó, thì sẽ tự động tạo ngữ cảnh mới để sử dụng trong luồng hiện tại
Bối cảnh mới được sao chép từ bối cảnh nguyên mẫu có tên là DefaultContext. Để kiểm soát các giá trị mặc định sao cho mỗi luồng sẽ sử dụng các giá trị giống nhau trong toàn bộ ứng dụng, hãy sửa đổi trực tiếp đối tượng DefaultContext. Điều này nên được thực hiện trước khi bất kỳ luồng nào được bắt đầu để không xảy ra tình trạng chạy đua giữa các luồng đang gọi. Ví dụ
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True4
Công thức nấu ăn
Dưới đây là một số công thức đóng vai trò là các hàm tiện ích và minh họa các cách làm việc với lớp
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True5
Câu hỏi thường gặp về số thập phân
Q. Thật khó để gõ
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']63. Có cách nào để giảm thiểu việc nhập khi sử dụng trình thông dịch tương tác không?
A. Một số người dùng viết tắt hàm tạo chỉ bằng một chữ cái
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True6
Q. Trong một ứng dụng điểm cố định có hai chữ số thập phân, một số đầu vào có nhiều vị trí và cần được làm tròn. Những người khác không được phép có thừa chữ số và cần được xác thực. Những phương pháp nên được sử dụng?
A. Phương pháp
>>> myothercontext = Context[prec=60, rounding=ROUND_HALF_DOWN] >>> setcontext[myothercontext] >>> Decimal[1] / Decimal[7] Decimal['0.142857142857142857142857142857142857142857142857142857142857'] >>> ExtendedContext Context[prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[]] >>> setcontext[ExtendedContext] >>> Decimal[1] / Decimal[7] Decimal['0.142857143'] >>> Decimal[42] / Decimal[0] Decimal['Infinity'] >>> setcontext[BasicContext] >>> Decimal[42] / Decimal[0] Traceback [most recent call last]: File "", line 1, in -toplevel- Decimal[42] / Decimal[0] DivisionByZero: x / 07 làm tròn đến một số chữ số thập phân cố định. Nếu bẫy được đặt, nó cũng hữu ích cho việc xác thực
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True7
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True8
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True9
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']0
Q. Sau khi tôi có hai giá trị đầu vào hợp lệ, làm cách nào để duy trì giá trị bất biến đó trong toàn bộ ứng dụng?
A. Một số phép toán như cộng, trừ và nhân với một số nguyên sẽ tự động bảo toàn điểm cố định. Các hoạt động khác, như phép chia và phép nhân không nguyên, sẽ thay đổi số lượng chữ số thập phân và cần được theo dõi bằng bước
>>> myothercontext = Context[prec=60, rounding=ROUND_HALF_DOWN] >>> setcontext[myothercontext] >>> Decimal[1] / Decimal[7] Decimal['0.142857142857142857142857142857142857142857142857142857142857'] >>> ExtendedContext Context[prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[]] >>> setcontext[ExtendedContext] >>> Decimal[1] / Decimal[7] Decimal['0.142857143'] >>> Decimal[42] / Decimal[0] Decimal['Infinity'] >>> setcontext[BasicContext] >>> Decimal[42] / Decimal[0] Traceback [most recent call last]: File "", line 1, in -toplevel- Decimal[42] / Decimal[0] DivisionByZero: x / 07
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']1
Khi phát triển các ứng dụng điểm cố định, việc xác định các chức năng để xử lý bước
>>> myothercontext = Context[prec=60, rounding=ROUND_HALF_DOWN] >>> setcontext[myothercontext] >>> Decimal[1] / Decimal[7] Decimal['0.142857142857142857142857142857142857142857142857142857142857'] >>> ExtendedContext Context[prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[]] >>> setcontext[ExtendedContext] >>> Decimal[1] / Decimal[7] Decimal['0.142857143'] >>> Decimal[42] / Decimal[0] Decimal['Infinity'] >>> setcontext[BasicContext] >>> Decimal[42] / Decimal[0] Traceback [most recent call last]: File "", line 1, in -toplevel- Decimal[42] / Decimal[0] DivisionByZero: x / 07 sẽ thuận tiện
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']2
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']3
Q. Có nhiều cách để thể hiện cùng một giá trị. Các số
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']68,
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']69,
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']70 và
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']71 đều có cùng giá trị ở các độ chính xác khác nhau. Có cách nào để chuyển đổi chúng thành một giá trị chuẩn có thể nhận biết được không?
A. Phương pháp
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']72 ánh xạ tất cả các giá trị tương đương với một đại diện duy nhất
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']4
Q. Một số giá trị thập phân luôn in với ký hiệu số mũ. Có cách nào để có được một đại diện không theo cấp số nhân?
A. Đối với một số giá trị, ký hiệu hàm mũ là cách duy nhất để biểu thị số vị trí quan trọng trong hệ số. Ví dụ: biểu thị
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']73 thành
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']74 giữ giá trị không đổi nhưng không thể hiển thị ý nghĩa hai vị trí của bản gốc
Nếu một ứng dụng không quan tâm đến việc theo dõi ý nghĩa, có thể dễ dàng loại bỏ số mũ và số 0 ở cuối, làm mất ý nghĩa nhưng vẫn giữ nguyên giá trị
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']5
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']6
Q. Có cách nào để chuyển đổi số float thông thường thành số không?
A. Có, bất kỳ số dấu phẩy động nhị phân nào cũng có thể được biểu thị chính xác dưới dạng Số thập phân mặc dù một chuyển đổi chính xác có thể chính xác hơn so với trực giác sẽ đề xuất
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']7
Q. Trong một phép tính phức tạp, làm cách nào để đảm bảo rằng tôi không nhận được kết quả giả do không đủ độ chính xác hoặc làm tròn bất thường
A. Mô-đun thập phân giúp dễ dàng kiểm tra kết quả. Cách thực hành tốt nhất là chạy lại các phép tính bằng cách sử dụng độ chính xác cao hơn và với các chế độ làm tròn khác nhau. Các kết quả khác nhau nhiều cho thấy độ chính xác không đủ, các vấn đề về chế độ làm tròn, đầu vào không ổn định hoặc thuật toán không ổn định về mặt số
Q. Tôi nhận thấy rằng độ chính xác của ngữ cảnh được áp dụng cho kết quả của hoạt động nhưng không áp dụng cho đầu vào. Có điều gì cần chú ý khi trộn các giá trị của các độ chính xác khác nhau không?
A. Đúng. Nguyên tắc là tất cả các giá trị được coi là chính xác và số học trên các giá trị đó cũng vậy. Chỉ có kết quả được làm tròn. Ưu điểm của đầu vào là “những gì bạn nhập là những gì bạn nhận được”. Một nhược điểm là kết quả có thể trông kỳ quặc nếu bạn quên rằng đầu vào chưa được làm tròn
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']8
Giải pháp là tăng độ chính xác hoặc buộc làm tròn đầu vào bằng cách sử dụng phép toán cộng một ngôi
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']9
Ngoài ra, đầu vào có thể được làm tròn khi tạo bằng phương pháp
>>> Decimal["1e9999999999999999999"] Traceback [most recent call last]: File "", line 1, in decimal.InvalidOperation: []0
Q. Việc triển khai CPython có nhanh với số lượng lớn không?
A. Đúng. In the CPython and PyPy3 implementations, the C/CFFI versions of the decimal module integrate the high speed libmpdec library for arbitrary precision correctly rounded decimal floating point arithmetic .
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']77 sử dụng phép nhân Karatsuba cho các số cỡ trung bình và cho các số rất lớn
Bối cảnh phải được điều chỉnh cho số học chính xác tùy ý chính xác.
>>> c = getcontext[] >>> c.traps[FloatOperation] = True >>> Decimal[3.14] Traceback [most recent call last]: File "", line 1, in decimal.FloatOperation: [] >>> Decimal['3.5'] >> Decimal['3.5'] == 3.5 True99 và
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']33 phải luôn được đặt thành giá trị tối đa,
>>> getcontext[].prec = 6 >>> Decimal['3.0'] Decimal['3.0'] >>> Decimal['3.1415926535'] Decimal['3.1415926535'] >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85987'] >>> getcontext[].rounding = ROUND_UP >>> Decimal['3.1415926535'] + Decimal['2.7182818285'] Decimal['5.85988']80 phải luôn là 0 [mặc định]. Setting
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']79 requires some care
Cách tiếp cận đơn giản nhất để thử số học bignum là sử dụng giá trị lớn nhất cho cả
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']79
>>> Decimal["1e9999999999999999999"] Traceback [most recent call last]: File "", line 1, in decimal.InvalidOperation: []1
For inexact results, is far too large on 64-bit platforms and the available memory will be insufficient
>>> Decimal["1e9999999999999999999"] Traceback [most recent call last]: File "", line 1, in decimal.InvalidOperation: []2
On systems with overallocation [e. g. Linux], a more sophisticated approach is to adjust
>>> getcontext[].prec = 28 >>> Decimal[10] Decimal['10'] >>> Decimal['3.14'] Decimal['3.14'] >>> Decimal[3.14] Decimal['3.140000000000000124344978758017532527446746826171875'] >>> Decimal[[0, [3, 1, 4], -2]] Decimal['3.14'] >>> Decimal[str[2.0 ** 0.5]] Decimal['1.4142135623730951'] >>> Decimal[2] ** Decimal['0.5'] Decimal['1.414213562373095048801688724'] >>> Decimal['NaN'] Decimal['NaN'] >>> Decimal['-Infinity'] Decimal['-Infinity']79 to the amount of available RAM. Suppose that you have 8GB of RAM and expect 10 simultaneous operands using a maximum of 500MB each
>>> Decimal["1e9999999999999999999"] Traceback [most recent call last]: File "", line 1, in decimal.InvalidOperation: []3
Nói chung [và đặc biệt là trên các hệ thống không có phân bổ quá mức], nên ước tính các giới hạn chặt chẽ hơn nữa và đặt bẫy nếu tất cả các tính toán được mong đợi là chính xác