Làm thế nào để bạn in tối đa n chữ số thập phân trong python?

Mô-đun cung cấp hỗ trợ cho số học dấu phẩy động thập phân được làm tròn chính xác nhanh chóng. Nó cung cấp một số lợi thế so với kiểu dữ liệu

Nội dung chính Show

Hướng dẫn bắt đầu nhanh
đối tượng thập phân
toán hạng logic
đối tượng bối cảnh
hằng số
Rounding modes
Ghi chú dấu phẩy động
Giảm thiểu lỗi làm tròn với độ chính xác cao hơn
Giá trị đặc biệt
Làm việc với chủ đề
Công thức nấu ăn
Câu hỏi thường gặp về số thập phân

Số thập phân “dựa trên một mô hình dấu phẩy động được thiết kế dành cho con người và nhất thiết phải có một nguyên tắc hướng dẫn tối quan trọng – máy tính phải cung cấp một phép tính số học hoạt động giống như phép tính số học mà mọi người học ở trường. ” – đoạn trích từ đặc tả số học thập phân

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

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

7 và

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

8 không có biểu diễn chính xác ở dạng dấu phẩy động nhị phân. Người dùng cuối thường không mong đợi

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

9 hiển thị dưới dạng

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

0 giống như với dấu phẩy động nhị phân

Tính chính xác chuyển sang số học. Trong dấu phẩy động thập phân,

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

1 chính xác bằng 0. Trong dấu phẩy động nhị phân, kết quả là

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

2. Trong khi gần bằng 0, sự khác biệt ngăn cản thử nghiệm bình đẳng đáng tin cậy và sự khác biệt có thể tích lũy. Vì lý do này, số thập phân được ưa thích hơn trong các ứng dụng kế toán có bất biến đẳng thức nghiêm ngặt

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

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

3 là

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

4. Số 0 ở cuối được giữ để biểu thị tầm quan trọng. Đây là cách trình bày thông thường cho các ứng dụng tiền tệ. Đối với phép nhân, cách tiếp cận “sách giáo khoa” sử dụng tất cả các số liệu trong các bội số. Chẳng hạn,

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

5 cho

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

6 trong khi

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

7 cho

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

Không giống như dấu phẩy động nhị phân dựa trên phần cứng, mô-đun thập phân có độ chính xác có thể thay đổi của người dùng (mặc định là 28 vị trí) có thể lớn đến mức cần thiết cho một vấn đề nhất định
```
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
```
Cả dấu phẩy động nhị phân và thập phân đều được triển khai theo các tiêu chuẩn đã công bố. Trong khi kiểu float có sẵn chỉ thể hiện một phần khiêm tốn khả năng của nó, thì mô-đun thập phân thể hiện tất cả các phần bắt buộc của tiêu chuẩn. Khi cần, lập trình viên có toàn quyền kiểm soát việc làm tròn và xử lý tín hiệu. Điều này bao gồm một tùy chọn để thực thi số học chính xác bằng cách sử dụng các ngoại lệ để chặn bất kỳ hoạt động không chính xác nào
Mô-đun thập phân được thiết kế để hỗ trợ “không ảnh hưởng, cả số học thập phân không làm tròn chính xác (đôi khi được gọi là số học dấu phẩy động) và số học dấu phẩy động làm tròn. ” – đoạn trích từ đặc tả số học thập phân

Thiết kế mô-đun tập trung vào ba khái niệm. số thập phân, ngữ cảnh cho số học và tín hiệu

Một số thập phân là bất biến. Nó có dấu, chữ số hệ số và số mũ. Để duy trì ý nghĩa, các chữ số của hệ số không cắt bớt các số 0 ở cuối. Số thập phân cũng bao gồm các giá trị đặc biệt như

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

0 và

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1. Tiêu chuẩn cũng phân biệt giữa

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

2 với

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

Bối cảnh cho số học là môi trường chỉ định độ chính xác, quy tắc làm tròn, giới hạn số mũ, cờ biểu thị kết quả của phép toán và trình hỗ trợ bẫy xác định xem tín hiệu có được coi là ngoại lệ hay không. Các tùy chọn làm tròn bao gồm , , , , , , và

Tín hiệu là nhóm các điều kiện đặc biệt phát sinh trong quá trình tính toán. Tùy thuộc vào nhu cầu của ứng dụng, các tín hiệu có thể bị bỏ qua, được coi là thông tin hoặc được coi là ngoại lệ. Các tín hiệu trong mô-đun thập phân là. , , , , , , , Và

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

Xem thêm

Đặc tả số học thập phân chung của IBM, Đặc tả số học thập phân chung

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

Cách bắt đầu thông thường để sử dụng số thập phân là nhập mô-đun, xem ngữ cảnh hiện tại và, nếu cần, đặt các giá trị mới cho độ chính xác, làm tròn hoặc bật bẫy

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

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

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

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 viết tắt của “Không phải là số”, số dương và số âm

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

9 và

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

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

Nếu tín hiệu bị mắc kẹt, việc vô tình trộn số thập phân và số float trong hàm tạo hoặc so sánh thứ tự sẽ tạo ra một ngoại lệ

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 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 Số thập phân mới chỉ được xác định bởi số lượng chữ số đầu vào. Độ chính xác của ngữ cảnh và làm tròn chỉ phát huy tác dụng trong các phép toán số học

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

Nếu vượt quá giới hạn nội bộ của phiên bản C, việc xây dựng số thập phân sẽ tăng

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

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. Đây là một rạp xiếc bay dấu phẩy động thập phân nhỏ

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

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

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

Phương pháp

>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)
>>> setcontext(myothercontext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857142857142857142857142857')

>>> ExtendedContext
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[])
>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857143')
>>> Decimal(42) / Decimal(0)
Decimal('Infinity')

>>> setcontext(BasicContext)
>>> Decimal(42) / Decimal(0)
Traceback (most recent call last):
  File "", line 1, in -toplevel-
    Decimal(42) / Decimal(0)
DivisionByZero: x / 0

7 làm tròn một số thành số mũ cố định. Phương pháp này 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ố vị trí cố định

>>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)
Decimal('7.32')
>>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)
Decimal('8')

Như được hiển thị ở trên, chức năng truy cập ngữ cảnh hiện tại và cho phép thay đổi cài đặt. 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 khi tạo các ngữ cảnh thay thế bằng cách sử dụng hàm tạo Context(). Để thực hiện thay thế hoạt động, hãy sử dụng chức năng

Theo tiêu chuẩn, mô-đun cung cấp hai bối cảnh tiêu chuẩn sẵn sàng sử dụng và. Cái trước đặc biệt hữu ích để gỡ lỗi vì nhiều bẫy được bật

>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)
>>> setcontext(myothercontext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857142857142857142857142857')

>>> ExtendedContext
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[])
>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857143')
>>> Decimal(42) / Decimal(0)
Decimal('Infinity')

>>> setcontext(BasicContext)
>>> Decimal(42) / Decimal(0)
Traceback (most recent call last):
  File "", line 1, in -toplevel-
    Decimal(42) / Decimal(0)
DivisionByZero: x / 0

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ờ vẫn được đặt cho đến khi bị xóa rõ ràng, vì vậy, tốt nhất là xóa cờ trước mỗi tập hợp tính toán được giám sát bằng cách sử dụng phương pháp

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

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

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

Mục cờ cho thấy rằng giá trị gần đúng hợp lý của

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

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

04 đã được làm tròn (các chữ số vượt quá độ chính xác của ngữ cảnh đã bị loại bỏ) và kết quả là không chính xác (một số chữ số bị loại bỏ khác 0)

Các bẫy riêng lẻ được đặt bằng cách sử dụng từ điển trong trườ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

05 của ngữ 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

Hầu hết các chương trình chỉ điều chỉnh bối cảnh hiện tại một lần, khi bắt đầu chương trình. Và, trong nhiều ứng dụng, dữ liệu được chuyển đổi thành một lần truyền bên trong một vòng lặp. Với tập ngữ cảnh và số thập phân được tạo, phần lớn chương trình thao tác dữ liệu không khác gì với các loại số Python khác

đối tượng thập phân

lớp thập phân. Số thập phân(giá trị=', context=None)

Xây dựng một đối tượng mới dựa trên giá trị

giá trị có thể là một số nguyên, chuỗi, tuple, hoặc một đối tượng khác. Nếu không có giá trị nào được đưa ra, trả về

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

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

10. Nếu giá trị là một chuỗi, thì giá trị đó phải tuân theo cú pháp chuỗi số thập phân sau khi các ký tự khoảng trắng ở đầu và cuối, cũng như dấu gạch dưới trong suốt, được xóa

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

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

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

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

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

11 xuất hiện ở trên. Chúng bao gồm các chữ số thập phân từ nhiều bảng chữ cái khác (ví dụ: chữ số Ả Rập-Ấn Độ và Devanāgarī) cùng với các chữ số có độ rộng đầy đủ từ

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

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

12 đế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

Nếu giá trị là a , thì giá trị đó phải có ba thành phần, một dấu (_______18_______15 cho số dương hoặc

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

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

16 cho số âm), một chữ số và một số mũ nguyên. Ví dụ:

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

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

18 trả về

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

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

Nếu giá trị là a , thì giá trị dấu phẩy động nhị phân được chuyển đổi dễ dàng thành số thập phân tương đương chính xác của nó. Chuyển đổi này thường có thể yêu cầu độ chính xác từ 53 chữ số trở lên. Ví dụ:

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

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

21 chuyển đổi thành

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

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

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

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

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

23 ghi tất cả năm số không ngay cả khi độ chính xác của ngữ cảnh chỉ là ba

Mục đích của đối số ngữ cảnh là xác định phải làm gì nếu giá trị là một chuỗi không đúng định dạng. Nếu bẫy bối cảnh, một ngoại lệ được đưa ra;

Sau khi được xây dựng, các đối tượng là bất biến

Đã thay đổi trong phiên bản 3. 2. Đối số của hàm tạo hiện được phép là một thể hiện.

Đã thay đổi trong phiên bản 3. 3. các đối số đưa ra một ngoại lệ nếu bẫy được đặt. Theo mặc định bẫy tắt.

Đã thay đổi trong phiên bản 3. 6. Dấu gạch dưới được cho phép để nhóm, như với các ký tự dấu phẩy động và tích phân trong mã.

Các đối tượng dấu chấm động thập phân chia sẻ nhiều thuộc tính với các kiểu số dựng sẵn khác như và. Tất cả các phép toán thông thường và các phương pháp đặc biệt được áp dụng. Tương tự như vậy, các đối tượng thập phân có thể được sao chép, chọn, in, sử dụng làm khóa từ điển, được sử dụng làm phần tử tập hợp, so sánh, sắp xếp và ép buộc sang loại khác (chẳng hạn như hoặc )

Có một số khác biệt nhỏ giữa số học trên các đối tượng thập phân và số học trên số nguyên và số float. Khi toán tử còn lại

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

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

34 được áp dụng cho các đối tượng Số thập phân, dấu của kết quả là dấu của số bị chia chứ không phải là dấu của số chia

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

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

Toán tử chia số nguyên

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

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

35 hoạt động tương tự, trả về phần nguyên của thương số thực (cắt ngắn về 0) thay vì giá trị sàn của nó, để giữ nguyên giá trị thông thường

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

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

>>> 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 toán tử

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

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

34 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

35 thực hiện các phép toán

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

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

39 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

40 (tương ứng) như được mô tả trong đặc tả

Các đối tượng thập phân thường không thể được kết hợp với số float hoặc thể hiện của trong các phép toán số học. một nỗ lực để thêm một vào một, ví dụ, sẽ nâng cao một. Tuy nhiên, có thể sử dụng các toán tử so sánh của Python để so sánh một thể hiện

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

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

46 với một số khác

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

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

47. Điều này tránh kết quả khó hiểu khi thực hiện so sánh bình đẳng giữa các số loại khác nhau

Đã thay đổi trong phiên bản 3. 2. So sánh kiểu hỗn hợp giữa các phiên bản và các kiểu số khác hiện được hỗ trợ đầy đủ.

Ngoài các thuộc tính số tiêu chuẩn, các đối tượng dấu phẩy động thập phân còn có một số phương thức chuyên biệt

đã điều chỉnh()

Trả về số mũ đã điều chỉnh sau khi dịch chuyển các chữ số ngoài cùng bên phải của hệ số cho đến khi chỉ còn lại chữ số dẫn đầu.

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

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

49 trả về bảy. Được sử dụng để xác định vị trí của chữ số có nghĩa nhất đối với dấu thập phân

as_integer_ratio()

Trả về một cặp

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

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

50 số nguyên đại diện cho trường hợp đã cho dưới dạng phân số, ở dạng nhỏ nhất và có mẫu số dương

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

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

Việc chuyển đổi là chính xác. Tăng OverflowError trên vô số và ValueError trên NaN

Mới trong phiên bản 3. 6

as_tuple()

Trả về một đại diện của số.

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

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

chính tắc()

Trả lại mã hóa chính tắc của đối số. Hiện tại, mã hóa của một phiên bản luôn ở dạng chuẩn, vì vậy thao tác này trả về đối số của nó không thay đổi

so sánh(khác , bối cảnh=None)

So sánh các giá trị của hai trường hợp thập phân. trả về một thể hiện Thập phân và nếu một trong hai toán hạng là NaN thì kết quả là NaN

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

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

so sánh_signal(khác , bối cảnh=None)

Hoạt động này giống hệt với phương pháp, ngoại trừ tất cả các tín hiệu NaN. Nghĩa là, nếu không có toán hạng nào là NaN báo hiệu thì bất kỳ toán hạng NaN yên tĩnh nào cũng được coi như thể đó là NaN báo hiệu

so_total(khác , bối cảnh=None)

So sánh hai toán hạng bằng cách sử dụng biểu diễn trừu tượng thay vì giá trị số của chúng. Tương tự như phương pháp, nhưng kết quả cho tổng thứ tự trên các trường hợp. Hai trường hợp có cùng giá trị số nhưng cách biểu diễn khác nhau so sánh không bằng nhau theo thứ tự này

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

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

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

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

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

10 nếu cả hai toán hạng có cùng biểu diễn,

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

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

60 nếu toán hạng đầu tiên có tổng thứ tự thấp hơn toán hạng thứ hai và

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

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

61 nếu toán hạng thứ nhất có tổng thứ tự cao hơn toán hạng thứ hai. Xem thông số kỹ thuật để biết chi tiết về tổng số đơn đặt hàng

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

so sánh_total_mag(khác , bối cảnh=None)

So sánh hai toán hạng bằng cách sử dụng biểu diễn trừu tượng của chúng thay vì giá trị của chúng như trong , nhưng bỏ qua dấu của từng toán hạng.

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

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

63 tương đương với

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

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

liên hợp()

Chỉ trả về self, phương thức này chỉ tuân theo Đặc tả thập phân

copy_abs()

Trả về giá trị tuyệt đối của đối số. Hoạt động này không bị ảnh hưởng bởi bối cảnh và yên tĩnh. không có cờ nào được thay đổi và không có phép làm tròn nào được thực hiện

copy_negate()

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

copy_sign(khác , bối cảnh=None)

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

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

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

exp(bối cảnh=Không có)

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

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

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

65 tại số đã cho. Kết quả được làm tròn chính xác bằng cách sử dụng chế độ làm tròn

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

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

classmethod from_float(f)

Hàm tạo thay thế chỉ chấp nhận các thể hiện của hoặc

Lưu ý

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

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

69 không giống với

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

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

70. kể từ 0. 1 không thể biểu diễn chính xác trong dấu phẩy động nhị phân, giá trị được lưu dưới dạng giá trị biểu diễn gần nhất là

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

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

71. Giá trị tương đương ở dạng thập phân là

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

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

Ghi chú

Từ Python 3. 2 trở đi, một thể hiện cũng có thể được xây dựng trực tiếp từ một

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

Mới trong phiên bản 3. 1

fma(khác , thứ ba, context=None)

Hợp nhất nhân-thêm. Trả về self*other+thứ ba mà không làm tròn sản phẩm trung gian self*other

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

is_canonical()

Trả về nếu đối số là hợp quy và ngược lại. Hiện tại, một phiên bản luôn ở dạng chuẩn, vì vậy thao tác này luôn trả về

is_finite()

Trả về nếu đối số là một số hữu hạn và nếu đối số là vô hạn hoặc NaN

is_infinite()

Trả về nếu đối số là vô cực dương hoặc âm và ngược lại

is_nan()

Trả về nếu đối số là NaN (im lặng hoặc báo hiệu) và ngược lại

is_normal(bối cảnh=Không có)

Trả về nếu đối số là một số hữu hạn bình thường. Trả về nếu đối số bằng 0, không bình thường, vô hạn hoặc NaN

is_qnan()

Trả về nếu đối số là một NaN yên tĩnh và ngược lại

is_signed()

Trả về nếu đối số có dấu âm và ngược lại. Lưu ý rằng cả số không và NaN đều có thể mang dấu

is_snan()

Trả về nếu đối số là NaN báo hiệu và ngược lại

is_subnormal(bối cảnh=Không có)

Trả về nếu đối số không bình thường và ngược lại

is_zero()

Trả về nếu đối số là số 0 (dương hoặc âm) và ngược lại

ln(bối cảnh=Không có)

Trả về logarit tự nhiên (cơ số e) của toán hạng. Kết quả được làm tròn chính xác bằng cách sử dụng chế độ làm tròn

log10(bối cảnh=Không có)

Trả về logarit cơ số 10 của toán hạng. Kết quả được làm tròn chính xác bằng cách sử dụng chế độ làm tròn

logb(bối cảnh=Không có)

Đối với một số khác 0, trả về số mũ đã điều chỉnh của toán hạng của nó làm ví dụ. Nếu toán hạng là số 0 thì hàm

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

00 được trả về và cờ được nâng lên. Nếu toán hạng là vô cùng thì trả về

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

logic_and(khác , bối cảnh=None)

là một phép toán logic nhận hai toán hạng logic (xem ). Kết quả là

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

04 chữ số của hai toán hạng

logic_invert(bối cảnh=Không có)

là một phép toán logic. Kết quả là nghịch đảo chữ số của toán hạng

logic_or(khác , bối cảnh=None)

là một phép toán logic nhận hai toán hạng logic (xem ). Kết quả là

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

07 chữ số của hai toán hạng

logic_xor(khác , bối cảnh=None)

là một phép toán logic nhận hai toán hạng logic (xem ). Kết quả là loại trừ chữ số hoặc của hai toán hạng

tối đa(khác , bối cảnh=None)

Giống như

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

09 ngoại trừ quy tắc làm tròn ngữ cảnh được áp dụng trước khi quay lại và các giá trị

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 được báo hiệu hoặc bỏ qua (tùy thuộc vào ngữ cảnh và chúng đang báo hiệu hay không)

max_mag(khác , bối cảnh=None)

Tương tự như phương pháp, nhưng việc so sánh được thực hiện bằng cách sử dụng các giá trị tuyệt đối của toán hạng

phút(khác , bối cảnh=None)

Giống như

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

12 ngoại trừ quy tắc làm tròn ngữ cảnh được áp dụng trước khi quay lại và các giá trị

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 được báo hiệu hoặc bỏ qua (tùy thuộc vào ngữ cảnh và chúng đang báo hiệu hay không)

min_mag(khác , bối cảnh=None)

Tương tự như phương pháp, nhưng việc so sánh được thực hiện bằng cách sử dụng các giá trị tuyệt đối của toán hạng

next_minus(bối cảnh=Không có)

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

next_plus(bối cảnh=Không có)

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

next_toward(khác , bối cảnh=None)

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

chuẩn hóa(bối cảnh=Không có)

Bình thường hóa số bằng cách loại bỏ các số 0 ở cuối bên phải và chuyển đổi bất kỳ kết quả nào bằng

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

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

10 thành

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

16. Được sử dụng để tạo ra các giá trị chuẩn cho các thuộc tính của một lớp tương đương. Ví dụ:

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

17 và

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

18 đều chuẩn hóa thành giá trị tương đương

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

số_lớp(bối cảnh=Không có)

Trả về một chuỗi mô tả lớp của toán hạng. Giá trị trả về là một trong mười chuỗi sau

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

20, chỉ ra rằng toán hạng là âm vô cùng

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

21, chỉ ra rằng toán hạng là một số bình thường âm

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

22, chỉ ra rằng toán hạng là âm và không bình thường

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

23, cho biết toán hạng là số 0 âm

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

24, cho biết toán hạng là số 0 dương

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

25, chỉ ra rằng toán hạng là dương và không bình thường

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

26, chỉ ra rằng toán hạng là một số bình thường dương

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

27, chỉ ra rằng toán hạng là dương vô cùng

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

28, chỉ ra rằng toán hạng là một NaN yên tĩnh (Không phải là một số)

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

29, chỉ ra rằng toán hạng là một NaN báo hiệu

số lượng hóa(exp , làm tròn=None, context=None)

Trả về một giá trị bằng toán hạng đầu tiên sau khi làm tròn và có số mũ của toán hạng thứ hai

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

Không giống như các thao tác khác, nếu độ dài của hệ số sau thao tác lượng tử hóa lớn hơn độ chính xác, thì an được báo hiệu. Điều này đảm bảo rằng, trừ khi có điều kiện lỗi, số mũ được lượng tử hóa luôn bằng số mũ của toán hạng bên phải

Ngoài ra, không giống như các hoạt động khác, lượng tử hóa không bao giờ báo hiệu Underflow, ngay cả khi kết quả là không bình thường và không chính xác

Nếu số mũ của toán hạng thứ hai lớn hơn số mũ của toán hạng thứ nhất thì có thể cần phải làm tròn. Trong trường hợp này, chế độ làm tròn được xác định bởi đối số

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

31 nếu được đưa ra, ngược lại bởi đối số

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

32 đã cho;

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

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

33 hoặc nhỏ hơn

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

cơ số()

Trả về

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

35, cơ số (cơ số) mà lớp thực hiện tất cả các phép tính của nó. Bao gồm để tương thích với đặc điểm kỹ thuật

remainder_near(khác , bối cảnh=None)

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

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

37 ở chỗ dấu của phần dư được chọn sao cho giá trị tuyệt đối của nó là nhỏ nhất. Chính xác hơn, giá trị trả về là

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

38 trong đó

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

39 là số nguyên gần nhất với giá trị chính xác của

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

40 và nếu hai số nguyên gần bằng nhau thì số chẵn được chọn

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

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

xoay(khác , bối cảnh=None)

Trả về kết quả xoay các chữ số của toán hạng thứ nhất theo một lượng được chỉ định bởi toán hạng thứ hai. Toán hạng thứ hai phải là một số nguyên trong phạm vi -precision đến precision. Giá trị tuyệt đối của toán hạng thứ hai cho biết số vị trí cần xoay. Nếu toán hạng thứ hai là dương thì phép quay sang trái; . Hệ số của toán hạng đầu tiên được đệm ở bên trái với độ chính xác từ 0 đến độ dài nếu cần. Dấu và số mũ của toán hạng đầu tiên không thay đổi

same_quantum(other , bối cảnh=None)

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

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

scaleb(khác , bối cảnh=None)

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

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

42. Toán hạng thứ hai phải là một số nguyên

chuyển(khác , bối cảnh=None)

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

sqrt(bối cảnh=Không có)

Trả lại căn bậc hai của đối số về độ chính xác đầy đủ

to_eng_string(bối cảnh=Không có)

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

Ký hiệu kỹ thuật có số mũ là bội số của 3. Điều này có thể để lại tối đa 3 chữ số ở bên trái của vị trí thập phân và có thể yêu cầu thêm một hoặc hai số 0 ở cuối

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

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

43 thành

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

to_integral(làm tròn=Không có, context=None)

Tương tự với phương pháp. Tên

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

46 đã được giữ để tương thích với các phiên bản cũ hơn

to_integral_exact(làm tròn=Không có, context=None)

Làm tròn đến số nguyên gần nhất, báo hiệu hoặc nếu thích hợp nếu làm tròn xảy ra. Chế độ làm tròn được xác định bởi tham số

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

31 nếu được cung cấp, nếu không thì bởi

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

32 đã cho. Nếu không có tham số nào được cung cấp thì chế độ làm tròn của ngữ cảnh hiện tại được sử dụng

to_integral_value(làm tròn=Không có, context=None)

Làm tròn đến số nguyên gần nhất mà không báo hiệu hoặc. Nếu được cung cấp, áp dụng làm tròn;

toán hạng logic

Các phương thức

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

03,

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

05,

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

06 và

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

08 mong đợi các đối số của chúng là toán hạng logic. Toán hạng logic là một thực thể có số mũ và dấu đều bằng 0 và có tất cả các chữ số là

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

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

15 hoặc

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

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

đối tượng bối cảnh

Bối cảnh là môi trường cho các hoạt động số học. Chúng chi phối độ chính xác, đặt quy tắc làm tròn, xác định tín hiệu nào được coi là ngoại lệ và giới hạn phạm vi cho số mũ

Mỗi luồng có bối cảnh hiện tại của riêng nó được truy cập hoặc thay đổi bằng cách sử dụng các chức năng và

thập phân. getcontext()

Return the current context for the active thread

decimal. setcontext(c)

Set the current context for the active thread to c

You can also use the statement and the function to temporarily change the active context

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

Return a context manager that will set the current context for the active thread to a copy of ctx on entry to the with-statement and restore the previous context when exiting the with-statement. If no context is specified, a copy of the current context is used. The kwargs argument is used to set the attributes of the new context

For example, the following code sets the current decimal precision to 42 places, performs a calculation, and then automatically restores the previous context

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

Using keyword arguments, the code would be the following

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

Raises if kwargs supplies an attribute that doesn’t support. Raises either or if kwargs supplies an invalid value for an attribute

Changed in version 3. 11. now supports setting context attributes through the use of keyword arguments.

New contexts can also be created using the constructor described below. In addition, the module provides three pre-made contexts

class decimal. BasicContext

This is a standard context defined by the General Decimal Arithmetic Specification. Precision is set to nine. Rounding is set to . All flags are cleared. All traps are enabled (treated as exceptions) except , , and

Because many of the traps are enabled, this context is useful for debugging

class decimal. ExtendedContext

This is a standard context defined by the General Decimal Arithmetic Specification. Precision is set to nine. Rounding is set to . All flags are cleared. No traps are enabled (so that exceptions are not raised during computations)

Because the traps are disabled, this context is useful for applications that prefer to have result value of

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 or

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

9 instead of raising exceptions. This allows an application to complete a run in the presence of conditions that would otherwise halt the program

class decimal. DefaultContext

This context is used by the constructor as a prototype for new contexts. Thay đổi một trường (độ chính xác như vậy) có tác dụng thay đổi mặc định cho các ngữ cảnh mới được tạo bởi hàm tạo

This context is most useful in multi-threaded environments. Changing one of the fields before threads are started has the effect of setting system-wide defaults. Changing the fields after threads have started is not recommended as it would require thread synchronization to prevent race conditions

In single threaded environments, it is preferable to not use this context at all. Instead, simply create contexts explicitly as described below

The default values are

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

79=

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

80,

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

31=, and enabled traps for , , and

In addition to the three supplied contexts, new contexts can be created with the constructor

class decimal. Context(prec=None , rounding=None , Emin=None , Emax=None , capitals=None , clamp=None , flags=None , traps=None)

Creates a new context. If a field is not specified or is , the default values are copied from the . If the flags field is not specified or is , all flags are cleared

prec is an integer in the range [

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

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

16, ] that sets the precision for arithmetic operations in the context

The rounding option is one of the constants listed in the section

The traps and flags fields list any signals to be set. Generally, new contexts should only set traps and leave the flags clear

The Emin and Emax fields are integers specifying the outer limits allowable for exponents. Emin must be in the range [,

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

15], Emax in the range [

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

15, ]

The capitals field is either

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

15 or

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

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

16 (the default). If set to

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

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

16, exponents are printed with a capital

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

99; otherwise, a lowercase

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

00 is used.

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

The clamp field is either

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

15 (the default) or

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

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

16. If set to

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

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

16, the exponent

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

00 of a instance representable in this context is strictly limited to the range

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

07. If clamp is

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

15 then a weaker condition holds. the adjusted exponent of the instance is at most

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

33. When clamp is

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

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

16, a large normal number will, where possible, have its exponent reduced and a corresponding number of zeros added to its coefficient, in order to fit the exponent constraints; this preserves the value of the number but loses information about significant trailing zeros. For example

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

A clamp value of

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

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

16 allows compatibility with the fixed-width decimal interchange formats specified in IEEE 754

The class defines several general purpose methods as well as a large number of methods for doing arithmetic directly in a given context. In addition, for each of the methods described above (with the exception of the

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

15 and

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

16 methods) there is a corresponding method. For example, for a instance

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

19 and instance

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

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

46,

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

22 is equivalent to

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

23. Each method accepts a Python integer (an instance of ) anywhere that a Decimal instance is accepted

clear_flags()

Resets all of the flags to

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

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

clear_traps()

Resets all of the traps to

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

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

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

copy()

Return a duplicate of the context

copy_decimal(num)

Return a copy of the Decimal instance num

create_decimal(num)

Creates a new Decimal instance from num but using self as context. Unlike the constructor, the context precision, rounding method, flags, and traps are applied to the conversion

This is useful because constants are often given to a greater precision than is needed by the application. Another benefit is that rounding immediately eliminates unintended effects from digits beyond the current precision. In the following example, using unrounded inputs means that adding zero to a sum can change the result

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

This method implements the to-number operation of the IBM specification. If the argument is a string, no leading or trailing whitespace or underscores are permitted

create_decimal_from_float(f)

Creates a new Decimal instance from a float f but rounding using self as the context. Unlike the class method, the context precision, rounding method, flags, and traps are applied to the conversion

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

Mới trong phiên bản 3. 1

Etiny()

Returns a value equal to

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

30 which is the minimum exponent value for subnormal results. When underflow occurs, the exponent is set to

Etop()

Returns a value equal to

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

The usual approach to working with decimals is to create instances and then apply arithmetic operations which take place within the current context for the active thread. An alternative approach is to use context methods for calculating within a specific context. The methods are similar to those for the class and are only briefly recounted here

abs(x)

Returns the absolute value of x

add(x , y)

Return the sum of x and y

canonical(x)

Returns the same Decimal object x

compare(x , y)

Compares x and y numerically

compare_signal(x , y)

Compares the values of the two operands numerically

compare_total(x , y)

Compares two operands using their abstract representation

compare_total_mag(x , y)

Compares two operands using their abstract representation, ignoring sign

copy_abs(x)

Returns a copy of x with the sign set to 0

copy_negate(x)

Returns a copy of x with the sign inverted

copy_sign(x , y)

Copies the sign from y to x

divide(x , y)

Return x divided by y

divide_int(x , y)

Return x divided by y, truncated to an integer

divmod(x , y)

Divides two numbers and returns the integer part of the result

exp(x)

Returns

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

fma(x , y , z)

Returns x multiplied by y, plus z

is_canonical(x)

Returns

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

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

75 if x is canonical; otherwise returns

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

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

is_finite(x)

Returns

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

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

75 if x is finite; otherwise returns

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

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

is_infinite(x)

Returns

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

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

75 if x is infinite; otherwise returns

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

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

is_nan(x)

Returns

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

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

75 if x is a qNaN or sNaN; otherwise returns

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

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

is_normal(x)

Returns

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

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

75 if x is a normal number; otherwise returns

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

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

is_qnan(x)

Returns

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

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

75 if x is a quiet NaN; otherwise returns

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

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

is_signed(x)

Trả về

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

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

75 nếu x âm;

is_snan(x)

Trả về

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

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

75 nếu x là NaN báo hiệu;

is_subnormal(x)

Trả về

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

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

75 nếu x không bình thường;

is_zero(x)

Trả về

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

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

75 nếu x là số không;

ln(x)

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

log10(x)

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

logb(x)

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

logic_and(x , y)

Áp dụng phép toán logic và giữa các chữ số của mỗi toán hạng

logic_invert(x)

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

logic_or(x , y)

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

logic_xor(x , y)

Áp dụng phép toán logic xor giữa các chữ số của mỗi toán hạng

max(x , y)

So sánh hai giá trị bằng số và trả về giá trị lớn nhất

max_mag(x , y)

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

phút(x , y)

So sánh hai giá trị bằng số và trả về giá trị nhỏ nhất

min_mag(x , y)

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

trừ(x)

Dấu trừ tương ứng với toán tử trừ tiền tố một ngôi trong Python

nhân lên(x , y)

Trả về tích của x và y

next_minus(x)

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

next_plus(x)

Trả về số biểu diễn nhỏ nhất lớn hơn x

next_toward(x , y)

Trả về số gần x nhất, theo hướng về phía y

chuẩn hóa(x)

Rút gọn x về dạng đơn giản nhất

số_lớp(x)

Trả về một dấu hiệu của lớp x

cộng(x)

Plus tương ứng với toán tử cộng tiền tố một ngôi trong Python. Thao tác này áp dụng độ chính xác của ngữ cảnh và làm tròn, vì vậy đây không phải là thao tác nhận dạng

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

Đưa

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

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

46 về lũy thừa của

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

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

47, rút gọn modulo

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

58 nếu đã cho

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

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

59. Nếu

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

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

46 âm thì

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

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

47 phải nguyên. Kết quả sẽ không chính xác trừ khi

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

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

47 là tích phân và kết quả là hữu hạn và có thể được biểu thị chính xác bằng các chữ số 'chính xác'. Chế độ làm tròn của bối cảnh được sử dụng. Kết quả luôn được làm tròn chính xác trong phiên bản Python

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

63 dẫn đến

>>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)
Decimal('7.32')
>>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)
Decimal('8')

3 và nếu

>>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)
Decimal('7.32')
>>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)
Decimal('8')

3 không bị mắc kẹt, thì kết quả là

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Đã thay đổi trong phiên bản 3. 3. Mô-đun C tính toán theo cách làm tròn chính xác và các hàm. Kết quả được xác định rõ nhưng chỉ "hầu như luôn được làm tròn chính xác".

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

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

70. Đối với dạng ba đối số, các hạn chế sau đối với các đối số được giữ

cả ba đối số phải là tích phân

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

47 phải không âm

ít nhất một trong số

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

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

46 hoặc

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

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

47 phải khác không

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

58 phải khác 0 và có tối đa các chữ số 'chính xác'

Giá trị thu được từ

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

75 bằng với giá trị sẽ thu được bằng cách tính toán

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

70 với độ chính xác không giới hạn, nhưng được tính toán hiệu quả hơn. Số mũ của kết quả bằng 0, bất kể số mũ của

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

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

46,

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

47 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

58. Kết quả luôn chính xác

số lượng hóa(x , y)

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

cơ số()

Chỉ trả về 10, vì đây là Số thập phân,. )

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

Trả về phần còn lại từ phép chia số nguyên

Dấu của kết quả, nếu khác không, giống như dấu của số bị chia ban đầu

remainder_near(x , y)

Trả về

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

80, trong đó n là số nguyên gần nhất với giá trị chính xác của

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

81 (nếu kết quả là 0 thì dấu của nó sẽ là dấu của x)

xoay(x , y)

Trả về một bản sao được xoay x, y lần

same_quantum(x , y)

Trả về

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

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

75 nếu hai toán hạng có cùng số mũ

scaleb(x , y)

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

ca(x , y)

Trả về một bản sao đã dịch chuyển của x, y lần

sqrt(x)

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

trừ(x , y)

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

to_eng_string(x)

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

to_integral_exact(x)

Làm tròn thành một số nguyên

to_sci_string(x)

Chuyển đổi một số thành một chuỗi bằng cách sử dụng ký hiệu khoa học

hằng số

The constants in this section are only relevant for the C module. They are also included in the pure Python version for compatibility

32-bit

64-bit

decimal. MAX_PREC

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

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

decimal. MAX_EMAX

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

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

decimal. MIN_EMIN

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

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

decimal. MIN_ETINY

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

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

decimal. HAVE_THREADS

The value is

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

75. Deprecated, because Python now always has threads

Deprecated since version 3. 9

decimal. HAVE_CONTEXTVAR

The default value is

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

75. If Python is , the C version uses a thread-local rather than a coroutine-local context and the value is

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

76. This is slightly faster in some nested context scenarios

New in version 3. 9. backported to 3. 7 and 3. 8.

Rounding modes

decimal. ROUND_CEILING

Round towards

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

decimal. ROUND_DOWN

Round towards zero

decimal. ROUND_FLOOR

Round towards

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

decimal. ROUND_HALF_DOWN

Round to nearest with ties going towards zero

decimal. ROUND_HALF_EVEN

Round to nearest with ties going to nearest even integer

decimal. ROUND_HALF_UP

Round to nearest with ties going away from zero

decimal. ROUND_UP

Round away from zero

decimal. ROUND_05UP

Round away from zero if last digit after rounding towards zero would have been 0 or 5; otherwise round towards zero

Signals

Signals represent conditions that arise during computation. Each corresponds to one context flag and one context trap enabler

The context flag is set whenever the condition is encountered. Sau khi tính toán, các cờ có thể được kiểm tra cho các mục đích thông tin (ví dụ: để xác định xem một phép tính có chính xác hay không). Sau khi kiểm tra các cờ, đảm bảo xóa tất cả các cờ trước khi bắt đầu tính toán tiếp theo

Nếu trình kích hoạt bẫy của ngữ cảnh được đặt cho tín hiệu, thì điều kiện sẽ gây ra một ngoại lệ Python được đưa ra. For example, if the trap is set, then a exception is raised upon encountering the condition

class decimal. Đã kẹp

Altered an exponent to fit representation constraints

Thông thường, hiện tượng kẹp xảy ra khi một số mũ nằm ngoài giới hạn

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

99 và

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

33 của ngữ cảnh. If possible, the exponent is reduced to fit by adding zeros to the coefficient

class decimal. DecimalException

Base class for other signals and a subclass of

class decimal. DivisionByZero

Signals the division of a non-infinite number by zero

Có thể xảy ra với phép chia, phép chia modulo hoặc khi nâng một số lên lũy thừa âm. If this signal is not trapped, returns

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

9 or

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

0 with the sign determined by the inputs to the calculation

lớp thập phân. Không chính xác

Cho biết đã xảy ra làm tròn và kết quả không chính xác

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

lớp thập phân. Thao tác không hợp lệ

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

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

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1. nguyên nhân có thể bao gồm

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

lớp thập phân. Tràn

tràn số

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

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

33 sau khi làm tròn. Nếu không bị mắc kẹt, kết quả phụ thuộc vào chế độ làm tròn, kéo vào trong đến số hữu hạn có thể biểu diễn lớn nhất hoặc làm tròn ra ngoài thành

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

9. Trong cả hai trường hợp, và cũng được báo hiệu

lớp thập phân. Làm tròn

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

Báo hiệu bất cứ khi nào làm tròn loại bỏ chữ số; . Nếu không bị mắc kẹt, trả về kết quả không thay đổi. Tín hiệu này được sử dụng để phát hiện mất chữ số có nghĩa

lớp thập phân. Không bình thường

Số mũ thấp hơn

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

99 trước khi làm tròn

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

lớp thập phân. Tràn

Dòng dưới số với kết quả được làm tròn thành 0

Xảy ra khi một kết quả không bình thường được đẩy về 0 bằng cách làm tròn. và cũng được báo hiệu

lớp thập phân. FloatOperation

Kích hoạt ngữ nghĩa chặt chẽ hơn để trộn số float và số thập phân

Nếu tín hiệu không bị bẫy (mặc định), thì cho phép trộn số float và Số thập phân trong hàm tạo và tất cả các toán tử so sánh. Cả chuyển đổi và so sánh đều chính xác. Bất kỳ sự xuất hiện nào của một hoạt động hỗn hợp đều được ghi lại một cách âm thầm bằng cách đặt trong các cờ ngữ cảnh. Chuyển đổi rõ ràng có hoặc không đặt cờ

Mặt khác (tín hiệu bị bẫy), chỉ có các phép so sánh đẳng thức và chuyển đổi rõ ràng là im lặng. Tất cả các hoạt động hỗn hợp khác tăng

Bảng dưới đây tóm tắt hệ thống phân cấp tín hiệu

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Ghi chú dấu phẩy động

Giảm thiểu lỗi làm tròn với độ chính xác cao hơn

Việc sử dụng dấu phẩy động thập phân giúp loại bỏ lỗi biểu diễn thập phân (giúp có thể biểu diễn chính xác

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

20);

Ảnh hưởng của sai số làm tròn có thể được khuếch đại bằng cách cộng hoặc trừ các đại lượng gần như bù trừ dẫn đến mất ý nghĩa. Knuth cung cấp hai ví dụ hướng dẫn trong đó số học dấu phẩy động được làm tròn với độ chính xác không đủ gây ra sự phá vỡ các thuộc tính kết hợp và phân phối của phép cộng

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Mô-đun cho phép khôi phục danh tính bằng cách mở rộng độ chính xác đủ để tránh mất ý nghĩa

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Giá trị đặc biệt

Hệ thống số cho mô-đun cung cấp các giá trị đặc biệt bao gồm

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

24,

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

9 và hai số không,

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

3 và

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

Vô cực có thể được xây dựng trực tiếp với.

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

02. Ngoài ra, chúng có thể phát sinh từ việc chia cho 0 khi tín hiệu không bị mắc kẹt. Tương tự như vậy, khi tín hiệu không bị mắc kẹt, vô cực có thể là kết quả của việc làm tròn vượt quá giới hạn của số lớn nhất có thể biểu thị

Các vô hạn được ký (affine) và có thể được sử dụng trong các phép tính số học khi chúng được coi là các số rất lớn, không xác định. Chẳng hạn, thêm một hằng số vào vô cùng sẽ cho một kết quả vô hạn khác

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

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 hoặc nếu tín hiệu bị kẹt, hãy đưa ra một ngoại lệ. Ví dụ:

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

34 trả về

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 có nghĩa là “không phải là số”. Loại

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 này không hoạt động và sau khi được tạo, sẽ chạy qua các tính toán khác và luôn dẫn đến một

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 khác. Hành vi này có thể hữu ích đối với một loạt phép tính đôi khi thiếu đầu vào — nó cho phép phép tính tiếp tục trong khi gắn cờ các kết quả cụ thể là không hợp lệ

Một biến thể là

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

24 phát tín hiệu thay vì giữ im lặng sau mỗi lần vận hành. Đây là một giá trị trả về hữu ích khi một kết quả không hợp lệ cần làm gián đoạn phép tính để xử lý đặc biệt

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

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1. Một bài kiểm tra về sự bằng nhau khi một trong các toán hạng là một giá trị yên tĩnh hoặc có tín hiệu

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 luôn trả về (ngay cả khi thực hiện

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

42), trong khi một bài kiểm tra về sự bất bình đẳng luôn trả về. Một nỗ lực để so sánh hai Số thập phân bằng cách sử dụng bất kỳ toán tử nào trong số các toán tử

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

44,

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

45,

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

46 hoặc

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

47 sẽ tăng tín hiệu nếu một trong hai toán hạng là

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 và trả về nếu tín hiệu này không bị mắc kẹt. Lưu ý rằng đặc tả số học thập phân chung không chỉ định hành vi so sánh trực tiếp; . 7). Để đảm bảo tuân thủ các tiêu chuẩn nghiêm ngặt, hãy sử dụng các phương pháp

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

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

54 và

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

53 thay thế

Các số 0 có dấu có thể là kết quả của các phép tính nằm dưới. Họ giữ dấu hiệu sẽ có kết quả nếu phép tính được thực hiện với độ chính xác cao hơn. Vì độ lớn của chúng bằng 0 nên cả số 0 dương và âm đều được coi là bằng nhau và dấu của chúng là thông tin

Ngoài hai số 0 có dấu phân biệt nhưng bằng nhau, còn có nhiều cách biểu diễn khác nhau của số 0 với độ chính xác khác nhau nhưng có giá trị tương đương. Điều này cần một chút thời gian để làm quen. Đối với một người đã quen với các biểu diễn dấu phẩy động được chuẩn hóa, không rõ ràng ngay lập tức rằng phép tính sau đây trả về một giá trị bằng 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

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

Hàm truy cập một đối tượng khác nhau cho mỗi luồng. Có ngữ cảnh luồng riêng biệt có nghĩa là các luồng có thể thực hiện các thay đổi (chẳng hạn như

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

56) mà không can thiệp vào các luồng khác

Tương tự như vậy, chức năng tự động gán mục tiêu của nó cho luồng hiện tại

Nếu chưa được gọi trước đó, thì sẽ tự động tạo ngữ cảnh mới để sử dụng trong luồng hiện tại

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

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Công thức nấu ăn

Dưới đây là một số công thức đóng vai trò là các hàm tiện ích và minh họa các cách làm việc với lớp

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

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

Q. Thật khó để gõ

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

63. Có cách nào để giảm thiểu việc nhập khi sử dụng trình thông dịch tương tác không?

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

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

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

A. Phương pháp

>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)
>>> setcontext(myothercontext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857142857142857142857142857')

>>> ExtendedContext
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[])
>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857143')
>>> Decimal(42) / Decimal(0)
Decimal('Infinity')

>>> setcontext(BasicContext)
>>> Decimal(42) / Decimal(0)
Traceback (most recent call last):
  File "", line 1, in -toplevel-
    Decimal(42) / Decimal(0)
DivisionByZero: x / 0

7 làm tròn đến một số chữ số thập phân cố định. Nếu bẫy được đặt, nó cũng hữu ích cho việc xác thực

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

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

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

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

Q. Sau khi tôi có hai giá trị đầu vào hợp lệ, làm cách nào để duy trì giá trị bất biến đó trong toàn bộ ứng dụng?

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

>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)
>>> setcontext(myothercontext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857142857142857142857142857')

>>> ExtendedContext
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[])
>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857143')
>>> Decimal(42) / Decimal(0)
Decimal('Infinity')

>>> setcontext(BasicContext)
>>> Decimal(42) / Decimal(0)
Traceback (most recent call last):
  File "", line 1, in -toplevel-
    Decimal(42) / Decimal(0)
DivisionByZero: x / 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')

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

>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)
>>> setcontext(myothercontext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857142857142857142857142857')

>>> ExtendedContext
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[])
>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857143')
>>> Decimal(42) / Decimal(0)
Decimal('Infinity')

>>> setcontext(BasicContext)
>>> Decimal(42) / Decimal(0)
Traceback (most recent call last):
  File "", line 1, in -toplevel-
    Decimal(42) / Decimal(0)
DivisionByZero: x / 0

7 sẽ thuận tiện

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

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

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

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

68,

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

69,

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

70 và

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

71 đều có cùng giá trị ở các độ chính xác khác nhau. Có cách nào để chuyển đổi chúng thành một giá trị chuẩn có thể nhận biết được không?

A. Phương pháp

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

72 ánh xạ tất cả các giá trị tương đương với một đại diện duy nhất

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

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

A. Đối với một số giá trị, ký hiệu hàm mũ là cách duy nhất để biểu thị số vị trí quan trọng trong hệ số. Ví dụ: biểu thị

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

73 thành

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

74 giữ giá trị không đổi nhưng không thể hiển thị ý nghĩa hai vị trí của bản gốc

Nếu một ứng dụng không quan tâm đến việc theo dõi ý nghĩa, thì có thể dễ dàng xóa số mũ và số 0 ở cuối, làm mất ý nghĩa nhưng vẫn giữ nguyên giá trị

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

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

Q. Có cách nào để chuyển đổi số float thông thường thành số không?

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

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

Q. Trong một phép tính phức tạp, làm cách nào để đảm bảo rằng tôi không nhận được kết quả giả do không đủ chính xác hoặc làm tròn bất thường

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

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

A. Đúng. Nguyên tắc là tất cả các giá trị được coi là chính xác và số học trên các giá trị đó cũng vậy. Chỉ có kết quả được làm tròn. Ưu điểm của đầu vào là “những gì bạn nhập là những gì bạn nhận được”. Một nhược điểm là kết quả có thể trông kỳ quặc nếu bạn quên rằng đầu vào chưa được làm tròn

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

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

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

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

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

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

A. Đúng. Trong triển khai CPython và PyPy3, các phiên bản C/CFFI của mô-đun thập phân tích hợp thư viện libmpdec tốc độ cao để có độ chính xác tùy ý làm tròn số học dấu phẩy động thập phân chính xác.

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

77 sử dụng phép nhân Karatsuba cho các số cỡ trung bình và cho các số rất lớn

Bối cảnh phải được điều chỉnh cho số học chính xác tùy ý chính xác.

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

99 và

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

33 phải luôn được đặt thành giá trị tối đa,

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

80 phải luôn là 0 (mặc định). Cài đặt

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

79 yêu cầu một số cẩn thận

Cách tiếp cận đơn giản nhất để thử số học bignum là sử dụng giá trị lớn nhất cho cả

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

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

Đối với kết quả không chính xác, quá lớn trên nền tảng 64 bit và bộ nhớ khả dụng sẽ không đủ

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

Trên các hệ thống có phân bổ tổng thể (e. g. Linux), một cách tiếp cận tinh vi hơn là điều chỉnh

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

79 theo dung lượng RAM khả dụng. Giả sử bạn có 8GB RAM và mong đợi 10 toán hạng đồng thời sử dụng tối đa 500MB mỗi toán hạng

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

Nói chung (và đặc biệt là trên các hệ thống không có phân bổ quá mức), nên ước tính các giới hạn chặt chẽ hơn nữa và đặt bẫy nếu tất cả các tính toán được mong đợi là chính xác

programming python

Làm thế nào để bạn in tối đa n chữ số thập phân trong python?

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

đối tượng thập phân

toán hạng logic

đối tượng bối cảnh

hằng số

Rounding modes

Signals

Ghi chú dấu phẩy động

Giảm thiểu lỗi làm tròn với độ chính xác cao hơn

Giá trị đặc biệt

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

Công thức nấu ăn

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

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội