Làm thế nào để bạn int mà không có 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 ngữ cảnh
chế độ làm tròn
tín hiệu
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 được làm tròn. ” – đoạn trích từ đặc tả số học thập phân

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

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

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

>>> 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 bộ 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 của chúng thay vì giá trị số của chúng. Tương tự như phương pháp, nhưng kết quả cho tổng thứ tự trên các trường hợp. Hai trường hợp có cùng giá trị số nhưng cách biểu diễn khác nhau so sánh không bằng nhau theo thứ tự này

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

>>> getcontext().prec = 7       # Set a new 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à liệu chúng đang báo hiệu hay không)

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

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

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

Giống như

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

>>> getcontext().prec = 7       # Set a new 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 ngữ cảnh

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

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

thập phân. getcontext()

Trả về bối cảnh hiện tại cho chuỗi hoạt động

thập phân. setcontext(c)

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

Bạn cũng có thể sử dụng câu lệnh và hàm để tạm thời thay đổi ngữ cảnh hoạt động

thập phân. localcontext(ctx=None , \*\*kwargs)

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

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

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

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

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

Tăng nếu kwargs cung cấp thuộc tính không hỗ trợ. Tăng hoặc nếu kwargs cung cấp giá trị không hợp lệ cho một thuộc tính

Đã thay đổi trong phiên bản 3. 11. hiện hỗ trợ đặt thuộc tính ngữ cảnh thông qua việc sử dụng đối số từ khóa.

Các bối cảnh mới cũng có thể được tạo bằng cách sử dụng hàm tạo được mô tả bên dưới. Ngoài ra, mô-đun cung cấp ba bối cảnh được tạo sẵn

lớp thập phân. Bối cảnh cơ bản

Đây là ngữ cảnh tiêu chuẩn được xác định bởi Đặc tả số học thập phân chung. Độ chính xác được đặt thành chín. Làm tròn được đặt thành. Tất cả cờ bị xóa. Tất cả các bẫy được bật (được coi là ngoại lệ) ngoại trừ , và

Do nhiều bẫy được bật nên bối cảnh này rất hữu ích để gỡ lỗi

lớp thập phân. Ngữ cảnh mở rộng

Đây là ngữ cảnh tiêu chuẩn được xác định bởi Đặc tả số học thập phân chung. Độ chính xác được đặt thành chín. Làm tròn được đặt thành. Tất cả cờ bị xóa. Không có bẫy nào được kích hoạt (để không phát sinh ngoại lệ trong quá trình tính toán)

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

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

1 hoặc

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

9 thay vì đưa ra các ngoại lệ. Điều này cho phép một ứng dụng hoàn thành một lần chạy khi có các điều kiện có thể làm dừng chương trình

lớp thập phân. Ngữ cảnh mặc định

Bối cảnh này được nhà xây dựng sử dụng làm nguyên mẫu cho các bối cảnh mới. Thay đổi một trường (độ chính xác như vậy) có tác dụng thay đổi mặc định cho các ngữ cảnh mới được tạo bởi hàm tạo

Bối cảnh này hữu ích nhất trong môi trường đa luồng. Thay đổi một trong các trường trước khi chuỗi bắt đầu có tác dụng đặt giá trị mặc định trên toàn hệ thống. Không nên thay đổi các trường sau khi các luồng đã bắt đầu vì nó sẽ yêu cầu đồng bộ hóa luồng để ngăn các điều kiện tương tranh

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

Các giá trị mặc định là

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

79=______22_______80,

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

31=, và bật bẫy cho , , và

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

lớp thập phân. Bối cảnh(prec=Không có, rounding=None, Emin=None, Emax=None, capitals=None, clamp=None, flags=None, traps=None)

Tạo bối cảnh mới. Nếu một trường không được chỉ định hoặc là, các giá trị mặc định được sao chép từ. Nếu trường cờ không được chỉ định hoặc là , tất cả các cờ sẽ bị xóa

prec là một số nguyên trong phạm vi [_______18_______16, ] đặt độ chính xác cho các phép toán số học trong ngữ cảnh

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

Các trường bẫy và cờ liệt kê mọi tín hiệu sẽ được đặt. Nói chung, bối cảnh mới chỉ nên đặt bẫy và để trống cờ

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

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

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

15], Emax trong khoảng [

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

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

15, ]

Trường chữ hoa là

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

>>> getcontext().prec = 7       # Set a new 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

16 (mặc định). Nếu được đặt thành

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

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

16, số mũ được in bằng chữ hoa ____22_______99; .

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

Trường kẹp là

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

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

15 (mặc định) hoặc

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

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

16. Nếu được đặt thành

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

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

16, số mũ

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

00 của một trường hợp có thể biểu thị trong ngữ cảnh này bị giới hạn nghiêm ngặt trong phạm vi

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

07. Nếu kẹp là

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

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

15 thì tình trạng yếu hơn sẽ xảy ra. số mũ đã điều chỉnh của phiên bản nhiều nhất là

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

33. Khi clamp là

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

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

16, một số bình thường lớn, nếu có thể, sẽ bị giảm số mũ và một số 0 tương ứng được thêm vào hệ số của nó, để phù hợp với các ràng buộc về số mũ; . Ví dụ

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

Giá trị kẹp của

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

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

16 cho phép tương thích với các định dạng trao đổi thập phân có chiều rộng cố định được chỉ định trong IEEE 754

Lớp này định nghĩa một số phương thức có mục đích chung cũng như một số lượng lớn các phương thức để thực hiện số học trực tiếp trong một ngữ cảnh nhất định. Ngoài ra, đối với mỗi phương pháp được mô tả ở trên (ngoại trừ phương pháp

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

15 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

16) đều có một phương pháp tương ứng. Ví dụ: đối với phiên bản

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

19 và phiên bản

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

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

46, thì

>>> 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 tương đương với

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

23. Mỗi phương thức chấp nhận một số nguyên Python (một thể hiện của ) ở bất kỳ đâu mà một thể hiện Thập phân được chấp nhận

clear_flags()

Đặt lại tất cả các cờ thành

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

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

clear_traps()

Đặt lại tất cả các bẫy thành

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

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

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

bản sao()

Trả lại một bản sao của ngữ cảnh

copy_decimal(num)

Trả về một bản sao của ví dụ thập phân num

create_decimal(num)

Tạo một thể hiện Thập phân mới từ num nhưng sử dụng self làm ngữ cảnh. Không giống như hàm tạo, độ chính xác của ngữ cảnh, phương thức làm tròn, cờ và bẫy được áp dụng cho chuyển đổi

Điều này rất hữu ích vì các hằng số thường được cung cấp cho độ chính xác cao hơn mức cần thiết của ứng dụng. Một lợi ích khác là làm tròn ngay lập tức loại bỏ các hiệu ứng ngoài ý muốn từ các chữ số vượt quá độ chính xác hiện tại. Trong ví dụ sau, sử dụng đầu vào không được làm tròn có nghĩa là việc thêm 0 vào tổng có thể thay đổi kết quả

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

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

create_decimal_from_float(f)

Tạo một thể hiện Thập phân mới từ một float f nhưng làm tròn bằng cách sử dụng self làm ngữ cảnh. Không giống như phương thức lớp, độ chính xác của ngữ cảnh, phương thức làm tròn, cờ và bẫy được áp dụng cho chuyển đổi

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

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

Etiny()

Trả về giá trị bằng _______23_______30 là giá trị số mũ tối thiểu cho kết quả không bình thường. Khi tràn xảy ra, số mũ được đặt thành

Etop()

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

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

Cách tiếp cận thông thường để làm việc với số thập phân là tạo các thể hiện và sau đó áp dụng các phép toán số học diễn ra trong ngữ cảnh hiện tại cho chuỗi hoạt động. Một cách tiếp cận khác là sử dụng các phương thức ngữ cảnh để tính toán trong một ngữ cảnh cụ thể. Các phương thức tương tự như các phương thức dành cho lớp và chỉ được kể lại ngắn gọn ở đây

abs(x)

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

add(x , y)

Trả về tổng của x và y

chính tắc(x)

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

so sánh(x , y)

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

so sánh_signal(x , y)

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

so_total(x , y)

So sánh hai toán hạng sử dụng biểu diễn trừu tượng của chúng

so_total_mag(x , y)

So sánh hai toán hạng bằng biểu diễn trừu tượng của chúng, bỏ qua dấu

copy_abs(x)

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

copy_negate(x)

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

copy_sign(x , y)

Sao chép dấu từ y sang x

chia(x , y)

Trả về x chia cho y

divide_int(x , y)

Trả về x chia cho y, rút gọn thành một số nguyên

divmod(x , y)

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

exp(x)

Trả về

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

fma(x , y, z)

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

is_canonical(x)

Trả về

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

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

75 nếu x là chính tắc;

is_finite(x)

Trả về

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

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

75 nếu x hữu hạn;

is_infinite(x)

Trả về

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

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

75 nếu x là vô hạn;

is_nan(x)

Trả về

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

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

75 nếu x là qNaN hoặc sNaN;

is_normal(x)

Trả về

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

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

75 nếu x là số bình thường;

is_qnan(x)

Trả về

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

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

75 nếu x là NaN yên tĩnh;

is_signed(x)

Trả về

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

>>> getcontext().prec = 7       # Set a new 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)

Compares the values numerically with their sign ignored

min(x , y)

Compares two values numerically and returns the minimum

min_mag(x , y)

Compares the values numerically with their sign ignored

minus(x)

Minus corresponds to the unary prefix minus operator in Python

multiply(x , y)

Return the product of x and y

next_minus(x)

Returns the largest representable number smaller than x

next_plus(x)

Returns the smallest representable number larger than x

next_toward(x , y)

Returns the number closest to x, in direction towards y

normalize(x)

Reduces x to its simplest form

number_class(x)

Returns an indication of the class of x

plus(x)

Plus corresponds to the unary prefix plus operator in Python. This operation applies the context precision and rounding, so it is not an identity operation

power(x , y , modulo=None)

Return

>>> from decimal import *
>>> getcontext()
Context(prec=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 to the power 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

47, reduced 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 if given

With two arguments, compute

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

>>> from decimal import *
>>> getcontext()
Context(prec=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 is negative then

>>> from decimal import *
>>> getcontext()
Context(prec=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 must be integral. The result will be inexact unless

>>> from decimal import *
>>> getcontext()
Context(prec=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 is integral and the result is finite and can be expressed exactly in ‘precision’ digits. The rounding mode of the context is used. Results are always correctly rounded in the Python version

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

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

3, and if

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

3 is not trapped, then results in

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

Changed in version 3. 3. The C module computes in terms of the correctly rounded and functions. 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".

With three arguments, compute

>>> 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. For the three argument form, the following restrictions on the arguments hold

all three arguments must be integral

>>> from decimal import *
>>> getcontext()
Context(prec=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 must be nonnegative

at least one 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

46 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

47 must be nonzero

>>> 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 must be nonzero and have at most ‘precision’ digits

The value resulting from

>>> 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 is equal to the value that would be obtained by computing

>>> 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 with unbounded precision, but is computed more efficiently. The exponent of the result is zero, regardless of the exponents 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

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

58. The result is always exact

quantize(x , y)

Returns a value equal to x (rounded), having the exponent of y

cơ số()

Just returns 10, as this is Decimal, . )

remainder(x , y)

Returns the remainder from integer division

The sign of the result, if non-zero, is the same as that of the original dividend

remainder_near(x , y)

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

80, where n is the integer nearest the exact value of

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

81 (if the result is 0 then its sign will be the sign of x)

rotate(x , y)

Returns a rotated copy of x, y times

same_quantum(x , y)

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 the two operands have the same exponent

scaleb(x , y)

Returns the first operand after adding the second value its exp

shift(x , y)

Returns a shifted copy of x, y times

sqrt(x)

Square root of a non-negative number to context precision

subtract(x , y)

Return the difference between x and y

to_eng_string(x)

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

to_integral_exact(x)

Rounds to an integer

to_sci_string(x)

Converts a number to a string using scientific notation

Constants

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

thập phân. HAVE_THREADS

Giá trị là

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

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

75. Không dùng nữa, vì Python giờ đây luôn có chủ đề

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

thập phân. HAVE_CONTEXTVAR

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

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

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

75. Nếu Python là , thì phiên bản C sử dụng ngữ cảnh cục bộ luồng thay vì bối cảnh cục bộ coroutine và giá trị là

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

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

76. Điều này nhanh hơn một chút trong một số tình huống ngữ cảnh lồng nhau

Mới trong phiên bản 3. 9. đã nhập ngược về 3. 7 và 3. 8.

chế độ làm tròn

thập phân. ROUND_CEILING

Vòng về phía

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

thập phân. ROUND_DOWN

Làm tròn về số không

thập phân. ROUND_FLOOR

Vòng về phía

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

thập phân. ROUND_HALF_DOWN

Làm tròn đến gần nhất với các mối quan hệ tiến về 0

thập phân. ROUND_HALF_EVEN

Làm tròn đến gần nhất với các mối quan hệ sẽ đến số nguyên chẵn gần nhất

thập phân. ROUND_HALF_UP

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

thập phân. ROUND_UP

Làm tròn từ số 0

thập phân. ROUND_05UP

Làm tròn từ 0 nếu chữ số cuối cùng sau khi làm tròn về 0 sẽ là 0 hoặc 5;

tín hiệu

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

Cờ ngữ cảnh được đặt bất cứ khi nào gặp điều kiện. Sau khi tính toán, các cờ có thể được kiểm tra cho các mục đích thông tin (ví dụ: để xác định xem một phép tính có chính xác hay không). Sau khi kiểm tra các cờ, đảm bảo xóa tất cả các cờ trước khi bắt đầu tính toán tiếp theo

Nếu trình kích hoạt bẫy của ngữ cảnh được đặt cho tín hiệu, thì điều kiện sẽ gây ra một ngoại lệ Python được đưa ra. Ví dụ: nếu bẫy được đặt, thì một ngoại lệ sẽ xuất hiện khi gặp điều kiện

lớp thập phân. Đã kẹp

Đã thay đổi số mũ để phù hợp với các ràng buộc biểu diễn

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

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 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. Nếu có thể, số mũ được giảm xuống cho phù hợp bằng cách thêm các số 0 vào hệ số

lớp thập phân. DecimalException

Lớp cơ sở cho các tín hiệu khác và một lớp con của

lớp thập phân. DivisionByZero

Báo hiệu phép chia một số không vô hạn cho 0

Có thể xảy ra với phép chia, phép chia modulo hoặc khi nâng một số lên lũy thừa âm. Nếu tín hiệu này không bị giữ lại, trả về

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

9 hoặc

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

0 với dấu hiệu được xác định bởi đầu vào của phép tính

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 chuỗi 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, có thể dễ dàng loại bỏ số mũ và số 0 ở cuối, làm mất ý nghĩa nhưng vẫn giữ nguyên giá trị

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

>>> 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 int mà không có 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 ngữ cảnh

Constants

chế độ làm tròn

tín hiệu

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