Hướng dẫn how do you change decimals in python? - làm thế nào để bạn thay đổi số thập phân trong python?

Tldr;)

Vấn đề làm tròn của đầu vào và đầu ra đã được giải quyết dứt khoát bằng Python 3.1 và bản sửa lỗi cũng được đưa vào Python 2.7.0.solved definitively by Python 3.1 and the fix is backported also to Python 2.7.0.

Các số tròn có thể được chuyển đổi đảo ngược giữa phao và chuỗi qua lạ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')
7 hoặ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')
8
back and forth:
>>> 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 or
>>> 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

>>> 0.3
0.3
>>> float(repr(0.3)) == 0.3
True

Một loạ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')
9 không cần thiết để lưu trữ nữa.

Kết quả của các hoạt động số học phải được làm tròn một lần nữa vì các lỗi làm tròn có thể tích lũy không chính xác hơn so với điều đó có thể xảy ra sau khi phân tích một số. Không được cố định bởi thuật 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') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
0 được cải thiện (Python> = 3.1,> = 2.7.0): because rounding errors could accumulate more inaccuracy than that is possible after parsing one number. That is not fixed by the improved
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
0 algorithm (Python >= 3.1, >= 2.7.0):

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

The output string function

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
1 was rounded to 12 valid digits in Python < 2.7x and < 3.1, to prevent excessive invalid digits similar to unfixed repr() output. That was still insufficientl after subtraction of very similar numbers and it was too much rounded after other operations. Python 2.7 and 3.1 use the same length of str() although the repr() is fixed. Some old versions of Numpy had also excessive invalid digits, even with fixed Python. The current Numpy is fixed. Python versions >= 3.2 have the same results of str() and repr() function and also output of similar functions in Numpy.


Bài kiểm tra

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

Tài liệu

Xem Ghi chú phát hành Python 2.7 - Ngôn ngữ khác thay đổi đoạn thứ tư:

Chuyển đổi giữa các số dấu phẩy động và chuỗi hiện được làm tròn chính xác trên hầu hết các nền tảng. Những chuyển đổi này xảy ra ở nhiều nơi khác nhau: str () trên phao và số phức; các nhà xây dựng nổi và phức tạp; định dạng số; tuần tự hóa và khử tự động các phao và số phức bằng các mô-đun

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
2,
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
3 và
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
4; phân tích cú pháp phao và văn học tưởng tượng trong mã Python; và chuyển đổi thập phân sang phao.
between floating-point numbers and strings are now correctly rounded on most platforms. These conversions occur in many different places: str() on floats and complex numbers; the float and complex constructors; numeric formatting; serializing and de-serializing floats and complex numbers using the
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
2,
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
3 and
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
4 modules; parsing of float and imaginary literals in Python code; and Decimal-to-float conversion.

Liên quan đến điều này, phần repr () của số điểm nổi x hiện đang trả về kết quả dựa trên chuỗi thập phân ngắn nhất mà Lọ đảm bảo quay trở lại X dưới cách làm tròn chính xác (với chế độ làm tròn nửa vòng tròn). Trước đây, nó đã đưa ra một chuỗi dựa trên làm tròn x đến 17 chữ số thập phân.repr() of a floating-point number x now returns a result based on the shortest decimal string that’s guaranteed to round back to x under correct rounding (with round-half-to-even rounding mode). Previously it gave a string based on rounding x to 17 decimal digits.

Vấn đề liên quan


Thông tin thêm: Định dạng

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
5 trước Python 2.7 tương tự như
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
6 hiện tại. Cả hai loại đều sử dụng cùng độ chính xác gấp đôi của IEEE 754 với 52 bit mantissa. Một sự khác biệt lớn là
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
7 được định dạng thường xuyên với số thập phân quá mức để không thể mất một chút, nhưng không có số IEEE 754 hợp lệ tồn tại trong khoảng 13.94999999999999 và 13.9500000000001. Kết quả là không tốt và chuyển đổi
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
8 không thể đảo ngược với Numpy. Mặt khác:
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
9 được định dạng để mọi chữ số đều quan trọng; Trình tự là không có khoảng trống và chuyển đổi có thể đảo ngược. Đơn giản: Nếu bạn có thể có số Numpy.Loat64, hãy chuyển đổi nó thành phao bình thường để được định dạng cho con người, không phải cho bộ xử lý số, nếu không thì không có gì cần thiết hơn với Python 2.7+.
The formatting of
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
5 before Python 2.7 was similar to the current
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
6. Both types use the same 64 bit IEEE 754 double precision with 52 bit mantissa. A big difference is that
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
7 is formatted frequently with an excessive decimal number so that no bit can be lost, but no valid IEEE 754 number exists between 13.949999999999999 and 13.950000000000001. The result is not nice and the conversion
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
8 is not reversible with numpy. On the other hand:
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
9 is formatted so that every digit is important; the sequence is without gaps and the conversion is reversible. Simply: If you perhaps have a numpy.float64 number, convert it to normal float in order to be formatted for humans, not for numeric processors, otherwise nothing more is necessary with Python 2.7+.

Mã nguồn: lib/decimal.py Lib/decimal.py


Mô -đun

>>> 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 cung cấp hỗ trợ cho số học điểm nổi tròn chính xác chính xác. Nó cung cấp một số lợi thế so với kiểu dữ liệu
>>> 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:

  • Decimal, dựa trên mô hình dấu phẩy động được thiết kế với mọi 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 số học hoạt động theo cách tương tự như số học mà mọi người học ở trường. - Đoạn trích từ đặc điểm số học thập phân.

  • Số thập phân có thể được đại diện chính xác. Ngược lại, các số như

    >>> getcontext().prec = 6
    >>> Decimal('3.0')
    Decimal('3.0')
    >>> Decimal('3.1415926535')
    Decimal('3.1415926535')
    >>> Decimal('3.1415926535') + Decimal('2.7182818285')
    Decimal('5.85987')
    >>> getcontext().rounding = ROUND_UP
    >>> Decimal('3.1415926535') + Decimal('2.7182818285')
    Decimal('5.85988')
    
    2 và
    >>> getcontext().prec = 6
    >>> Decimal('3.0')
    Decimal('3.0')
    >>> Decimal('3.1415926535')
    Decimal('3.1415926535')
    >>> Decimal('3.1415926535') + Decimal('2.7182818285')
    Decimal('5.85987')
    >>> getcontext().rounding = ROUND_UP
    >>> Decimal('3.1415926535') + Decimal('2.7182818285')
    Decimal('5.85988')
    
    3 không có biểu diễn chính xác trong điểm nổi nhị phân. Người dùng cuối thường không mong đợ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')
    
    4 sẽ hiển thị là
    >>> getcontext().prec = 6
    >>> Decimal('3.0')
    Decimal('3.0')
    >>> Decimal('3.1415926535')
    Decimal('3.1415926535')
    >>> Decimal('3.1415926535') + Decimal('2.7182818285')
    Decimal('5.85987')
    >>> getcontext().rounding = ROUND_UP
    >>> Decimal('3.1415926535') + Decimal('2.7182818285')
    Decimal('5.85988')
    
    5 như với điểm nổi nhị phân.

  • Sự chính xác mang lại vào số học. Trong điểm nổi thập phâ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')
    
    6 chính xác bằng không. Trong điểm nổi nhị phân, kết quả là
    >>> getcontext().prec = 6
    >>> Decimal('3.0')
    Decimal('3.0')
    >>> Decimal('3.1415926535')
    Decimal('3.1415926535')
    >>> Decimal('3.1415926535') + Decimal('2.7182818285')
    Decimal('5.85987')
    >>> getcontext().rounding = ROUND_UP
    >>> Decimal('3.1415926535') + Decimal('2.7182818285')
    Decimal('5.85988')
    
    7. Mặc dù gần bằng không, sự khác biệt ngăn chặn kiểm tra và khác biệt đáng tin cậy có thể tích lũy. Vì lý do này, thập phân được ưa thích trong các ứng dụng kế toán có bất biến bình đẳng nghiêm ngặt.

  • Mô -đun thập phân kết hợp một khái niệm về các địa điểm quan trọng để

    >>> 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 là
    >>> getcontext().prec = 6
    >>> Decimal('3.0')
    Decimal('3.0')
    >>> Decimal('3.1415926535')
    Decimal('3.1415926535')
    >>> Decimal('3.1415926535') + Decimal('2.7182818285')
    Decimal('5.85987')
    >>> getcontext().rounding = ROUND_UP
    >>> Decimal('3.1415926535') + Decimal('2.7182818285')
    Decimal('5.85988')
    
    9. Số 0 được giữ để chỉ ra ý nghĩa. Đây là bản trình bày thông thường cho các ứng dụng tiền tệ. Để nhân lên, phương pháp tiếp cận của trường học của người Viking sử dụng tất cả các số liệu trong nhân vật nhân. Chẳng hạn,
    >>> Decimal("1e9999999999999999999")
    Traceback (most recent call last):
      File "", line 1, in 
    decimal.InvalidOperation: []
    
    0 cho
    >>> Decimal("1e9999999999999999999")
    Traceback (most recent call last):
      File "", line 1, in 
    decimal.InvalidOperation: []
    
    1 trong khi
    >>> Decimal("1e9999999999999999999")
    Traceback (most recent call last):
      File "", line 1, in 
    decimal.InvalidOperation: []
    
    2 cho
    >>> Decimal("1e9999999999999999999")
    Traceback (most recent call last):
      File "", line 1, in 
    decimal.InvalidOperation: []
    
    3.

  • Không giống như điểm nổi 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 đến 28 vị trí) có thể lớn như 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ả điểm nổi nhị phân và thập phân được thực hiện theo các tiêu chuẩn được công bố. Mặc dù loại phao tích hợp chỉ hiển thị một phần khiêm tốn của khả năng của nó, mô-đun thập phân cho thấy tất cả các phần cần thiết của tiêu chuẩn. Khi cần thiết, lập trình viên có toàn quyền kiểm soát 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 mọi hoạt động không chính xác.

  • Mô-đun thập phân được thiết kế để hỗ trợ mà không có thành kiến, cả số học thập phân không có căn cứ chính xác (đôi khi được gọi là số học điểm cố định) và số học nổi tròn. - Đoạn trích từ đặc điểm 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, bối 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ó một dấu hiệu, số số hệ số và số mũ. Để giữ được ý nghĩa, các số các số không cắt ngắn các số không. Số thập phân cũng bao gồm các giá trị đặc biệt như

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
4,
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
5 và
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6. Tiêu chuẩn cũng khác biệt
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
7 với
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
8.

Bối cảnh cho số học là một môi trường chỉ định độ chính xác, các quy tắc làm tròn, giới hạn đối với số mũ, cờ cho thấy kết quả hoạt động và các yếu tố hỗ trợ bẫy xác định xem các 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

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
9,
>>> 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,
>>> 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,
>>> 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,
>>> 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,
>>> 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,
>>> 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 và
>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')
6.

Tín hiệu là các nhóm đ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, 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à:

>>> 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,
>>> 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')
8,
>>> 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,
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
00,
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
01,
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
02,
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
03,
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
04 và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
05.

Đối với mỗi tín hiệu có một cờ và một bộ tạo bẫy. Khi một tín hiệu gặp phải, cờ của nó được đặt thành một, sau đó, nếu bộ kích hoạt bẫy được đặt thành một, một ngoại lệ được nâng lên. Cờ bị dính, vì vậy người dùng cần đặt lại chúng trước khi theo dõi tính toán.

Xem thêm

  • Đặc điểm số học số thập phân tổng quát của IBM, đặc điểm số học số thập phân chung.

Hướng dẫn bắt đầu nhanh

Việc bắt đầu sử dụng số thập phân thông thường là nhập mô -đun, xem bối cảnh hiện tại với

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
06 và, nếu cần, đặt các giá trị mới cho độ chính xác, làm tròn hoặc bẫy được bậ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 precision

Các trường hợp thập phân có thể được xây dựng từ số nguyên, dây, phao hoặc bộ dữ liệu. Xây dựng từ một số nguyên hoặc phao thực hiện chuyển đổi chính xác giá trị của số nguyên hoặc phao. Các số thập phân bao gồm các giá trị đặc biệt, chẳng hạn như

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6 là viết tắt của không phải là một số, dương và âm
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
4 và
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
7:

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

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
05 bị mắc kẹt, sự pha trộn tình cờ của số thập phân và phao trong các hàm tạo hoặc so sánh đặt hàng sẽ gây 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') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Mới trong phiên bản 3.3.

Tầm quan trọng của một số thập phân mới được xác định chỉ bằng số lượng đầu vào. Độ chính xác bối cảnh và làm tròn chỉ phát huy tác dụng trong các hoạt động 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 tă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')
8:

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []

Đã thay đổi trong phiên bản 3.3.

Số thập phân tương tác tốt với phần lớn phần còn lại của Python. Dưới đây là một rạp xiếc bay thả nổi số thập phân 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')

Và một số chức năng toán học cũng có sẵn cho số thập phân:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
0

Phương pháp

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
12 làm tròn một số vào số mũ cố định. Phương pháp này rất hữu ích cho các ứng dụng tiền tệ thường làm tròn kết quả đến một số địa điểm cố định:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
1

Như được hiển thị ở trên, hàm

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
06 truy cập vào bối cảnh hiện tại và cho phép các cài đặt được thay đổi. Cách tiếp cận này đáp ứng nhu cầu của hầu hết các ứng dụng.

Đối với công việc nâng cao hơn, có thể hữu ích để tạo bối cảnh thay thế bằng cách sử dụng hàm tạo ngữ cảnh (). Để thực hiện hoạt động thay thế, hãy sử dụng chức năng

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
14.

Theo tiêu chuẩn, mô -đun

>>> 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 cung cấp hai bối cảnh tiêu chuẩn sẵn sàng sử dụng,
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
16 và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
17. Cái trước đặc biệt hữu ích cho việc gỡ lỗi vì nhiều bẫy được bật:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
2

Bối cảnh cũng có cờ tín hiệu để theo dõi các điều kiện đặc biệt gặp phải trong quá trình tính toán. Các cờ vẫn được đặt cho đến khi được xóa rõ ràng, vì vậy tốt nhất là xóa các cờ trước mỗi bộ tính toán được giám sát bằng cách sử dụng phương pháp

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
18.

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
3

Mục nhập cờ cho thấy mức độ xấp xỉ hợp lý với

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
19 được làm tròn (các chữ số vượt quá độ chính xác ngữ cảnh đã bị vứt đi) và kết quả là không chính xác (một số chữ số bị loại bỏ là không khác).

Các bẫy riêng lẻ được đặt bằng cách sử dụng từ điển trong trường

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
20 của bối cảnh:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
4

Hầu hết các chương trình điều chỉnh bối cảnh hiện tại chỉ 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

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 với một diễn viên duy nhất bên trong một vòng lặp. Với bối cảnh được đặt và số thập phân được tạo ra, phần lớn chương trình thao túng 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

classDecimal.decimal (value = '0', bối cảnh = none) ¶decimal.Decimal(value='0', context=None)

Xây dựng một đối tượng

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 mới dựa trên giá trị.

Giá trị có thể là một số nguyên, chuỗi, tuple,

>>> 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 hoặc đối tượng
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 khác. Nếu không có giá trị nào được đưa ra, trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
25. Nếu giá trị là một chuỗi, nó sẽ phù hợp với cú pháp chuỗi số thập phân sau khi dẫn đầu và theo dõi các ký tự khoảng trắng, cũng như các dấu gạch dưới trong suốt, được loại bỏ:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
5

Các chữ số thập phân Unicode khác cũng được cho phép trong đó

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
26 xuất hiện ở trên. Chúng bao gồm các chữ số thập phân từ các bảng chữ cái khác nhau khác nhau (ví dụ, các chữ số tiếng Ả Rập và Devanāgarī) cùng với các chữ số fullwidth
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
27 đến
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
28.

Nếu giá trị là

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
29, nó sẽ có ba thành phần, một dấu hiệu (
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
30 cho dương hoặc
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
31 cho âm),
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
29 của các chữ số và số mũ số nguyên. Ví dụ:
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
33 trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
34.

Nếu giá trị là

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
1, giá trị điểm nổi nhị phân sẽ được chuyển đổi một cách không tổn thất thành tương đương thập phân chính xác của nó. Chuyển đổi này thường có thể yêu cầu 53 chữ số trở lên chính xác. Ví dụ,
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
36 chuyển đổi thành
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
37.

Độ chính xác bối cảnh không ảnh hưởng đến số lượng được lưu trữ. Điều đó được xác định riêng bởi số chữ số trong giá trị. Ví dụ,

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
38 ghi lại tất cả năm số không ngay cả khi độ chính xác 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 định dạng. Nếu bối cảnh bẫy

>>> 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')
8, một ngoại lệ sẽ được nâng lên; Mặt khác, hàm tạo trả về một số thập phân mới với giá trị
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6.

Sau khi được xây dựng, các đối tượng

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 là bất biến.

Thay đổi trong phiên bản 3.2: Đối số cho hàm tạo hiện được phép là một ví dụ

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
1.The argument to the constructor is now permitted to be 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')
1 instance.

Đã thay đổi trong phiên bản 3.3:

>>> 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 Các đối số tăng một ngoại lệ nếu bẫy ____105 được đặt. Theo mặc định, bẫy bị tắt.
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
1 arguments raise an exception if the
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
05 trap is set. By default the trap is off.

Đã thay đổi trong phiên bản 3.6: Dấu gạch dưới được phép nhóm, như với các chữ ký tích hợp và dấu phẩy động trong mã.Underscores are allowed for grouping, as with integral and floating-point literals in code.

Các đối tượng điểm nổi thập phân chia sẻ nhiều thuộc tính với các loại số tích hợp khác như

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
1 và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
46. Tất cả các hoạt động toán học 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, ngâm, in, được sử dụng làm khóa từ điển, được sử dụng như các phần tử đã đặt, so sánh, sắp xếp và ép buộc sang loại khác (chẳng hạn như
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
1 hoặc
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
46).

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à phao. Khi toán tử còn lại

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
49 được áp dụng cho các đối tượng thập phân, dấu hiệu của kết quả là dấu hiệu của cổ tức chứ không phải là dấu hiệu của ước số:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
6

Toán tử phân chia số nguyên

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
50 hoạt động tương tự, trả về phần số nguyên của thương số thực (cắt ngắn về 0) thay vì sàn của nó, để bảo tồn danh tính thông thường
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
51:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
7

Các toán tử

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
49 và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
50 thực hiện các hoạt động
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
54 và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
55 (tương ứng) như được mô tả trong đặc điểm kỹ thuật.

Các đối tượng thập phân thường không thể được kết hợp với các phao hoặc các trường hợp

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
56 trong các hoạt động số học: ví dụ, một nỗ lực để thêm
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 vào
>>> 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, chẳng hạn, sẽ tăng
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
59. Tuy nhiên, có thể sử dụng các toán tử so sánh Python, để so sánh một ví dụ
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
61 với một số khác
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
62. Đ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 loại hỗn hợp giữa các trường hợp

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 và các loại số khác hiện được hỗ trợ đầy đủ.Mixed-type comparisons between
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 instances and other numeric types are now fully supported.

Ngoài các thuộc tính số tiêu chuẩn, các đối tượng điểm nổi thập phân cũng có một số phương pháp chuyên dụng:

điều chỉnh()¶()

Trả về số mũ được điều chỉnh sau khi chuyển ra hệ số các chữ số bên phải của hệ số cho đến khi chỉ còn lại chữ số chì:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
64 trả về bảy. Được sử dụng để xác định vị trí của chữ số quan trọng nhất đối với điểm thập phân.

as_integer_ratio () ¶()

Trả về một cặp

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
65 số nguyên đại diện cho trường hợp
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 đã cho dưới dạng một phần, theo mức thấp nhất và với mẫu số tích cực:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
8

Việc chuyển đổi là chính xác. Nâng cao Overflowerror về Infinities và ValueError trên Nans.

Mới trong phiên bản 3.6.

as_tuple () ¶()

Trả về một đại diện tuple có tên của số:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
67.named tuple representation of the number:
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
67.

kinh điển () ¶()

Trả về mã hóa kinh điển của đối số. Hiện tại, việc mã hóa một ví dụ

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 luôn luôn có kinh điển, vì vậy hoạt động này trả về đối số của nó không thay đổi.

So sánh (Khác, Bối cảnh = Không) ¶(other, context=None)

So sánh các giá trị của hai trường hợp thập phân.

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
69 trả về một ví dụ thập phân và nếu một trong hai toán hạng là NAN thì kết quả là NAN:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
9

compare_signal (khác, bối cảnh = không) ¶(other, context=None)

Hoạt động này giống hệt với phương pháp

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
69, ngoại trừ tất cả tín hiệu NANS. Đó là, nếu cả hai toán hạng không phải là một NAN báo hiệu thì bất kỳ toán hạng NAN yên tĩnh nào cũng được đối xử như thể đó là một NAN báo hiệu.

compare_total (khác, bối cảnh = không) ¶(other, context=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

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
69, nhưng kết quả đưa ra tổng số đặt hàng trên các trường hợp
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21. Hai trường hợp
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 có cùng giá trị số nhưng các biểu diễn khác nhau so sánh không đồng đều trong thứ tự này:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
0

Nans yên tĩnh và báo hiệu cũng được bao gồm trong tổng số đơn đặt hàng. Kết quả của chức năng này là

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
25 nếu cả hai toán hạng có cùng một biểu diễn,
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
75 nếu toán hạng đầu tiên thấp hơn trong tổng thứ tự so với thứ hai và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
76 nếu toán hạng đầu tiên cao hơn trong tổng số thứ tự so với 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 bối cảnh và im lặng: không có cờ nào được thay đổi và không có làm tròn nào được thực hiện. Như một ngoại lệ, phiên bản C có thể tăng không hợp lệ nếu toán hạng thứ hai không thể được chuyển đổi chính xác.

compare_total_mag (khác, bối cảnh = không) ¶(other, context=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

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
77, nhưng bỏ qua dấu hiệu của mỗi toán hạng.
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
78 tương đương với
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
79.

Hoạt động này không bị ảnh hưởng bởi bối cảnh và im lặng: không có cờ nào được thay đổi và không có làm tròn nào được thực hiện. Như một ngoại lệ, phiên bản C có thể tăng không hợp lệ nếu toán hạng thứ hai không thể được chuyển đổi chính xác.

liên hợp () ¶()

Chỉ cần trả lại bản thân, phương pháp này chỉ tuân thủ đặc tả số 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à im lặng: không có cờ nào được thay đổi và không có cách làm tròn nào được thực hiện.

copy_negate () ¶()

Trả lại sự phủ định của đối số. Hoạt động này không bị ảnh hưởng bởi bối cảnh và im lặng: không có cờ nào được thay đổi và không có cách làm tròn nào được thực hiện.

COPY_SIGN (Khác, Bối cảnh = Không) ¶(other, context=None)

Trả về một bản sao của toán hạng đầu tiên với dấu hiệu được đặt giống như dấu hiệu của toán hạng thứ hai. Ví dụ:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
1

Hoạt động này không bị ảnh hưởng bởi bối cảnh và im lặng: không có cờ nào được thay đổi và không có làm tròn nào được thực hiện. Như một ngoại lệ, phiên bản C có thể tăng không hợp lệ nếu toán hạng thứ hai không thể được chuyển đổi chính xác.

exp (bối cảnh = không) ¶(context=None)

Trả về giá trị của hàm số mũ (tự nhiên)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
80 ở số đã cho. Kết quả được làm tròn chính xác bằng chế độ làm trò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')
3.

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
2

classmethodfrom_float (f) ¶from_float(f)

Hàm tạo thay thế chỉ chấp nhận các trường hợp

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
1 hoặc
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
46.

Lưu ý

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
84 không giống như
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
85. Vì 0,1 không thể đại diện chính xác trong điểm nổi nhị phân, giá trị được lưu trữ dưới dạng giá trị đại diện gần nhất là
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
86. Giá trị tương đương đó trong thập phân là
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
87.

Ghi chú

Từ Python 3.2 trở đi, một trường hợp

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 cũng có thể được xây dựng trực tiếp từ
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
1.

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
3

Mới trong phiên bản 3.1.

FMA (Khác, Thứ ba, Bối cảnh = Không) ¶(other, third, context=None)

Nội dung nhân lên. Tự trả lại*Khác+thứ ba không có sự làm tròn của sản phẩm trung gian tự*khác.

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
4

is_canonical ()()

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 Nếu đối số là chính tắc và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91 khác. Hiện tại, một ví dụ
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 luôn luôn có kinh điển, vì vậy hoạt động này luôn trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90.

is_finite () ¶()

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 Nếu đối số là một số hữu hạn và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91 nếu đối số là vô cực hoặc NAN.

là vô hạn()¶()

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 Nếu đối số là vô cùng dương hoặc âm và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91 khác.

is_nan ()()

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 Nếu đối số là một (yên tĩnh hoặc báo hiệu) NAN và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91 khác.

is_nquaral (bối cảnh = không) ¶(context=None)

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 Nếu đối số là số hữu hạn bình thường. Trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91 Nếu đối số bằng không, không bình thường, vô hạn hoặc NAN.

is_qnan ()()

Trả lại

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 Nếu cuộc tranh luận là một NAN yên tĩnh và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91 khác.

is_sign ()()

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 Nếu đối số có dấu âm và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91 khác. Lưu ý rằng cả Zeros và Nans đều có thể mang dấu hiệu.

is_snan ()()

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 Nếu đối số là NAN báo hiệu và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91 khác.

is_subnormal (bối cảnh = none) ¶(context=None)

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 Nếu đối số là không bình thường và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91 khác.

is_zero ()()

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 Nếu đối số là một (dương hoặc âm) bằng không và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91 khác.

ln (bối cảnh = không) ¶(context=None)

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 chế độ làm trò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')
3.

log10 (bối cảnh = không) ¶(context=None)

Trả lại cơ sở mười logarit của toán hạng. Kết quả được làm tròn chính xác bằng chế độ làm trò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')
3.

logb (bối cảnh = không) ¶(context=None)

Đối với một số khác nhau, hãy trả về số mũ được điều chỉnh của toán hạng của nó dưới dạng ví dụ

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21. Nếu toán hạng bằng 0 thì
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
15 sẽ được trả về và 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 được nâng lên. Nếu toán hạng là vô cực thì
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
17 sẽ được trả về.

Logical_and (Khác, Bối cảnh = Không) ¶(other, context=None)

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
18 là một hoạt động logic có hai toán hạng logic (xem các toán hạng logic). Kết quả là chữ số
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
19 của hai toán hạng.Logical operands). The result is the digit-wise
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
19 of the two operands.

Logical_invert (bối cảnh = Không) ¶(context=None)

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
20 là một hoạt động hợp lý. Kết quả là đảo ngược chữ số của toán hạng.

Logical_or (Khác, Bối cảnh = Không) ¶(other, context=None)

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
21 là một hoạt động logic có hai toán hạng logic (xem các toán hạng logic). Kết quả là chữ số
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
22 của hai toán hạng.Logical operands). The result is the digit-wise
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
22 of the two operands.

Logical_xor (Khác, Bối cảnh = Không) ¶(other, context=None)

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
23 là một hoạt động logic có hai toán hạng logic (xem các toán hạng logic). Kết quả là độc quyền chữ số hoặc của hai toán hạng.Logical operands). The result is the digit-wise exclusive or of the two operands.

tối đa (khác, bối cảnh = không) ¶(other, context=None)

Giống như

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
24 ngoại trừ quy tắc làm tròn ngữ cảnh được áp dụng trước khi trả về và các giá trị
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6 được báo hiệu hoặc bỏ qua (tùy thuộc vào ngữ cảnh và liệu chúng có báo hiệu hay yên tĩnh).

MAX_MAG (Khác, Bối cảnh = Không) ¶(other, context=None)

Tương tự như phương pháp

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
26, nhưng so sánh được thực hiện bằng cách sử dụng các giá trị tuyệt đối của các toán hạng.

Min (Khác, Bối cảnh = Không) ¶(other, context=None)

Giống như

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
27 ngoại trừ quy tắc làm tròn ngữ cảnh được áp dụng trước khi trả về và các giá trị
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6 được báo hiệu hoặc bỏ qua (tùy thuộc vào ngữ cảnh và liệu chúng có báo hiệu hay yên tĩnh).

min_mag (khác, bối cảnh = không) ¶(other, context=None)

Tương tự như phương pháp

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
29, nhưng so sánh được thực hiện bằng cách sử dụng các giá trị tuyệt đối của các toán hạng.

next_minus (bối cảnh = không) ¶(context=None)

Trả về số lớn nhất có thể thể hiện trong bối cảnh đã cho (hoặc trong bối cảnh luồng hiện tại nếu không có ngữ cảnh nào được đưa ra) nhỏ hơn toán hạng đã cho.

next_plus (bối cảnh = không) ¶(context=None)

Trả về số nhỏ nhất có thể thể hiện trong bối cảnh đã cho (hoặc trong bối cảnh luồng hiện tại nếu không có ngữ cảnh nào được đưa ra) lớn hơn toán hạng đã cho.

next_toward (khác, bối cảnh = không) ¶(other, context=None)

Nếu hai toán hạng là không đồng đều, hãy trả lại số gần nhất với toán hạng đầu tiên theo hướng của toán hạng thứ hai. Nếu cả hai toán hạng đều bằng số, hãy trả về một bản sao của toán hạng đầu tiên với dấu hiệu được đặt giống như dấu hiệu của toán hạng thứ hai.

Bình thường hóa (bối cảnh = Không) ¶(context=None)

Bình thường hóa số bằng cách tước các số không theo dõi ngoài cùng bên phải và chuyển đổi bất kỳ kết quả nào bằng

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
25 thành
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
31. Được sử dụng để tạo ra các giá trị kinh điển cho các thuộc tính của một lớp tương đương. Ví dụ,
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
32 và
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
33 đều bình thường hóa thành giá trị tương đương
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
34.

Number_Class (bối cảnh = Không) ¶(context=None)

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.

  • import random
    from decimal import Decimal
    for _ in range(1000000):
        x = random.random()
        assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
        assert str(x) == repr(x)
        assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
    
    35, chỉ ra rằng toán hạng là vô cùng tiêu cực.

  • import random
    from decimal import Decimal
    for _ in range(1000000):
        x = random.random()
        assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
        assert str(x) == repr(x)
        assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
    
    36, chỉ ra rằng toán hạng là số bình thường âm.

  • import random
    from decimal import Decimal
    for _ in range(1000000):
        x = random.random()
        assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
        assert str(x) == repr(x)
        assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
    
    37, chỉ ra rằng toán hạng là âm và dưới mức.

  • import random
    from decimal import Decimal
    for _ in range(1000000):
        x = random.random()
        assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
        assert str(x) == repr(x)
        assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
    
    38, chỉ ra rằng toán hạng là số 0 âm.

  • import random
    from decimal import Decimal
    for _ in range(1000000):
        x = random.random()
        assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
        assert str(x) == repr(x)
        assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
    
    39, chỉ ra rằng toán hạng là số 0 dương.

  • import random
    from decimal import Decimal
    for _ in range(1000000):
        x = random.random()
        assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
        assert str(x) == repr(x)
        assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
    
    40, chỉ ra rằng toán hạng là dương và dưới mức.

  • import random
    from decimal import Decimal
    for _ in range(1000000):
        x = random.random()
        assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
        assert str(x) == repr(x)
        assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
    
    41, chỉ ra rằng toán hạng là số bình thường dương.

  • import random
    from decimal import Decimal
    for _ in range(1000000):
        x = random.random()
        assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
        assert str(x) == repr(x)
        assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
    
    42, chỉ ra rằng toán hạng là vô cùng dương tính.

  • import random
    from decimal import Decimal
    for _ in range(1000000):
        x = random.random()
        assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
        assert str(x) == repr(x)
        assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
    
    43, chỉ ra rằng toán hạng là một nan yên tĩnh (không phải là một số).

  • import random
    from decimal import Decimal
    for _ in range(1000000):
        x = random.random()
        assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
        assert str(x) == repr(x)
        assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
    
    44, chỉ ra rằng toán hạng là NAN báo hiệu.

Quantize (exp, làm tròn = không, bối cảnh = không) ¶(exp, rounding=None, context=None)

Trả về một giá trị bằng với 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.

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
5

Không giống như các hoạt động khác, nếu độ dài của hệ số sau khi hoạt động lượng tử hóa sẽ lớn hơn độ chính xác, thì

>>> 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')
8 được báo hiệu. Điều này đảm bảo rằng, trừ khi có một điều kiện lỗi, số mũ được định lượng luôn bằng với hoạt động bên phải.

Cũng không giống như các hoạt động khác, lượng tử hóa không bao giờ tín hiệu tăng, 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 so với đầu tiên thì làm tròn có thể là cần thiết. Trong trường hợp này, chế độ làm tròn được xác định bằng đối số

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
46 nếu được đưa ra, khác bằng đối số
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
47 đã cho; Nếu không có đối số nào được đưa ra chế độ làm tròn của bối cảnh luồng hiện tại được sử dụng.

Một lỗi được trả về bất cứ khi nào số mũ kết quả lớn hơn

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
48 hoặc nhỏ hơn
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
49.

radix ()()

Trả về

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
50, radix (cơ sở) trong đó lớp
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 thực hiện tất cả số học của nó. Bao gồm để tương thích với đặc điểm kỹ thuật.

phần còn lại_near (khác, bối cảnh = không) ¶(other, context=None)

Trả lại phần còn lại từ việc chia cho bản thân cho người khác. Điều này khác với

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
52 ở chỗ dấu hiệu của phần còn lại được chọn để giảm thiểu giá trị tuyệt đối của nó. Chính xác hơn, giá trị trả về là
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
53 trong đó
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
54 là số nguyên gần nhất với giá trị chính xác của
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
55 và nếu hai số nguyên gần thì chẵn được chọn.

Nếu kết quả bằng không thì dấu hiệu của nó sẽ là dấu hiệu của bản thân.

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
6

xoay (khác, bối cảnh = không) ¶(other, context=None)

Trả về kết quả quay các chữ số của toán hạng đầu tiên bằng một lượng được chỉ định bởi toán hạng thứ hai. Toán tử thứ hai phải là một số nguyên trong phạm vi -Crive thông qua độ chính xác. Giá trị tuyệt đối của toán hạng thứ hai cung cấp số lượng địa điểm để xoay. Nếu toán hạng thứ hai là dương thì xoay ở bên trái; Nếu không thì xoay ở bên phải. Hệ số của toán hạng đầu tiên được đệm ở bên trái với số không có độ chính xác chiều dài nếu cần thiết. Dấu hiệu và số mũ của toán hạng đầu tiên không thay đổi.

cùng nhau_quantum (khác, bối cảnh = không) ¶(other, context=None)

Kiểm tra xem bản thân và người khác có cùng số mũ hay liệu cả hai đều là

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6.

Hoạt động này không bị ảnh hưởng bởi bối cảnh và im lặng: không có cờ nào được thay đổi và không có làm tròn nào được thực hiện. Như một ngoại lệ, phiên bản C có thể tăng không hợp lệ 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 = không) ¶(other, context=None)

Trả lại toán hạng đầu tiên với số mũ được điều chỉnh theo thứ hai. Tương tự, trả về toán hạng đầu tiên nhân với

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
57. Toán tử thứ hai phải là một số nguyên.

Shift (Khác, Bối cảnh = Không) ¶(other, context=None)

Trả về kết quả của việc chuyển các chữ số của toán hạng đầu tiên bằng một lượng được chỉ định bởi toán hạng thứ hai. Toán tử thứ hai phải là một số nguyên trong phạm vi -Crive thông qua độ chính xác. Giá trị tuyệt đối của toán hạng thứ hai cho số lượng địa điểm thay đổi. Nếu toán hạng thứ hai là dương thì sự thay đổi ở bên trái; Nếu không thì sự thay đổi là bên phải. Các chữ số chuyển vào hệ số là số không. Dấu hiệu và số mũ của toán hạng đầu tiên không thay đổi.

sqrt (bối cảnh = không) ¶(context=None)

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 = none) ¶(context=None)

Chuyển đổi thành một chuỗi, sử dụng ký hiệu kỹ thuật nếu cần một số mũ.

Kỹ thuật ký hiệu có số mũ là bội số của 3. Điều này có thể để lại tới 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ố không kéo dài.

Ví dụ, điều này chuyển đổi

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
58 thành
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
59.

to_integral (làm tròn = không, bối cảnh = không) ¶(rounding=None, context=None)

Giống hệt với phương pháp

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
60. Tên
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
61 đã được giữ để tương thích với các phiên bản cũ hơn.

to_integral_exact (làm tròn = không, bối cảnh = không) ¶(rounding=None, context=None)

Vòng tròn đến số nguyên gần nhất, báo hiệu

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
00 hoặc
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
01 khi thích hợp nếu xảy ra làm tròn. Chế độ làm tròn được xác định bởi tham số
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
46 nếu được đưa ra, khác bởi
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
47 đã cho. Nếu không tham số nào được đưa ra thì chế độ làm tròn của bối cảnh hiện tại được sử dụng.

to_integral_value (làm tròn = none, bối cảnh = không) ¶(rounding=None, context=None)

Vòng tròn đến số nguyên gần nhất mà không báo hiệu

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
00 hoặc
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
01. Nếu được đưa ra, áp dụng làm tròn; Mặt khác, sử dụng phương pháp làm tròn trong bối cảnh được cung cấp hoặc bối cảnh hiện tại.

Toán tử logic

Các phương thức

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
18,
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
20,
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
21 và
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
23 mong đợi các đối số của họ là các toán hạng logic. Một toán hạng logic là một thể hiện
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 có số mũ và dấu hiệu cả bằng không và có tất cả các chữ số là
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
30 hoặc
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
31.

Đối tượng bối cảnh lor

Bối cảnh là môi trường cho các hoạt động số học. Họ chi phối độ chính xác, đặt các 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ó ngữ cảnh hiện tại riêng được truy cập hoặc thay đổi bằng các hàm

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
06 và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
14:

decimal.getContext () ¶getcontext()

Trả về bối cảnh hiện tại cho chủ đề hoạt động.

decimal.setContext (c) ¶setcontext(c)

Đặt bối cảnh hiện tại cho luồng hoạt động thành c.

Bạn cũng có thể sử dụng câu lệnh

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
77 và hàm
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
78 để tạm thời thay đổi bối cảnh hoạt động.

decimal.localcontext (ctx = none, \*\*kwargs) ¶localcontext(ctx=None, \*\*kwargs)

Trả về Trình quản lý bối cảnh sẽ đặt bối cảnh hiện tại cho luồng hoạt động thành bản sao của CTX khi nhập vào thông báo và khôi phục bối cảnh trước đó khi thoát khỏi sự cố. Nếu không có ngữ cảnh nào được chỉ định, một bản sao của bối cảnh hiện tại được sử dụng. Đối số KWARGS được sử dụng để đặt các thuộc tính của bối cảnh mới.

Ví dụ: mã sau đây đặt độ chính xác thập phân hiện tại thành 42 vị trí, thực hiện tính toán và sau đó tự động khôi phục bối cảnh trước đó:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
7

Sử dụng các đối số từ khóa, mã sẽ như sau:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
8

Tăng

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
59 Nếu Kwargs cung cấp một thuộc tính mà
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
80 không hỗ trợ. Tăng
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
59 hoặc
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
82 nếu KWARG 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:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
78 Bây giờ hỗ trợ cài đặt các thuộc tính ngữ cảnh thông qua việc sử dụng các đối số từ khóa.
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
78 now supports setting context attributes through the use of keyword arguments.

Bối cảnh mới cũng có thể được tạo bằng cách sử dụng hàm tạo

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
80 được mô tả dưới đây. Ngoài ra, mô-đun cung cấp ba bối cảnh được tạo sẵn:

classdecimal.basiccontext¶decimal.BasicContext

Đây là một bối 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

>>> 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. Tất cả các cờ được xóa. Tất cả các bẫy được bật (được coi là ngoại lệ) ngoại trừ
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
00,
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
01 và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
02.

Bởi vì nhiều bẫy được bật, bối cảnh này rất hữu ích cho việc gỡ lỗi.

ClassDecimal.ExtendsContext¶ decimal.ExtendedContext

Đây là một bối 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

>>> 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. Tất cả các cờ được xóa. Không có bẫy được bật (để các ngoại lệ không được nâng lên trong quá trình tính toán).

Bởi vì các bẫy bị vô hiệu hóa, bối cảnh này rất hữu ích cho các ứng dụng thích có giá trị kết quả là

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6 hoặc
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
4 thay vì nâng cao các ngoại lệ. Điều này cho phép một ứng dụng hoàn thành một cuộc chạy với sự hiện diện của các điều kiện nếu không nên tạm dừng chương trình.

classdecimal.defaultcontext¶decimal.DefaultContext

Bối cảnh này được sử dụng bởi hàm tạo

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
80 như một 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 bối cảnh mới được tạo bởi hàm tạo
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
80.

Bối cảnh này hữu ích nhất trong các môi trường đa luồng. Thay đổi một trong các trường trước khi các luồng được bắt đầu có hiệu ứng thiết lập các mặc định trên toàn hệ thống. Thay đổi các trường sau khi các luồng đã bắt đầu không được khuyến nghị vì nó sẽ yêu cầu đồng bộ hóa luồng để ngăn chặn các điều kiện chủng tộc.

Trong các môi trường có ren đơn, tốt hơn là không sử dụng bối cảnh này. Thay vào đó, chỉ cần tạo bối cảnh rõ ràng như được mô tả dưới đây.

Các giá trị mặc định là ________ 294 = ________ 295, ________ 246 = ________ 93 và đã kích hoạt bẫy cho

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
03,
>>> 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')
8 và
>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')
9.

Ngoài ba bối cảnh được cung cấp, các bối cảnh mới có thể được tạo với hàm tạo

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
80.

classDecimal.Context (pre = none, rounding = none, emin = none, emax = none, capitals = none, kẹp = none, flags = none, bẫy = none) ¶ decimal.Context(prec=None, rounding=None, Emin=None, Emax=None, capitals=None, clamp=None, flags=None, traps=None)

Tạo ra một bối cảnh mới. Nếu một trường không được chỉ định hoặc là

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
02, các giá trị mặc định được sao chép từ
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
03. Nếu trường cờ không được chỉ định hoặc là
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
02, tất cả các cờ đều được xóa.

PREP là một số nguyên trong phạm vi [

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
31,
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
06] đặt độ chính xác cho các hoạt động số học trong bối cảnh.

Tùy chọn làm tròn là một trong những hằng số được liệt kê trong các chế độ làm tròn phần.

Các trường bẫy và cờ liệt kê bất kỳ tín hiệu nào được đặt. Nói chung, bối cảnh mới chỉ nên đặt bẫy và để lại những lá cờ rõ ràng.

Các trường Emin và Emax là các số nguyên chỉ định các giới hạn bên ngoài được phép cho số mũ. Emin phải nằm trong phạm vi [

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
07,
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
30], Emax trong phạm vi [
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
30,
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
10].

Trường thủ đô là

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
30 hoặc
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
31 (mặc định). Nếu được đặt thành
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
31, số mũ được in bằng vốn
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
14; Mặt khác, chữ thường
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
15 được sử dụng:
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
16.

Trường kẹp là

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
30 (mặc định) hoặc
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
31. Nếu được đặt thành
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
31, số mũ
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
15 của một thể hiện
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 có thể thể hiện trong bối cảnh này bị giới hạn nghiêm ngặt trong phạm vi
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
22. Nếu kẹp là
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
30 thì điều kiện yếu hơn sẽ giữ: số mũ được điều chỉnh của ví dụ
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 là tối đa
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
48. Khi kẹp là
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
31, một số lượng bình thường lớn sẽ, nếu có thể, có số mũ của nó giả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 số mũ; Điều này bảo tồn giá trị của số nhưng mất thông tin về số không có dấu vết đáng kể. Ví dụ:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
9

Giá trị kẹp của

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
31 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

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
80 xác định một số phương pháp mục đích chung cũng như một số lượng lớn các phương pháp để thực hiện số học trực tiếp trong một bối cảnh nhất định. Ngoài ra, đối với mỗi phương pháp
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 được mô tả ở trên (ngoại trừ các phương thức
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
30 và
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
31) có một phương pháp
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
80 tương ứng. Ví dụ: đối với một ví dụ
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
80
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
34 và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
61,
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
37 tương đương với
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
38. Mỗi phương thức
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
80 chấp nhận một số nguyên python (một ví dụ là
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
46) bất cứ nơi nào mà một ví dụ thập phân được chấp nhận.

Clear_flags ()()

Đặt lại tất cả các lá cờ về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
30.

Clear_traps ()()

Đặt lại tất cả các bẫy về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
30.

Mới trong phiên bản 3.3.

sao chép () ¶()

Trả lại một bản sao của bối cảnh.

copy_decimal (num) ¶(num)

Trả về một bản sao của số thập phân NUM.

created_decimal (num) ¶(num)

Tạo một ví dụ thập phân mới từ num nhưng sử dụng bản thân làm bối cảnh. Không giống như hàm tạo

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21, độ chính xác ngữ cảnh, phương pháp làm tròn, cờ và bẫy được áp dụng cho việc 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 một độ chính xác cao hơn so với ứng dụng cần thiết. 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 các đầu vào không có căn cứ có nghĩa là việc thêm 0 vào tổng có thể thay đổi kết quả:

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
0

Phương pháp này thực hiện hoạt động số lượng của đặc tả IBM. Nếu đối số là một chuỗi, không được phép có khoảng trắng hoặc dấu gạch dưới hàng đầu.

created_decimal_from_float (f) ¶(f)

Tạo một ví dụ thập phân mới từ một float f nhưng làm tròn bằng cách sử dụng bản thân làm bối cảnh. Không giống như phương pháp lớp

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
44, phương pháp độ chính xác ngữ cảnh, phương pháp làm tròn, cờ và bẫy được áp dụng cho việc chuyển đổi.

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
1

Mới trong phiên bản 3.1.

Etiny ()()

Trả về một giá trị bằng

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
45 là giá trị số mũ tối thiểu cho kết quả dưới mức. Khi dòng chảy xảy ra, số mũ được đặt thành
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
49.

Etop () ¶()

Trả về một giá trị bằng

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
47.

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 trường hợp

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 và sau đó áp dụng các hoạt động số học diễn ra trong bối cảnh hiện tại cho luồng hoạt động. Một cách tiếp cận khác là sử dụng các phương thức bối cảnh để tính toán trong một bối cảnh cụ thể. Các phương pháp tương tự như các phương pháp cho lớp
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 và chỉ được kể lại ngắn gọn ở đây.

abs (x)(x)

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

Thêm (x, y)(x, y)

Trả lại tổng của x và y.

Canonical (x)(x)

Trả về cùng một đối tượng thập phân x.

So sánh (x, y)(x, y)

So sánh x và y bằng số.

compare_signal (x, y) ¶(x, y)

So sánh các giá trị của hai toán hạng bằng số.

compare_total (x, y) ¶(x, y)

So sánh hai toán hạng bằng cách sử dụng đại diện trừu tượng của họ.

compare_total_mag (x, y) ¶(x, y)

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 họ, bỏ qua dấu hiệu.

copy_abs (x) ¶(x)

Trả về một bản sao của x với dấu được đặt thành 0.

copy_negate (x) ¶(x)

Trả về một bản sao của X với dấu hiệu đảo ngược.

COPY_SIGN (X, Y) ¶(x, y)

Sao chép dấu từ y đến x.

Chia (x, y) ¶(x, y)

Trả lại x chia cho y.

Divide_int (x, y) ¶(x, y)

Trả lại x chia cho y, cắt ngắn thành một số nguyên.

divmod (x, y) ¶(x, y)

Chia hai số và trả về phần số nguyên của kết quả.

exp (x)(x)

Trả lại

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
50.

FMA (X, Y, Z) ¶(x, y, z)

Trả về x nhân với y, cộng với z.

is_canonical (x) ¶(x)

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 nếu x là chính tắc; nếu không thì trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91.

is_finite (x)(x)

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 nếu x là hữu hạn; nếu không thì trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91.

is_infinite (x) ¶(x)

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 nếu x là vô hạn; nếu không thì trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91.

is_nan (x) ¶(x)

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 nếu x là qnan hoặc snan; nếu không thì trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91.

is_nquaral (x) ¶(x)

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 nếu x là số bình thường; nếu không thì trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91.

is_qnan (x)(x)

Trả lại

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 nếu X là một nan yên tĩnh; nếu không thì trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91.

is_signed (x) ¶(x)

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 nếu x là âm; nếu không thì trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91.

is_snan (x)(x)

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 nếu X là NAN báo hiệu; nếu không thì trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91.

is_subnormal (x) ¶(x)

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 Nếu X là Subnqualal; nếu không thì trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91.

is_zero (x)(x)

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 nếu x bằng 0; nếu không thì trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91.

ln (x)(x)

Trả về logarit tự nhiên (cơ sở e) của x.

log10 (x)(x)

Trả về cơ sở 10 logarit của x.

logb (x)(x)

Trả về số mũ của cường độ của toán hạng MSD MSD.

logic_and (x, y) ¶(x, y)

Áp dụng hoạt động logic và giữa mỗi chữ số của toán hạng.

Logical_invert (x)(x)

Đảo ngược tất cả các chữ số trong x.

logical_or (x, y) ¶(x, y)

Áp dụng hoạt động logic hoặc giữa mỗi chữ số của toán hạng.

Logical_xor (x, y) ¶(x, y)

Áp dụng hoạt động logic XOR giữa mỗi chữ số của toán hạng.

tối đa (x, y) ¶(x, y)

So sánh hai giá trị bằng số và trả về tối đa.

max_mag (x, y) ¶(x, y)

So sánh các giá trị bằng số với dấu hiệu của chúng bị bỏ qua.

Min (x, y)(x, y)

So sánh hai giá trị bằng số và trả về tối thiểu.

min_mag (x, y) ¶(x, y)

So sánh các giá trị bằng số với dấu hiệu của chúng bị bỏ qua.

Min (x, y)(x)

So sánh hai giá trị bằng số và trả về tối thiểu.

min_mag (x, y) ¶(x, y)

trừ (x)

Minus tương ứng với toán tử tiền tố Unary trừ trong Python.(x)

Nhân (x, y) ¶

Trả lại sản phẩm của X và Y.(x)

next_minus (x) ¶

Trả về số đại diện lớn nhất nhỏ hơn x.(x, y)

next_plus (x) ¶

Trả về số đại diện nhỏ nhất lớn hơn x.(x)

next_toward (x, y) ¶

Trả về số gần nhất với x, theo hướng về y.(x)

Bình thường hóa (x)

Giảm x xuống dạng đơn giản nhất của nó.(x)

Number_Class (x)

Trả về một dấu hiệu của lớp x.(x, y, modulo=None)

cộng (x)

Cộng với tương ứng với toán tử PREFIX Plus trong Python. Hoạt động này áp dụng độ chính xác và làm tròn ngữ cảnh, vì vậy nó không phải là một hoạt động nhận dạng.

sức mạnh (x, y, modulo = none) ¶

Trả lại

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
61 cho sức mạnh của
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
62, giảm modulo
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
73 nếu được đưa ra.The C module computes
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
82 in terms of the correctly rounded
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
83 and
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
84 functions. The result is well-defined but only “almost always correctly rounded”.

Với hai đối số, tính toán

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
74. Nếu
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
61 âm thì
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
62 phải không thể thiếu. Kết quả sẽ không chính xác trừ khi
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
62 là không thể thiếu và kết quả là hữu hạn và có thể được thể hiện chính xác trong 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.

  • >>> from decimal import *
    >>> getcontext().prec = 6
    >>> Decimal(1) / Decimal(7)
    Decimal('0.142857')
    >>> getcontext().prec = 28
    >>> Decimal(1) / Decimal(7)
    Decimal('0.1428571428571428571428571429')
    
    78 dẫn đế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')
    
    8 và nếu
    >>> 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')
    
    8 không bị mắc kẹt, thì kết quả là
    >>> from decimal import *
    >>> getcontext().prec = 6
    >>> Decimal(1) / Decimal(7)
    Decimal('0.142857')
    >>> getcontext().prec = 28
    >>> Decimal(1) / Decimal(7)
    Decimal('0.1428571428571428571428571429')
    
    81.

  • Đã thay đổi trong phiên bản 3.3: Mô -đun C tính toán

    >>> from decimal import *
    >>> getcontext().prec = 6
    >>> Decimal(1) / Decimal(7)
    Decimal('0.142857')
    >>> getcontext().prec = 28
    >>> Decimal(1) / Decimal(7)
    Decimal('0.1428571428571428571428571429')
    
    82 theo các hàm được làm tròn chính xác
    >>> from decimal import *
    >>> getcontext().prec = 6
    >>> Decimal(1) / Decimal(7)
    Decimal('0.142857')
    >>> getcontext().prec = 28
    >>> Decimal(1) / Decimal(7)
    Decimal('0.1428571428571428571428571429')
    
    83 và
    >>> from decimal import *
    >>> getcontext().prec = 6
    >>> Decimal(1) / Decimal(7)
    Decimal('0.142857')
    >>> getcontext().prec = 28
    >>> Decimal(1) / Decimal(7)
    Decimal('0.1428571428571428571428571429')
    
    84. Kết quả được xác định rõ nhưng chỉ có hầu như luôn luôn được làm tròn chính xác.

  • Với ba đối số, tính toán

    >>> from decimal import *
    >>> getcontext().prec = 6
    >>> Decimal(1) / Decimal(7)
    Decimal('0.142857')
    >>> getcontext().prec = 28
    >>> Decimal(1) / Decimal(7)
    Decimal('0.1428571428571428571428571429')
    
    85. Đối với biểu mẫu đối số ba, các hạn chế sau đối với các đối số giữ:

  • Cả ba đối số phải không thể thiếu

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
62 phải không âm

Ít nhất một trong số
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
61 hoặc
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
62 phải là không
(x, y)

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
73 phải là khác không và có nhiều nhất là các chữ số chính xác

Giá trị kết quả từ
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
90 bằng với giá trị sẽ thu được bằng cách tính toán
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
91 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 không, bất kể số mũ của
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
61,
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
62 và
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
73. Kết quả luôn luôn chính xác.
()

Quantize (x, y) ¶

Trả về một giá trị bằng x (tròn), có số mũ của y.(x, y)

radix ()

Dấu hiệu của kết quả, nếu khác không, giống như cổ tức ban đầu.

phần còn lại_near (x, y) ¶(x, y)

Trả về

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
95, trong đó n là số nguyên gần nhất là giá trị chính xác của
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
96 (nếu kết quả là 0 thì dấu của nó sẽ là dấu hiệu của x).

xoay (x, y) ¶(x, y)

Trả về một bản sao xoay của x, y lần.

are more_quantum (x, y) ¶(x, y)

Trả về

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90 Nếu hai toán hạng có cùng số mũ.

scaleB (x, y) ¶(x, y)

Trả về toán hạng đầu tiên sau khi thêm giá trị thứ hai exp của nó.

Shift (x, y)(x, y)

Trả về một bản sao thay đổi của X, Y Times.

sqrt (x)(x)

Căn bậc hai của một số không âm đến độ chính xác ngữ cảnh.

Trừ (x, y) ¶(x, y)

Trả về sự khác biệt giữa x và y.

to_eng_string (x) ¶(x)

Chuyển đổi thành một chuỗi, sử dụng ký hiệu kỹ thuật nếu cần một số mũ.

Kỹ thuật ký hiệu có số mũ là bội số của 3. Điều này có thể để lại tới 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ố không kéo dài.

to_integral_exact (x) ¶(x)

Vòng vào một số nguyên.

TO_SCI_STRING (x) ¶(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ố trong

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 Pure Python để tương thích.

32-bit

64-bit

decimal.max_prec¶MAX_PREC

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
98

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
99

decimal.max_emax¶MAX_EMAX

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
98

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
99

decimal.min_emin¶MIN_EMIN

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

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

decimal.min_etiny¶MIN_ETINY

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

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

decimal.have_threads¶HAVE_THREADS

Giá trị là

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90. Không dùng nữa, bởi vì Python bây giờ luôn có chủ đề.

Không dùng nữa kể từ phiên bản 3.9.

decimal.have_contextvar¶HAVE_CONTEXTVAR

Giá trị mặc định là

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90. Nếu Python 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 precision
08, phiên bản C sử dụng một địa phương thay vì bối cảnh coroutine-local và giá trị là
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91. Điều này nhanh hơn một chút trong một số kịch bản bối cảnh lồng nhau.

Mới trong phiên bản 3.9: Được ba chiều đến 3,7 và 3,8.backported to 3.7 and 3.8.

Chế độ làm tròn

decimal.round_ceiling¶ROUND_CEILING

Vòng hướng tới

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
4.

decimal.round_down¶ROUND_DOWN

Vòng về phía 0.

decimal.round_floor¶ROUND_FLOOR

Vòng hướng tới

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
5.

decimal.round_half_down¶ROUND_HALF_DOWN

Vòng đến gần nhất với các mối quan hệ đi về phía 0.

Decimal.Round_Half_Even¶ROUND_HALF_EVEN

Vòng đến gần nhất với các mối quan hệ đi đến gần nhất thậm chí số nguyên.

decimal.round_half_up¶ROUND_HALF_UP

Vòng đến gần nhất với các mối quan hệ đi xa từ số không.

decimal.round_up¶ROUND_UP

Làm tròn từ số không.

Decimal.Round_05Up¶ROUND_05UP

Là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; nếu không tròn về phía bằng không.

Tín hiệu/

Tín hiệu đại diện cho các điều kiện phát sinh trong quá trình tính toán. Mỗi tương ứng với một cờ bối cảnh và một trình tạo bẫy ngữ cảnh.

Cờ bối cảnh được đặt bất cứ khi nào điều kiện gặp phải. 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 việc tính toán có chính xác hay không). Sau khi kiểm tra các cờ, hãy chắc chắn xóa tất cả các cờ trước khi bắt đầu tính toán tiếp theo.

Nếu bộ tạo bẫy bẫy ngữ cảnh được đặt cho tín hiệu, thì điều kiện này sẽ gây ra ngoại lệ python. Ví dụ: nếu bẫy

>>> 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 được đặt, thì ngoại 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')
9 được tăng lên khi gặp phải điều kiện.

ClassDecimal.Clamped¶decimal.Clamped

Thay đổi một số mũ để phù hợp với các ràng buộc đại diện.

Thông thường, việc kẹp xảy ra khi một số mũ nằm ngoài bối cảnh giới hạ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 precision
14 và
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
48. Nếu có thể, số mũ được giảm để phù hợp bằng cách thêm số không vào hệ số.

classdecimal.decimalexception¶ decimal.DecimalException

Lớp cơ sở cho các tín hiệu khác và một lớp con 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 precision
16.

classdecimal.divisionbyzero¶ decimal.DivisionByZero

Báo hiệu sự phân chia của một số không vô hạn theo 0.

Có thể xảy ra với sự phân chia, phân chia modulo hoặc khi nâng một số lên một sức mạnh tiêu cực. Nếu tín hiệu này không bị mắc kẹt, trả về

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
4 hoặc
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
5 với dấu hiệu được xác định bởi các đầu vào cho phép tính.

classdecimal.inexact¶decimal.Inexact

Chỉ ra rằng làm tròn xảy ra và kết quả là không chính xác.

Tín hiệu khi các chữ số khác không bị loại bỏ trong quá trình làm tròn. Kết quả tròn được trả lại. Cờ tín hiệu hoặc bẫy được sử dụng để phát hiện khi kết quả không chính xác.

classdecimal.invalidoperation¶decimal.InvalidOperation

Một hoạt động không hợp lệ đã được thực hiện.

Chỉ ra rằng một hoạt động đã được yêu cầu không có ý nghĩa. Nếu không bị mắc kẹt, trả về

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6. Nguyên nhân có thể bao gồm:

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
2

ClassDecimal.Overflow¶decimal.Overflow

Tràn số.

Cho biết số mũ lớn hơn

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
48 sau khi làm tròn đã xảy ra. Nếu không bị mắc kẹt, kết quả phụ thuộc vào chế độ làm tròn, hoặc kéo vào trong số lượng hữu hạn lớn nhất có thể đại diện hoặc làm tròn ra ngoài đến
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
4. Trong cả hai trường hợp,
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
00 và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
01 cũng được báo hiệu.

ClassDecimal.Rounded¶ decimal.Rounded

Làm tròn xảy ra mặc dù có thể không có thông tin bị mất.

Báo hiệu bất cứ khi nào làm tròn loại bỏ các chữ số; Ngay cả khi các chữ số đó bằng không (chẳng hạn như 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 precision
24 đế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 precision
25). Nếu không bị mắc kẹt, trả về kết quả không thay đổi. Tín hiệu này được sử dụng để phát hiện mất các chữ số quan trọng.

classdecimal.subnitoral¶decimal.Subnormal

Số mũ thấp hơ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 precision
14 trước khi làm tròn.

Xảy ra khi kết quả hoạt động là dưới mức (số mũ quá nhỏ). Nếu không bị mắc kẹt, trả về kết quả không thay đổi.

classdecimal.underflow¶decimal.Underflow

Dòng chảy số với kết quả được làm tròn đến 0.

Xảy ra khi một kết quả dưới mức được đẩy về 0 bằng cách làm tròn.

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
00 và
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
02 cũng được báo hiệu.

classdecimal.floatoperation¶ decimal.FloatOperation

Cho phép ngữ nghĩa chặt chẽ hơn để trộn phao và số thập phân.

Nếu tín hiệu không bị mắc kẹt (mặc định), trộn các phao và số thập phân được cho phép trong hàm tạo

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21,
>>> 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
30 và tất cả các toán tử so sánh. Cả chuyển đổi và so sánh là chính xác. Bất kỳ sự xuất hiện nào của một hoạt động hỗn hợp đều được ghi lại âm thầm bằng cách đặt
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
05 trong các cờ ngữ cảnh. Chuyển đổi rõ rà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 precision
32 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 precision
33 không đặt cờ.

Mặt khác (tín hiệu bị mắc kẹt), chỉ so sánh bình đẳng và chuyển đổi rõ ràng là im lặng. Tất cả các hoạt động hỗn hợp khác tăng

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
05.

Bảng sau đây tóm tắt phân cấp tín hiệu:

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
3

Ghi chú điểm nổi

Giảm thiểu lỗi làm tròn với độ chính xác tăng

Việc sử dụng điểm nổi thập phân giúp loại bỏ lỗi biểu diễn thập phân (chính xác là biểu hiện chính xá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 precision
35); Tuy nhiên, một số hoạt động vẫn có thể gây ra lỗi làm tròn khi các chữ số khác không vượt quá độ chính xác cố định.

Các ảnh hưởng của lỗi làm tròn có thể được khuếch đại bằng cách bổ sung hoặc trừ các số lượng gần như bù đắp dẫn đến mất ý nghĩa. Knuth cung cấp hai ví dụ mang tính hướng dẫn trong đó số học điểm nổi tròn với độ chính xác không đủ gây ra sự cố của các thuộc tính liên kết và phân phối của việc bổ sung:

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
4

Mô -đun

>>> 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 cho phép khôi phục danh tính bằng cách mở rộng độ chính xác đủ để tránh mất ý nghĩa:

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
5

Giá trị đặc biệt

Hệ thống số cho mô -đun

>>> 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 cung cấp các giá trị đặc biệt bao gồm
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6,
>>> 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
39,
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
5,
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
4 và hai số không,
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
8 và
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
7.

Tính không đồng nhất có thể được xây dựng trực tiếp với:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
17. Ngoài ra, chúng có thể phát sinh từ việc chia cho 0 khi tín hiệu
>>> 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 không bị mắc kẹt. Tương tự như vậy, khi tín hiệu
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
03 không bị mắc kẹt, vô cực có thể là kết quả của việc làm tròn vượt quá giới hạn của số lượng đại diện lớn nhất.

Các tính không đồng thời được ký kết (affine) và có thể được sử dụng trong các hoạt động số học nơi chúng được đối xử là những con số rất lớn, không xác định. Chẳng hạn, việc thêm một hằng số vào vô cực cho kết quả vô hạn khác.

Một số hoạt động không xác định và trả về

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6 hoặc nếu tín hiệu
>>> 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')
8 bị mắc kẹt, hãy tăng một ngoại lệ. 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 precision
49 trả về
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6 có nghĩa là không phải là một số. Sự đa dạng của
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6 này là yên tĩnh và, một khi được tạo ra, sẽ chảy qua các tính toán khác luôn dẫn đến một
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6 khác. Hành vi này có thể hữu ích cho một loạt các tính toán đôi khi bị thiếu đầu vào - nó cho phép tính toán tiến hành trong khi gắn cờ các kết quả cụ thể là không hợp lệ.

Một biến thể 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 precision
39 báo hiệu thay vì giữ im lặng sau mỗi hoạt động. Đây là một giá trị trả lại hữu ích khi kết quả không hợp lệ cần làm gián đoạn tính toán để xử lý đặc biệt.

Hành vi của các nhà khai thác so sánh Python có thể hơi ngạc nhiên khi có liên quan đến

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6. Một bài kiểm tra cho sự bình đẳng trong đó một trong các toán hạng là một sự yên tĩnh hoặc tín hiệu
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6 luôn trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91 (ngay cả khi thực 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 precision
57), trong khi một bài kiểm tra cho sự bất bình đẳng luôn trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
90. Một nỗ lực để so sánh hai số thập phân bằng cách sử dụng bất kỳ toán tử
>>> 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
59,
>>> 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
60,
>>> 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
61 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 precision
62 sẽ tăng tín hiệu
>>> 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')
8 nếu một trong hai toán hạng là
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6 và trả về
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
91 nếu tín hiệu này không bị mắc kẹt. Lưu ý rằng đặc tả số học thập phân chung không chỉ định hành vi so sánh trực tiếp; Các quy tắc này để so sánh liên quan đến
>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []
6 đã được lấy từ tiêu chuẩn IEEE 854 (xem Bảng 3 trong Phần 5.7). Để đảm bảo tuân thủ các tiêu chuẩn nghiêm ngặt, thay vào đó, hãy sử dụng các phương thức
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
69 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 precision
68.

Các số không có chữ ký có thể là kết quả của các tính toán mà dòng chảy. Họ giữ các dấu hiệu sẽ dẫn đến nếu tính toán đã được thực hiện đến độ chính xác cao hơn. Vì cường độ của chúng bằng không, cả các số 0 dương và âm được coi là bằng nhau và dấu hiệu của chúng là thông tin.

Ngoài hai số không có chữ ký khác biệt nhưng có nhiều biểu diễn khác nhau có số 0 với các giá trị khác nhau vẫn tương đương về giá trị. Điều này mất một chút làm quen. Đối với một mắt quen thuộc với các biểu diễn điểm nổi được chuẩn hóa, không rõ ràng rằng tính toán sau đây trả về một giá trị bằng 0:

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
6

Làm việc với chủ đề

Hàm

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
06 truy cập vào một đối tượng
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
80 khác nhau cho mỗi luồng. Có bối cảnh luồng riêng biệt có nghĩa là các luồng có thể thực hiện các thay đổi (chẳng hạn như
>>> 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
71) mà không can thiệp vào các luồng khác.

Tương tự như vậy, hàm

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
14 tự động gán mục tiêu của nó cho luồng hiện tại.

Nếu

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
14 chưa được gọi trước
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
06, thì
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
06 sẽ tự động tạo bối cảnh mới để sử dụng trong luồng hiện tại.

Bối cảnh mới được sao chép từ bối cảnh nguyên mẫu gọi là DefaultContext. Để kiểm soát các mặc định để mỗi luồng sẽ sử dụng cùng một giá trị trong toàn bộ ứng dụng, hãy trực tiếp sửa đổi đối tượng DefaultContext. Điều này nên được thực hiện trước khi bất kỳ chủ đề nào được bắt đầu để có được một điều kiện cuộc đua giữa các luồng gọi

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
06. Ví dụ:

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
7

Công thức nấu ăn¶

Dưới đây là một vài công thức nấu ăn là chức năng tiện ích và thể hiện các cách để làm việc với lớp

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21:

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
8

Câu hỏi thường gặp về thập phân

Q. Nó là cồng kềnh để loạ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 precision
78. Có cách nào để giảm thiểu việc gõ khi sử dụng trình thông dịch tương tác không?

A. Một số người dùng viết tắt hàm tạo thành một chữ cái:

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
9

Q. Trong một ứng dụng điểm cố định với hai vị trí thập phân, một số đầu vào có nhiều nơi và cần phải được làm tròn. Những người khác không được phép có các chữ số dư thừa và cần phải được xác nhận. Những phương pháp nào nên được sử dụng?

A. Phương pháp

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
12 làm tròn đến một số vị trí thập phân cố định. Nếu bẫy
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
00 được đặt, nó cũng hữu ích cho việc xác thự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 precision
0

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

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

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

Q. Khi tôi có hai đầu vào hai địa điểm hợp lệ, làm thế nào để duy trì bất biến đó trong suốt một ứng dụng?

A. Một số hoạt động như bổ sung, trừ và phép nhân bằng một số nguyên sẽ tự động bảo tồn điểm cố định. Các hoạt động khác, như phép nhân chia và không số nguyên, sẽ thay đổi số lượng vị trí thập phân và cần phải được theo dõi với bước

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
12:

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

Trong việc phát triển các ứng dụng điểm cố định, thật thuận tiện khi xác định các chức năng để xử lý bước

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
12:

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

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

Q. Có nhiều cách để thể hiện cùng một giá trị. Các 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 precision
83,
>>> 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
84,
>>> 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
85 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 precision
86 đều có cùng giá trị ở các quy tắc khác nhau. Có cách nào để biến chúng thành một giá trị kinh điển có thể nhận ra duy nhất không?

A. Phương pháp

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision
87 ánh xạ tất cả các giá trị tương đương vào một đại diện duy nhấ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 precision
7

Q. Một số giá trị thập phân luôn in với ký hiệu theo cấp số nhân. Có cách nào để có được một đại diện không theo nhân viên không?

A. Đối với một số giá trị, ký hiệu theo cấp số nhân là cách duy nhất để thể hiện số lượng vị trí quan trọng trong hệ số. Ví dụ, biểu 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 precision
88 dưới 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 precision
89 giữ cho giá trị không đổi nhưng không thể hiển thị ý nghĩa hai vị trí ban đầu.

Nếu một ứng dụng không quan tâm đến việc theo dõi ý nghĩa, thì dễ dàng loại bỏ số mũ và số không, mất ý nghĩa, nhưng giữ cho giá trị không thay đổ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 precision
8

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

Q. Có cách nào để chuyển đổi một chiếc phao thông thường thành

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
21 không?

A. Có, bất kỳ số điểm nổi nhị phân nào cũng có thể được biểu thị chính xác dưới dạng thập phân mặc dù chuyển đổi chính xác có thể có độ chính xác hơn so với trực giác sẽ đề xuấ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

H: Trong một tính toán phức tạp, làm thế nào tôi có thể đảm bảo rằng tôi đã nhận được một kết quả giả vì không đủ độ chính xác hoặc làm tròn dị thường.

A. Mô -đun thập phân giúp bạn dễ dàng kiểm tra kết quả. Một thực tiễn tốt nhất là chạy lại các tính toán bằng cách sử dụng độ chính xác cao hơn và với các chế độ làm tròn khác nhau. Kết quả khác nhau cho thấy độ chính xác không đủ, các vấn đề chế độ làm tròn, đầu vào không điều hòa hoặc thuật toán không ổn định về số lượng.

H: Tôi nhận thấy rằng độ chính xác ngữ cảnh được áp dụng cho kết quả hoạt động nhưng không phải là đầu vào. Có bất cứ điều gì để coi chừng khi trộn các giá trị của các quy định khác nhau?

A. Có. 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 cho các đầu vào là những gì bạn gõ là những gì bạn nhận được. Một bất lợi là kết quả có thể trông kỳ lạ nếu bạn quên rằng các đầu vào đã được làm trò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')
1

Giải pháp là tăng độ chính xác hoặc buộc làm tròn các đầu vào bằng cách sử dụng hoạt động Unary Plus:

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

Ngoài ra, các đầu vào có thể được làm tròn khi tạo bằng phương pháp

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision
91:

>>> 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')
3

Q. Việc triển khai CPython có nhanh cho số lượng lớn không?

A. Có. Trong các 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 chính xác được làm tròn chính xác số.

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.

>>> 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
14 và
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
48 phải luôn được đặt thành các giá trị tối đ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 precision
95 phải luôn là 0 (mặc định).Cài đặt
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
94 yêu cầu một số chăm sóc.

Cách tiếp cận dễ nhất để thử số học Bignum là sử dụng giá trị tối đa cho

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
94 cũng như 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')
4

Đối với kết quả không chính xác,

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
06 quá lớn trên các nền tảng 64 bit và bộ nhớ có sẵn sẽ khô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')
5

Trên các hệ thống có tổng thể (ví dụ: Linux), một cách tiếp cận tinh vi hơn là điều chỉnh

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
94 theo lượng RAM có sẵn.Giả sử rằng bạn có 8GB RAM và mong đợi 10 toán hạng đồng thời bằng cách sử dụng tối đa 500MB mỗi lầ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')
6

Nói chung (và đặc biệt là trên các hệ thống không có tổng thể), nên ước tính các giới hạn chặt chẽ hơn và đặt bẫy

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)
00 nếu tất cả các tính toán được dự kiến chính xác.

1

Mới trong phiên bản 3.3.

2

Đã thay đổi trong phiên bản 3.9: Cách tiếp cận này hiện hoạt động cho tất cả các kết quả chính xác ngoại trừ các quyền hạn không định nghĩa.This approach now works for all exact results except for non-integer powers.