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ế dành cho 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 được 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']
Nếu vượt quá giới hạn nội bộ của phiên bản C, việc xây dựng số thập phân sẽ tăng
>>> 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']
And some mathematical functions are also available to Decimal
>>> 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
Hầu hết các chương trình chỉ điều chỉnh bối cảnh hiện tại một lần, khi bắt đầu chương trình. Và, trong nhiều ứng dụng, dữ liệu được chuyển đổi thành một lần truyền bên trong một vòng lặp. Với tập ngữ cảnh và số thập phân được tạo, phần lớn chương trình thao tác dữ liệu không khác gì với các loại số Python khác
đối tượng thập phân
lớp thập phân. Số thập phân[giá trị=', context=None]Xây dựng một đối tượng mới dựa trên giá trị
giá trị có thể là một số nguyên, chuỗi, tuple, hoặc một đối tượng khác. Nếu không có giá trị nào được đưa ra, 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 precision10. Nếu giá trị là một chuỗi, thì giá trị đó phải tuân theo cú pháp chuỗi số thập phân sau khi các ký tự khoảng trắng ở đầu và cuối, cũng như dấu gạch dưới trong suốt, được xó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 precision2
Các chữ số thập phân Unicode khác cũng được cho phép 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 precision11 xuất hiện ở trên. Chúng bao gồm các chữ số thập phân từ nhiều bảng chữ cái khác [ví dụ: chữ số Ả Rập-Ấn Độ và Devanāgarī] cùng với các chữ số có độ rộng đầy đủ từ
>>> 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 đế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 precision13
Nếu giá trị là a , thì giá trị đó phải có ba thành phần, một dấu [_______18_______15 cho số dương 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 cho số âm], một chữ số và một số mũ nguyên. 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 precision18 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 precision19
Nếu giá trị là a , thì giá trị dấu phẩy động nhị phân được chuyển đổi dễ dàng thành số thập phân tương đương chính xác của nó. Chuyển đổi này thường có thể yêu cầu độ chính xác từ 53 chữ số trở lên. 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 precision21 chuyển đổi 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 precision22
Độ chính xác của ngữ cảnh không ảnh hưởng đến số lượng chữ số được lưu trữ. Điều đó được xác định độc quyền bởi số chữ số trong giá trị. 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 precision23 ghi tất cả năm số không ngay cả khi độ chính xác của ngữ cảnh chỉ là ba
Mục đích của đối số ngữ cảnh là xác định phải làm gì nếu giá trị là một chuỗi không đúng định dạng. Nếu bẫy bối cảnh, một ngoại lệ được đưa ra;
Sau khi được xây dựng, các đối tượng là bất biến
Đã thay đổi trong phiên bản 3. 2. Đối số của hàm tạo hiện được phép là một thể hiện.
Đã thay đổi trong phiên bản 3. 3. các đối số đưa ra một ngoại lệ nếu bẫy được đặt. Theo mặc định bẫy tắt.
Đã thay đổi trong phiên bản 3. 6. Dấu gạch dưới được cho phép để nhóm, như với các ký tự dấu phẩy động và tích phân trong mã.
Các đối tượng dấu chấm động thập phân chia sẻ nhiều thuộc tính với các kiểu số dựng sẵn khác như và. Tất cả các phép toán thông thường và các phương pháp đặc biệt được áp dụng. Tương tự như vậy, các đối tượng thập phân có thể được sao chép, chọn, in, sử dụng làm khóa từ điển, được sử dụng làm phần tử tập hợp, so sánh, sắp xếp và ép buộc sang loại khác [chẳng hạn như hoặc ]
Có một số khác biệt nhỏ giữa số học trên các đối tượng thập phân và số học trên số nguyên và số float. Khi toán tử còn lạ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 precision34 được áp dụng cho các đối tượng Số thập phân, dấu của kết quả là dấu của số bị chia chứ không phải là dấu của số chia
>>> 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
Toán tử chia số nguyê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 precision35 hoạt động tương tự, trả về phần nguyên của thương số thực [cắt ngắn về 0] thay vì giá trị sàn của nó, để giữ nguyên giá trị thông thườ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 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
Các toán tử
>>> 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 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 precision35 thực hiện các phép toá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 precision39 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 precision40 [tương ứng] như được mô tả trong đặc tả
Các đối tượng thập phân thường không thể được kết hợp với số float hoặc thể hiện của trong các phép toán số học. một nỗ lực để thêm một vào một, ví dụ, sẽ nâng cao một. Tuy nhiên, có thể sử dụng các toán tử so sánh của Python để so sánh một thể hiệ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 precision46 với một số khá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. Đ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
Đã thay đổi trong phiên bản 3. 2. So sánh kiểu hỗn hợp giữa các phiên bản và các kiểu số khác hiện được hỗ trợ đầy đủ.
Ngoài các thuộc tính số tiêu chuẩn, các đối tượng dấu phẩy động thập phân còn có một số phương thức chuyên biệt
đã điều chỉnh[]Trả về số mũ đã điều chỉnh sau khi dịch chuyển các chữ số ngoài cùng bên phải của hệ số cho đến khi chỉ còn lại chữ số dẫ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 precision49 trả về bảy. Được sử dụng để xác định vị trí của chữ số có nghĩa nhất đối với dấu thập phânas_integer_ratio[]
Trả về một cặ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 precision50 số nguyên đại diện cho trường hợp đã cho dưới dạng phân số, ở dạng nhỏ nhất và có mẫu số dươ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 precision5
Việc chuyển đổi là chính xác. Tăng OverflowError trên vô số và ValueError trên NaN
Mới trong phiên bản 3. 6
as_tuple[]Trả về một đại diện của 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 precision52chính tắc[]
Trả lại mã hóa chính tắc của đối số. Hiện tại, mã hóa của một phiên bản luôn ở dạng chuẩn, vì vậy thao tác này trả về đối số của nó không thay đổi
so sánh[khác , bối cảnh=None]So sánh các giá trị của hai trường hợp thập phân. trả về một thể hiện Thập phân và nếu một trong hai toán hạng là NaN thì kết quả là 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à 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 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] 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
Ngoài ra, không giống như các hoạt động khác, lượng tử hóa không bao giờ báo hiệu Underflow, ngay cả khi kết quả là không bình thường và không chính xác
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. Ví dụ: đối với phiên bả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 True19 và phiên bả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 precision46, thì
>>> 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 tương đương vớ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 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 đến 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]
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 không bình thường; is_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 nhất với giá trị chính xác 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]Trả về sự khác biệt giữa x và 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. Each corresponds to one context flag and one context trap enabler
The context flag is set whenever the condition is encountered. 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
Typically, clamping occurs when an exponent falls outside the context’s
>>> 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 and
>>> 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 limits. 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
class decimal. DivisionByZeroSignals the division of a non-infinite number by zero
Can occur with division, modulo division, or when raising a number to a negative power. If this signal is not trapped, returns
>>> 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 or
>>> 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 with the sign determined by the inputs to the calculationclass decimal. Inexact
Indicates that rounding occurred and the result is not exact
Signals when non-zero digits were discarded during rounding. The rounded result is returned. The signal flag or trap is used to detect when results are inexact
class decimal. InvalidOperationAn invalid operation was performed
Indicates that an operation was requested that does not make sense. If not trapped, returns
>>> 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. Possible causes include
>>> 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']9class decimal. Overflow
Numerical overflow
Indicates the exponent is larger than
>>> 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 after rounding has occurred. If not trapped, the result depends on the rounding mode, either pulling inward to the largest representable finite number or rounding outward to
>>> 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. In either case, and are also signaledclass decimal. Rounded
Rounding occurred though possibly no information was lost
Signaled whenever rounding discards digits; even if those digits are zero [such as rounding
>>> 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']09 to
>>> 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']10]. If not trapped, returns the result unchanged. This signal is used to detect loss of significant digitsclass decimal. Subnormal
Exponent was lower than
>>> 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 prior to rounding
Occurs when an operation result is subnormal [the exponent is too small]. If not trapped, returns the result unchanged
class decimal. UnderflowNumerical underflow with result rounded to zero
Occurs when a subnormal result is pushed to zero by rounding. and are also signaled
class decimal. FloatOperationEnable stricter semantics for mixing floats and Decimals
If the signal is not trapped [default], mixing floats and Decimals is permitted in the constructor, and all comparison operators. Both conversion and comparisons are exact. Any occurrence of a mixed operation is silently recorded by setting in the context flags. Explicit conversions with or do not set the flag
Otherwise [the signal is trapped], only equality comparisons and explicit conversions are silent. All other mixed operations raise
The following table summarizes the hierarchy of signals
>>> 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
Floating Point Notes
Mitigating round-off error with increased precision
The use of decimal floating point eliminates decimal representation error [making it possible to represent
>>> 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 exactly]; however, some operations can still incur round-off error when non-zero digits exceed the fixed precision
The effects of round-off error can be amplified by the addition or subtraction of nearly offsetting quantities resulting in loss of significance. Knuth provides two instructive examples where rounded floating point arithmetic with insufficient precision causes the breakdown of the associative and distributive properties of addition
>>> 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
The module makes it possible to restore the identities by expanding the precision sufficiently to avoid loss of significance
>>> 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
Special values
The number system for the module provides special values including
>>> 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, and two zeros,
>>> 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 and
>>> 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
Infinities can be constructed directly with.
>>> 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. Also, they can arise from dividing by zero when the signal is not trapped. Likewise, when the signal is not trapped, infinity can result from rounding beyond the limits of the largest representable number
The infinities are signed [affine] and can be used in arithmetic operations where they get treated as very large, indeterminate numbers. For instance, adding a constant to infinity gives another infinite result
Some operations are indeterminate and return
>>> 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, or if the signal is trapped, raise an exception. For example,
>>> 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 returns
>>> 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 which means “not a number”. This variety 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 is quiet and, once created, will flow through other computations always resulting in another
>>> 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. This behavior can be useful for a series of computations that occasionally have missing inputs — it allows the calculation to proceed while flagging specific results as invalid
A variant is
>>> 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 which signals rather than remaining quiet after every operation. This is a useful return value when an invalid result needs to interrupt a calculation for special handling
The behavior of Python’s comparison operators can be a little surprising where 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']1 is involved. A test for equality where one of the operands is a quiet or signaling
>>> 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 always returns [even when doing
>>> 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], while a test for inequality always returns . An attempt to compare two Decimals using any of the
>>> 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 or
>>> 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 operators will raise the signal if either operand is 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']1, and return if this signal is not trapped. Note that the General Decimal Arithmetic specification does not specify the behavior of direct comparisons; these rules for comparisons involving 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']1 were taken from the IEEE 854 standard [see Table 3 in section 5. 7]. To ensure strict standards-compliance, use 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 precision54 and
>>> 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 methods instead
The signed zeros can result from calculations that underflow. They keep the sign that would have resulted if the calculation had been carried out to greater precision. Since their magnitude is zero, both positive and negative zeros are treated as equal and their sign is informational
In addition to the two signed zeros which are distinct yet equal, there are various representations of zero with differing precisions yet equivalent in value. This takes a bit of getting used to. 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
Working with threads
The function accesses a different object for each thread. Having separate thread contexts means that threads may make changes [such as
>>> 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] without interfering with other threads
Likewise, the function automatically assigns its target to the current thread
If has not been called before , then will automatically create a new context for use in the current thread
The new context is copied from a prototype context called DefaultContext. To control the defaults so that each thread will use the same values throughout the application, directly modify the DefaultContext object. This should be done before any threads are started so that there won’t be a race condition between threads calling . For example
>>> 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
Recipes
Here are a few recipes that serve as utility functions and that demonstrate ways to work with the class
>>> 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
Decimal FAQ
Q. It is cumbersome to type
>>> 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. Is there a way to minimize typing when using the interactive interpreter?
A. Some users abbreviate the constructor to just a single letter
>>> 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. In a fixed-point application with two decimal places, some inputs have many places and need to be rounded. Others are not supposed to have excess digits and need to be validated. What methods should be used?
A. 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 to a fixed number of decimal places. If the trap is set, it is also useful for validation
>>> 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. Once I have valid two place inputs, how do I maintain that invariant throughout an application?
A. Some operations like addition, subtraction, and multiplication by an integer will automatically preserve fixed point. Others operations, like division and non-integer multiplication, will change the number of decimal places and need to be followed-up with a
>>> 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 step
>>> 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
In developing fixed-point applications, it is convenient to define functions to handle 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 step
>>> 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. There are many ways to express the same value. The numbers
>>> 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, and
>>> 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 all have the same value at various precisions. Is there a way to transform them to a single recognizable canonical value?
A. The
>>> 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 method maps all equivalent values to a single representative
>>> 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. Some decimal values always print with exponential notation. Is there a way to get a non-exponential representation?
A. For some values, exponential notation is the only way to express the number of significant places in the coefficient. For example, expressing
>>> 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 as
>>> 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 keeps the value constant but cannot show the original’s two-place significance
If an application does not care about tracking significance, it is easy to remove the exponent and trailing zeroes, losing significance, but keeping the value unchanged
>>> 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. Is there a way to convert a regular float to a ?
A. Yes, any binary floating point number can be exactly expressed as a Decimal though an exact conversion may take more precision than intuition would suggest
>>> 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. Within a complex calculation, how can I make sure that I haven’t gotten a spurious result because of insufficient precision or rounding anomalies
A. The decimal module makes it easy to test results. A best practice is to re-run calculations using greater precision and with various rounding modes. Widely differing results indicate insufficient precision, rounding mode issues, ill-conditioned inputs, or a numerically unstable algorithm
Q. I noticed that context precision is applied to the results of operations but not to the inputs. Is there anything to watch out for when mixing values of different precisions?
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. Trong triển khai CPython và PyPy3, các phiên bản C/CFFI của mô-đun thập phân tích hợp thư viện libmpdec tốc độ cao để có độ chính xác tùy ý làm tròn số học dấu phẩy động thập phâ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']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]. Cài đặ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']79 yêu cầu một số cẩn thận
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
Đối với kết quả không chính xác, quá lớn trên nền tảng 64 bit và bộ nhớ khả dụng sẽ không đủ
>>> Decimal["1e9999999999999999999"] Traceback [most recent call last]: File "", line 1, in decimal.InvalidOperation: []2
Trên các hệ thống có phân bổ tổng thể [e. g. Linux], một cách tiếp cận tinh vi hơn là điều chỉ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']79 theo dung lượng RAM khả dụng. Giả sử bạn có 8GB RAM và mong đợi 10 toán hạng đồng thời sử dụng tối đa 500MB mỗi toán hạng
>>> 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