search

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

Ngày đăng: 15/11/2022
Trả lời: 0
Lượt xem: 89

Như đã được nêu trong vô số lần, 0.1 không thể được thể hiện chính xác trong điểm nổi của IEEE 754. Bạn có thể đọc tất cả về lý do tại sao trong những gì mọi nhà khoa học máy tính nên biết về số học dấu phẩy động hoặc hướng dẫn điểm nổi

Show

Bạn có thể trucate hoặc làm tròn giá trị:

>>> round(1.1+.1,2)
1.2
>>> "%.*f" % (1, 1.1+.1 )
'1.2'
>>> s=str(1.1+.1)
>>> s[0:s.find('.')+2]
'1.2'

Nếu bạn muốn biểu diễn chính xác của các giá trị đó, hãy xem xét sử dụng mô -đun thập phân:

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')

Lưu ý rằng bạn cần bắt đầu với biểu diễn chuỗi của chiếc phao của bạn, 

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
9 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
0 không thể đại diện chính xác trong nhị phân ở điểm nổi của IEEE:

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')

Để lấy lại một đại diện chuỗi sau khi bạn tính toán, bạn có thể sử dụng 

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

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

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'

Một cách khác là sử dụng thư viện số hợp lý như phân số:

>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)

Với kết quả đó, bạn vẫn sẽ cần phải làm tròn, cắt ngắn hoặc sử dụng gói số học chính xác tùy ý để có được một con số chính xác (tùy thuộc vào đầu vào ...)

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

Mô -đun 

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

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

    >>> 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 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
    5 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 
    >>> 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 sẽ hiể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
    7 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, 

    >>> 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 chính xác bằng không. Trong điểm nổi nhị phân, kết quả 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
    9. 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 = 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 là 
    >>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
    1. 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, 
    >>> 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 cho 
    >>> 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 trong khi 
    >>> 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 cho 
    >>> 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.

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

>>> 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, 
>>> 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 và 
>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
8. Tiêu chuẩn cũng khác biệ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')
9 với 
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True
0.

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 

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

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

>>> 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, 
>>> 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, 
>>> 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, 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
2, 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
3, 
>>> 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, 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
5, 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
6 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')
7.

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

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

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
8 là viết tắt của không phải là một số, dương và âm 
>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
6 và 
>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
9:

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

>>> 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 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ẽ tăng 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 

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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
0

Đã 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ỏ:

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
1

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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
2

Phương pháp 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
04 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:

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
3

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

>>> 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 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 hàm 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
06.

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

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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
4

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 thức 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
10.

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
5

Mục nhập cờ cho thấy mức độ gần đúng hợp lý với 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
11 đượ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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
12 của bối cảnh:

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
6

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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 mới dựa trên giá trị.

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

>>> 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 hoặc đối tượng 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 khác. Nếu không có giá trị nào được đưa ra, trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
17. 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ỏ:

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
7

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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
18 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 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
19 đến 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
20.

Nếu giá trị là 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
21, nó sẽ có ba thành phần, một dấu hiệu (
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
22 cho dương hoặc 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
23 cho âm), 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
21 của các chữ số và số mũ số nguyên. Ví dụ: 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
25 trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
26.

Nếu giá trị là 

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

>>> getcontext().prec = 7       # Set a new precision
3, giá trị điểm nổi nhị phân được chuyển đổi 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ụ, 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
28 chuyển đổi thành 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
29.

Độ 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ụ, 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
30 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 

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

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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 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ụ 

>>> 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.The argument to the constructor is now permitted to be 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
3 instance.

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

>>> 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 đối số nêu ra một ngoại lệ nếu bẫy 
>>> 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 được đặt. Theo mặc định, bẫy bị tắ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
3 arguments raise an exception if the 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
7 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ư 

>>> 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 và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
38. 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ư 
>>> 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 hoặc 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
38).

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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
41 đượ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ố:

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
8

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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
42 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 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
43:

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
9

Các toán tử 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
41 và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
42 thực hiện các hoạt động 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
46 và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
47 (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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
48 trong các hoạt động số học: ví dụ, một nỗ lực để thêm 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 vào 
>>> 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, chẳng hạn, sẽ tăng 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
51. Tuy nhiên, có thể sử dụng các toán tử so sánh Python, để so sánh một ví dụ 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
53 với một số khác 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
54. Đ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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 và các loại số khác hiện được hỗ trợ đầy đủ.Mixed-type comparisons between 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 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ì: 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
56 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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
57 của các số nguyên đại diện cho ví dụ 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 đã cho là một phần, theo mức thấp nhất và với mẫu số tích cực:

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
0

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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
59.named tuple representation of the number: 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
59.

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ụ 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 luôn luôn là 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. 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
61 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:

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
1

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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
61, 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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
61, nhưng kết quả đưa ra tổng số đặt hàng trên các trường hợp 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13. Hai trường hợp 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 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:

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
2

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à 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
17 nếu cả hai toán hạng có cùng một biểu diễn, 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
67 nếu toán hạng đầu tiên thấp hơn trong tổng thứ tự so với thứ hai và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
68 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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
69, nhưng bỏ qua dấu hiệu của mỗi toán hạng. 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
70 tương đương với 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
71.

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

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
3

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) 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
72 tại số đã cho. Kết quả được làm tròn chính xác bằng chế độ làm trò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
5.

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
4

classmethodfrom_float (f) ¶from_float(f)

Hàm tạo thay thế chỉ chấp nhận các trường hợ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
3 hoặc 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
38.

Lưu ý 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
76 không giống như 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
77. 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à 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
78. Giá trị tương đương đó trong thập phân là 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
79.

Ghi chú

Từ Python 3.2 trở đi, một ví dụ 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 cũng có thể được xây dựng trực tiếp 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
3.

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
5

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.

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
6

is_canonical ()()

Trả lại 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 Nếu đối số là chính tắc và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83 khác. Hiện tại, một ví dụ 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 luôn luôn có kinh điển, vì vậy hoạt động này luôn trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82.

is_finite () ¶()

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 Nếu đối số là số hữu hạn và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83 nếu đối số là vô cực hoặc NAN.

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

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 nếu đối số là vô cùng dương hoặc âm và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83 khác.

is_nan ()()

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 Nếu đối số là một (yên tĩnh hoặc báo hiệu) NAN và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83 nếu không.

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

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 Nếu đối số là số hữu hạn bình thường. Trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83 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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 Nếu cuộc tranh luận là một NAN yên tĩnh và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83 khác.

is_sign ()()

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 Nếu đối số có dấu âm và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83 khác. Lưu ý rằng cả Zeros và Nans đều có thể mang dấu hiệu.

is_snan ()()

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 Nếu đối số là NAN báo hiệu và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83 khác.

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

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 Nếu đối số là không bình thường và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83 khác.

is_zero ()()

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 Nếu đối số là (dương hoặc âm) bằng không và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83 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 

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

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 

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

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ụ 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13. Nếu toán hạng bằng 0 thì 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
07 sẽ được trả về và 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')
1 được nâng lên. Nếu toán hạng là vô cực thì 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
09 sẽ được trả về.

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

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
10 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ố 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
11 của hai toán hạng.Logical operands). The result is the digit-wise 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
11 of the two operands.

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

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
12 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)

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
13 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ố 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
14 của hai toán hạng.Logical operands). The result is the digit-wise 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
14 of the two operands.

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

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
15 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ư 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
16 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ị 
>>> 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 đượ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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
18, 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ư 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
19 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ị 
>>> 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 đượ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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
21, 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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
17 thành 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
23. Đượ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ụ, 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
24 và 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
25 đều bình thường hóa thành giá trị tương đương 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
26.

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.

  • >>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
    27, chỉ ra rằng toán hạng là vô cùng tiêu cực.

  • >>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
    28, chỉ ra rằng toán hạng là số bình thường âm.

  • >>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
    29, chỉ ra rằng toán hạng là âm và dưới mức.

  • >>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
    30, chỉ ra rằng toán hạng là số 0 âm.

  • >>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
    31, chỉ ra rằng toán hạng là số 0 dương.

  • >>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
    32, chỉ ra rằng toán hạng là dương và dưới mức.

  • >>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
    33, chỉ ra rằng toán hạng là số bình thường dương.

  • >>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
    34, chỉ ra rằng toán hạng là vô cùng dương tính.

  • >>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
    35, chỉ ra rằng toán hạng là một nan yên tĩnh (không phải là một số).

  • >>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
    36, 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.

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
7

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ì 

>>> 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 đượ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ố 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
38 nếu được đưa ra, khác bởi đối số 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
39 đã 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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
40 hoặc nhỏ hơn 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
41.

radix ()()

Trả về 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
42, radix (cơ sở) trong đó lớp 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
44 ở 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à 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
45 trong đó 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
46 là số nguyên gần nhất với giá trị chính xác của 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
47, 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.

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
8

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à 

>>> 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 hay khô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.

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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
49. 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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
50 thành 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
51.

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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
52. Tên 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
53 đã đượ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 

>>> 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 hoặc 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
3 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ố 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
38 nếu được đưa ra, khác bởi 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
39 đã 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)

Tròn đến số nguyên gần nhất mà không có tín hiệ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')
2 hoặc 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
3. 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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
10, 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
12, 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
13 và 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
15 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 ví dụ 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 có số mũ và dấu hiệu cả bằng không và các chữ số của họ đều là 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
22 hoặc 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
23.

Đố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ó bối cảnh hiện tại riêng được truy cập hoặc thay đổi bằng các hàm 

>>> 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 và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
06:

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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
69 và hàm 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
70 để 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 đó:

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
9

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

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
0

Tăng 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
51 nếu Kwargs cung cấp một thuộc tính mà 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
72 không hỗ trợ. Tăng 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
51 hoặc 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
74 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: 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
70 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.
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
70 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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
72 đượ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 

>>> 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. 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ừ 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
2, 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
3 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')
4.

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 

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

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

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
72 làm nguyên mẫu cho các bối cảnh mới. Thay đổi một trường (độ chính xác như vậy) có tác dụng thay đổi mặc định cho các bối cảnh mới được tạo bởi hàm tạo 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
72.

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à ________ 286 = ________ 287, ________ 238 = ________ 85 và đã kích hoạt bẫy cho 

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
5, 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
0 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')
1.

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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
72.

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à 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
94, các giá trị mặc định được sao chép từ 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
95. Nếu trường Cờ không được chỉ định hoặc là 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
94, tất cả các cờ đều được xóa.

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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
23, 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
98] đặ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 [

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
99, 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
22], Emax trong phạm vi [
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
22, 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
02].

Trường thủ đô là 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
22 hoặc 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
23 (mặc định). Nếu được đặt thành 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
23, số mũ được in bằng vốn 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
06; Mặt khác, chữ thường 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
07 được sử dụng: 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
08.

Trường kẹp là 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
22 (mặc định) hoặc 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
23. Nếu được đặt thành 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
23, số mũ 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
07 của một thể hiện 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 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 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
14. Nếu kẹp là 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
22 thì một điều kiện yếu hơn giữ: số mũ được điều chỉnh của ví dụ 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 là tối đa 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
40. Khi kẹp là 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
23, 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ụ:

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
1

Giá trị kẹp của 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
23 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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
72 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 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 được mô tả ở trên (ngoại trừ các phương thức 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
22 và 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
23) có một phương pháp 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
72 tương ứng. Ví dụ: đối với một ví dụ 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
72 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
26 và 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
53, 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
29 tương đương với 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
30. Mỗi phương thức 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
72 chấp nhận một số nguyên python (một ví dụ là 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
38) 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 cờ thành 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
22.

Clear_traps ()()

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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
22.

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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13, phương pháp độ chính xác bối 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ả:

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
2

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 

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
36, 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.

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
3

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

Etiny ()()

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

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
37 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 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
41.

Etop () ¶()

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

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
39.

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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 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 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 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ả về 

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
42.

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ề 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 nếu x là chính tắc; Nếu không, trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83.

is_finite (x)(x)

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 nếu x là hữu hạn; Nếu không, trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83.

is_infinite (x) ¶(x)

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 nếu x là vô hạn; Nếu không, trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83.

is_nan (x) ¶(x)

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 nếu x là qnan hoặc snan; Nếu không, trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83.

is_nquaral (x) ¶(x)

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 nếu x là số bình thường; Nếu không, trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83.

is_qnan (x)(x)

Trả lại 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 nếu X là một nan yên tĩnh; Nếu không, trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83.

is_signed (x) ¶(x)

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 nếu x là âm; Nếu không, trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83.

is_snan (x)(x)

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 nếu X là NAN báo hiệu; Nếu không, trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83.

is_subnormal (x) ¶(x)

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 nếu x là dưới mức; Nếu không, trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83.

is_zero (x)(x)

Trả về 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 nếu x bằng 0; Nếu không, trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83.

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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
53 cho sức mạnh của 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
54, giảm modulo 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
65 nếu được đưa ra.The C module computes 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
74 in terms of the correctly rounded 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
75 and 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
76 functions. The result is well-defined but only “almost always correctly rounded”.

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

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
66. Nếu 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
53 là âm thì 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
54 phải không thể thiếu. Kết quả sẽ không chính xác trừ khi 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
54 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.

  • >>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
    70 dẫn đế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')
    0 và nế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')
    0 không bị mắc kẹt, thì kết quả là 
    >>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
    73.

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

    >>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
    74 theo các hàm được làm tròn chính xác 
    >>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
    75 và 
    >>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
    76. 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 

    >>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
    77. Đố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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
54 phải không âm

Ít nhất một trong số 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
53 hoặc 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
54 phải là không(x, y)

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
65 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ừ 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
82 bằng với giá trị sẽ thu được bằng cách tính toán 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
83 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 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
53, 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
54 và 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
65. 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ề 

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
87, trong đó n là số nguyên gần nhất là giá trị chính xác của 
>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
88 (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ề 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82 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

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
90

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
91

decimal.max_emax¶MAX_EMAX

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
90

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
91

decimal.min_emin¶MIN_EMIN

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
94

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
95

decimal.min_etiny¶MIN_ETINY

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
96

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
97

decimal.have_threads¶HAVE_THREADS

Giá trị là 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82. 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à 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82. Nếu Python là 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
00, 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à 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83. Đ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 quay về phía 

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
6.

decimal.round_down¶ROUND_DOWN

Vòng về phía 0.

decimal.round_floor¶ROUND_FLOOR

Vòng hướng về 

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
7.

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 

>>> 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 đặt, thì ngoại 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 đượ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 fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
06 và 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
40. 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 fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
08.

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ề 

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

>>> 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. Nguyên nhân có thể bao gồm:

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
4

ClassDecimal.Overflow¶decimal.Overflow

Tràn số.

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

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
40 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 
>>> 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. Trong cả hai 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')
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 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 fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
16 đến 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
17). 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 fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
06 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. 

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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13, 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
22 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 
>>> 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 trong các cờ ngữ cảnh. Chuyển đổi rõ ràng với 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
24 hoặc 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
25 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 

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

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

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
5

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 fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
27); 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:

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
6

Mô -đun 

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

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
7

Giá trị đặc biệt

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

>>> 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 cung cấp các giá trị đặc biệt bao gồm 
>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
8, 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
31, 
>>> 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, 
>>> 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 và hai số 0, 
>>> 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 và 
>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
9.

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

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
09. Ngoài ra, chúng có thể phát sinh từ việc chia cho 0 khi tín hiệ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 không bị mắc kẹt. Tương tự như vậy, khi tín hiệ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')
5 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ề 

>>> 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 hoặc nếu tín hiệ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')
0 bị mắc kẹt, hãy tăng một ngoại lệ. Ví dụ: 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
41 trả về 
>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
8 có nghĩa là không phải là một số. Sự đa dạng của 
>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
8 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 
>>> 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 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 fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
31 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 

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
8. Mộ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 
>>> 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 luôn trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83 (ngay cả khi thực hiện 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
49), trong khi một bài kiểm tra cho sự bất bình đẳng luôn trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
82. 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 fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
51, 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
52, 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
53 hoặc 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
54 nào sẽ tăng tín hiệ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')
0 nếu một trong hai toán hạng là 
>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
8 và trả về 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
83 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 
>>> 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 đã đượ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 
>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
61 và 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
60.

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:

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
8

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

Hàm 

>>> 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 truy cập vào một đối tượng 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
72 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 fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
63) mà không can thiệp vào các luồng khác.

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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
06 tự động gán mục tiêu của nó cho luồng hiện tại.

Nếu 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
06 chưa được gọi trướ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')
8, thì 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
8 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 

>>> 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. Ví dụ:

>>> str(sum(map(decimal.Decimal,['.1','.1','.5','.5'])))
'1.2'
9

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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13:

>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
0

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

Q. Nó là cồng kềnh để loại 

>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
70. 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 fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
1

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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
04 làm tròn đến một số vị trí thập phân cố định. Nếu bẫy 
>>> 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 được đặt, nó cũng hữu ích cho việc xác thực:

>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
2

>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
3

>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
4

>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
5

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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
04:

>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
6

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 

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
04:

>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
7

>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
8

Q. Có nhiều cách để thể hiện cùng một giá trị. Các số 

>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
75, 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
76, 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
77 và 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
78 đề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 fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
79 ánh xạ tất cả các giá trị tương đương vào một đại diện duy nhất:

>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
9

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 fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
80 là 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
81 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().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
0

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

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

>>> import decimal
>>> decimal.Decimal('1.1')+decimal.Decimal('.1')
Decimal('1.2')
13 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:

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

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:

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

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:

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

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 fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
83:

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

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 fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
06 và 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
40 phải luôn được đặt thành các giá trị tối đa, 
>>> from fractions import Fraction as Fr
>>> Fr(11,10)+Fr(1,10)
Fraction(6, 5)
87 phải luôn là 0 (mặc định).Cài đặt 
>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
86 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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
86 cũng như 2:

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

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

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
98 quá lớn trên các nền tảng 64 bit và bộ nhớ có sẵn sẽ không đủ:

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

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 

>>> decimal.Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
86 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:

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

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 

>>> 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 nếu tất cả các tính toán được dự kiến là 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.

programming python Decimal Python Declare decimal python

Bài Viết Liên Quan

Hạch toán tài sản cố định xe ô tô năm 2024
Hạch toán tài sản cố định xe ô tô năm 2024

mẹo hay
Bài tập trắc nghiệm về đường tròn và tiếp tuyến năm 2024
Bài tập trắc nghiệm về đường tròn và tiếp tuyến năm 2024

mẹo hay Khỏe Đẹp Bài tập
Khái niệm hứng thú học tập là gì năm 2024
Khái niệm hứng thú học tập là gì năm 2024

là ai Hỏi Đáp Là gì Học Tốt Học
Cơn đau thắt ngưc ổn định là gì năm 2024
Cơn đau thắt ngưc ổn định là gì năm 2024

là ai Hỏi Đáp Là gì
Bài văn cảm nhận về bài thơ qua đèo ngang năm 2024
Bài văn cảm nhận về bài thơ qua đèo ngang năm 2024

mẹo hay
Đại trung môn văn miếu quốc tử giám năm 2024
Đại trung môn văn miếu quốc tử giám năm 2024

mẹo hay Văn Miếu
Định lượng ca72-4 cancer antigen 72-4 là gì năm 2024
Định lượng ca72-4 cancer antigen 72-4 là gì năm 2024

là ai Hỏi Đáp Là gì CA 72 cyfra 21-1 Cea la gì CA 72-4 wikipedia CEA
Văn phòng giao dịch có phải nộp thuế môn bài năm 2024
Văn phòng giao dịch có phải nộp thuế môn bài năm 2024

mẹo hay Ngôn ngữ Dịch
Thông tin xuất hóa đơn gồm những gì năm 2024
Thông tin xuất hóa đơn gồm những gì năm 2024

mẹo hay
Intelin là số điện thoại gì năm 2024
Intelin là số điện thoại gì năm 2024

là ai INTELIN vn
Soạn bài rằm tháng giêng ngữ văn lớp 7 năm 2024
Soạn bài rằm tháng giêng ngữ văn lớp 7 năm 2024

mẹo hay Soạn văn 7
1 số đề kiểm tra môn hóa hk2 năm 2024
1 số đề kiểm tra môn hóa hk2 năm 2024

mẹo hay
Phương tiện truyền thông xã hội là gì năm 2024
Phương tiện truyền thông xã hội là gì năm 2024

là ai Hỏi Đáp Là gì
Toán lớp 7 tập 1 bài 37 trang 22 năm 2024
Toán lớp 7 tập 1 bài 37 trang 22 năm 2024

mẹo hay
Bài tập lai phân tích 2 cặp tính trạng năm 2024
Bài tập lai phân tích 2 cặp tính trạng năm 2024

mẹo hay Khỏe Đẹp Bài tập Cryto Phân tích
A launch is on the cards là gì năm 2024
A launch is on the cards là gì năm 2024

là ai Hỏi Đáp Là gì Launched là gì Laid-back là gì In succession On the rocks Uproar Slipped my mind
Lỗi cad không hiển thi hai đầu đoan thắng năm 2024
Lỗi cad không hiển thi hai đầu đoan thắng năm 2024

mẹo hay
Trường đại học kinh bắc có những ngành nào năm 2024
Trường đại học kinh bắc có những ngành nào năm 2024

mẹo hay Học Tốt Học Đại học
Làm thế nào để được nhiều like trên facebook năm 2024
Làm thế nào để được nhiều like trên facebook năm 2024

mẹo hay Hỏi Đáp Thế nào Công Nghệ Facebook Mua like Facebook
Quản trị kinh doanh ebba là gì năm 2024
Quản trị kinh doanh ebba là gì năm 2024

là ai Hỏi Đáp Là gì

Quảng Cáo

Có thể bạn quan tâm

Vở bài tập toán lớp 5 trang 69 70 năm 2024
1 ngày trước . bởi DetectableAccuracy
Bai tap thày nguyen thanh van toán cao cap năm 2024
1 ngày trước . bởi BlondSpectre
Chỉ tiêu monetary base broad money là gì năm 2024
1 ngày trước . bởi TotalDeparture
Bán nhà đất xã văn phú thường tín năm 2024
1 ngày trước . bởi AdditiveFriendliness
Tại sao copy đoạn văn lại bị lỗi chính tả năm 2024
1 ngày trước . bởi Anti-inflationInaccuracy
Thợ kỹ thuật sửa chữa máy tiếng anh là gì năm 2024
1 ngày trước . bởi AssembledLoathing
Lỗi không vào được audition trên win 7 năm 2024
1 ngày trước . bởi UnfashionableIllustrator
Cbd and non-cbd là gì trong sub-market của cho thuê năm 2024
1 ngày trước . bởi UnansweredMainframe
Cai dat phan mem be khoa wifi cho lap top năm 2024
1 ngày trước . bởi BefuddledCouncilman
Chữa bệnh không đúng tuyến được bhyt thanh toán năm 2024
1 ngày trước . bởi NavalUnification

Toplist được quan tâm

#1
Top 9 tập bản đồ lớp 8 bài 31 2023
5 tháng trước
#2
Top 6 kết quả thi hsg đà nẵng 2022 2023
5 tháng trước
#3
Top 9 tủ nhựa đài loan 4 cánh 3d 2023
5 tháng trước
#4
Top 9 chất khí có thể làm mất màu dung dịch nước brom là: a. so2. b. co2. c. o2. d. hcl. 2023
5 tháng trước
#5
Top 8 tìm việc làm tiện, phay bảo q7 2023
5 tháng trước
#6
Top 3 tôi xuyên thành tiểu kiều the của lão đại phản 2 2023
5 tháng trước
#7
Top 9 đổi mới phong cách, thái độ phục vụ của cán bộ y tế hướng tới sự hài lòng của người bệnh 2023
5 tháng trước
#8
Top 2 bài the dục phát triển chung lớp 6 2022 2023
5 tháng trước
#9
Top 3 bài giảng vũ điệu sắc màu (lớp 4) 2023
5 tháng trước

Quảng cáo

Xem Nhiều

Bài 42 vật lí 9 sách bài tập năm 2024
1 tuần trước . bởi One-manReceptor
Camera điều khiển tren không gọi là gì năm 2024
2 ngày trước . bởi SquareBrunt
Ký hiệu ext trên tay cầm ps4 pro là gì năm 2024
1 ngày trước . bởi OverhangingIceberg
Nghĩa vụ cơ bản của hợp đồng là gì năm 2024
1 ngày trước . bởi Short-termGrandeur
Dùng ram như thế nào cho máy tính xem phim năm 2024
3 ngày trước . bởi DelightedWhereabouts
Qua tiêu hóa lipid sẽ được biến đổi thành gì năm 2024
5 ngày trước . bởi RabidContentment
Nhà hàng phố đêm 346 phạm văn đồng năm 2024
1 tuần trước . bởi UnregulatedIntersection
Đi vệ sinh nhiều lần trong ngày là bệnh gì năm 2024
1 tuần trước . bởi AptPerusal
Anh không có font nền gọi là gì năm 2024
6 ngày trước . bởi Two-hourProcessing
Lỗi page fault in nonpaged area win 7 năm 2024
5 ngày trước . bởi ImplacableDriver

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

DMCA.com Protection Status
Bản quyền © 2021 Xây Nhà Inc.