Hướng dẫn convert float to decimal python - chuyển đổi float thành python thập phân

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

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

>>> from decimal import *
>>> getcontext()
Context(prec=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 trường hợp thập phân có thể được xây dựng từ số nguyên, dây, phao hoặc bộ dữ liệu. Xây dựng từ một số nguyên hoặc phao thực hiện chuyển đổi chính xác giá trị của số nguyên hoặc phao. Các số thập phân bao gồm các giá trị đặc biệt như

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> 0.1 + 0.2 == 0.3
False

Nếu tín hiệ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

>>> 0.1 + 0.2 == 0.3
False

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

Tầm quan trọng của một số thập phân mới được xác định chỉ bằng số lượng đầu vào. Độ chính xác bối cảnh và làm tròn chỉ phát huy tác dụng trong các hoạt động số học.

>>> 0.1 + 0.2 == 0.3
False

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

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

>>> 0.1 + 0.2 == 0.3
False

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

Số thập phân tương tác tốt với phần lớn phần còn lại của Python. Dưới đây là một rạp xiếc bay thả nổi số thập phân nhỏ:

>>> 0.1 + 0.2 == 0.3
False

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

>>> 0.1 + 0.2 == 0.3
False

Phương pháp

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

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

>>> from decimal import *
>>> getcontext()
Context(prec=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 với công việc nâng cao hơn, có thể hữu ích để tạo bối cảnh thay thế bằng cách sử dụng hàm tạo ngữ cảnh (). Để thực hiện hoạt động thay thế, hãy sử dụng hàm

>>> 0.1 + 0.2 == 0.3
False

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

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

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

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

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

>>> 0.1 + 0.2 == 0.3
False

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

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

Hầu hết các chương trình điều chỉnh bối cảnh hiện tại chỉ một lần, khi bắt đầu chương trình. Và, trong nhiều ứng dụng, dữ liệu được chuyển đổi thành

>>> 0.1 + 0.2 == 0.3
False

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

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

>>> 0.1 + 0.2 == 0.3
False

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

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

Nếu giá trị là

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

Nếu giá trị là

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

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

>>> 0.1 + 0.2 == 0.3
False

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

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

>>> import math
>>> math.log10(2**53)
15.954589770191003

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

>>> 0.1 + 0.2 == 0.3
False

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

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

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

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

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

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

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

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

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

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

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

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> 0.1 + 0.2 == 0.3
False

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> 0.1 + 0.2 == 0.3
False

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

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Các toán tử

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

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

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

Thay đổi trong phiên bản 3.2: So sánh loại hỗn hợp giữa các trường hợp

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

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

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

>>> 0.1 + 0.2 == 0.3
False

Trả về một cặp

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

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

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

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

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

>>> 0.1 + 0.2 == 0.3
False

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

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

>>> 0.1 + 0.2 == 0.3
False

So sánh hai toán hạng bằng cách sử dụng biểu diễn trừu tượng của chúng thay vì giá trị số của chúng. Tương tự như phương pháp

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

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

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

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

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

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

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

Chỉ cần trả lại bản thân, phương pháp này chỉ tuân thủ đặc tả số thập phân.

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

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

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

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

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

>>> 0.1 + 0.2 == 0.3
False

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

ClassMethod ________ 188 (f)

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

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> 0.1 + 0.2 == 0.3
False

Lưu ý

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Ghi chú

>>> 0.1 + 0.2 == 0.3
False

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

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

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả lại

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

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

Trả lại cơ sở mười logarit của toán hạng. Kết quả được làm tròn chính xác bằng chế độ làm tròn

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

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

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import *
>>> getcontext()
Context(prec=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 Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Giống như

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> import math
>>> math.log10(2**53)
15.954589770191003

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

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Giống như

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> import math
>>> math.log10(2**53)
15.954589770191003

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

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

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

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

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

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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.

• >>> from decimal import Decimal
  >>> def ftod(val, prec = 15):   # float to Decimal
  ...     return Decimal(val).quantize(Decimal(10)**-prec)
  ... 
  >>> ftod(0.1) + ftod(0.2) == ftod(0.3)
  True
  

  69, chỉ ra rằng toán hạng là vô cùng tiêu cực.

• >>> from decimal import Decimal
  >>> def ftod(val, prec = 15):   # float to Decimal
  ...     return Decimal(val).quantize(Decimal(10)**-prec)
  ... 
  >>> ftod(0.1) + ftod(0.2) == ftod(0.3)
  True
  

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

• >>> from decimal import Decimal
  >>> def ftod(val, prec = 15):   # float to Decimal
  ...     return Decimal(val).quantize(Decimal(10)**-prec)
  ... 
  >>> ftod(0.1) + ftod(0.2) == ftod(0.3)
  True
  

  71, chỉ ra rằng toán hạng là âm và dưới mức.

• >>> from decimal import Decimal
  >>> def ftod(val, prec = 15):   # float to Decimal
  ...     return Decimal(val).quantize(Decimal(10)**-prec)
  ... 
  >>> ftod(0.1) + ftod(0.2) == ftod(0.3)
  True
  

  72, chỉ ra rằng toán hạng là số 0 âm.

• >>> from decimal import Decimal
  >>> def ftod(val, prec = 15):   # float to Decimal
  ...     return Decimal(val).quantize(Decimal(10)**-prec)
  ... 
  >>> ftod(0.1) + ftod(0.2) == ftod(0.3)
  True
  

  73, chỉ ra rằng toán hạng là số 0 dương.

• >>> from decimal import Decimal
  >>> def ftod(val, prec = 15):   # float to Decimal
  ...     return Decimal(val).quantize(Decimal(10)**-prec)
  ... 
  >>> ftod(0.1) + ftod(0.2) == ftod(0.3)
  True
  

  74, chỉ ra rằng toán hạng là dương và dưới mức.

• >>> from decimal import Decimal
  >>> def ftod(val, prec = 15):   # float to Decimal
  ...     return Decimal(val).quantize(Decimal(10)**-prec)
  ... 
  >>> ftod(0.1) + ftod(0.2) == ftod(0.3)
  True
  

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

• >>> from decimal import Decimal
  >>> def ftod(val, prec = 15):   # float to Decimal
  ...     return Decimal(val).quantize(Decimal(10)**-prec)
  ... 
  >>> ftod(0.1) + ftod(0.2) == ftod(0.3)
  True
  

  76, chỉ ra rằng toán hạng là vô cùng dương tính.

• >>> from decimal import Decimal
  >>> def ftod(val, prec = 15):   # float to Decimal
  ...     return Decimal(val).quantize(Decimal(10)**-prec)
  ... 
  >>> ftod(0.1) + ftod(0.2) == ftod(0.3)
  True
  

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

• >>> from decimal import Decimal
  >>> def ftod(val, prec = 15):   # float to Decimal
  ...     return Decimal(val).quantize(Decimal(10)**-prec)
  ... 
  >>> ftod(0.1) + ftod(0.2) == ftod(0.3)
  True
  

  78, chỉ ra rằng toán hạng là NAN báo hiệu.

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

>>> Decimal(10)**-4
Decimal('0.0001')

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

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

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

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

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> 0.1 + 0.2 == 0.3
False

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

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

>>> Decimal(10)**-4
Decimal('0.0001')

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

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

>>> import math
>>> math.log10(2**53)
15.954589770191003

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

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

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

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

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

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

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

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

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

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

Vòng tròn đến số nguyên gần nhất, báo hiệ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

>>> from decimal import *
>>> getcontext()
Context(prec=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 Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Tròn đến số nguyên gần nhất mà không có tín hiệ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

>>> from decimal import *
>>> getcontext()
Context(prec=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 Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

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

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

Mỗi luồng có ngữ cảnh hiện tại riêng được truy cập hoặc thay đổi bằng các hàm

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

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

>>> 0.1 + 0.2 == 0.3
False

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

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

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

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

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

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

>>> Decimal(10)**-4
Decimal('0.0001')

Bối cảnh mới cũng có thể được tạo bằng trình xây dựng

>>> Decimal(10)**-4
Decimal('0.0001')

Đây là một bối cảnh tiêu chuẩn được xác định bởi đặc tả số học thập phân chung. Độ chính xác được đặt thành chín. Làm tròn được đặt thành

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

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

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

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

Đây là một bối cảnh tiêu chuẩn được xác định bởi đặc tả số học thập phân chung. Độ chính xác được đặt thành chín. Làm tròn được đặt thành

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

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

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> import math
>>> math.log10(2**53)
15.954589770191003

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

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

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

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

Các giá trị mặc định là ________ 347 = ________ 348, ________ 281 = ________ 84 và đã kích hoạt bẫy cho

>>> from decimal import *
>>> getcontext()
Context(prec=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().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')

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

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

>>> Decimal(10)**-4
Decimal('0.0001')

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

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

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

>>> 0.1 + 0.2 == 0.3
False

>>> Decimal(10)**-4
Decimal('0.0001')

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

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

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

>>> Decimal(10)**-4
Decimal('0.0001')

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> Decimal(10)**-4
Decimal('0.0001')

Trường thủ đô là

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

Trường kẹp là

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> Decimal(10)**-4
Decimal('0.0001')

>>> 0.1 + 0.2 == 0.3
False

>>> Decimal(10)**-4
Decimal('0.0001')

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> 0.1 + 0.2 == 0.3
False

>>> Decimal(10)**-4
Decimal('0.0001')

Giá trị kẹp của

>>> 0.1 + 0.2 == 0.3
False

Lớp

>>> Decimal(10)**-4
Decimal('0.0001')

>>> 0.1 + 0.2 == 0.3
False

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

>>> Decimal(10)**-4
Decimal('0.0001')

>>> 0.1 + 0.2 == 0.3
False

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

>>> 0.1 + 0.2 == 0.3
False

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

>>> 0.1 + 0.2 == 0.3
False

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

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

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

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

>>> 0.1 + 0.2 == 0.3
False

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

>>> Decimal(10)**-4
Decimal('0.0001')

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

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

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

>>> Decimal(10)**-4
Decimal('0.0001')

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

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

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

Cách tiếp cận thông thường để làm việc với số thập phân là tạo các trường hợp

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

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

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

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

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

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

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

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

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

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

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

Trả lại x chia cho y.

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

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

Trả về

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

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

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả lại

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

Trả về

>>> 0.1 + 0.2 == 0.3
False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

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

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

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

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

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

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

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

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

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

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

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

________ 470 (x)

________ 471 (x, y) ¶

________ 259 (x)

________ 260 (x)

________ 261 (x, y)

________ 262 (x)

________ 268 (x)

________ 477 (x)

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

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

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

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

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

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

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

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

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

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

• >>> 0.1 + 0.2 == 0.3
  False
  

  55 phải không âm

• Ít nhất một trong số

  >>> 0.1 + 0.2 == 0.3
  False
  

  54 hoặc

  >>> 0.1 + 0.2 == 0.3
  False
  

  55 phải là không

• >>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
  ...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
  ... 
  float:   0.100000000000000006
  float:   0.200000000000000011
  float:   0.299999999999999989
  Decimal: 0.100000000000000000
  Decimal: 0.200000000000000000
  Decimal: 0.300000000000000000
  

  81 phải là khác không và có nhiều nhất là các chữ số chính xác

Giá trị kết quả từ

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

>>> 0.1 + 0.2 == 0.3
False

>>> 0.1 + 0.2 == 0.3
False

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

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

Chỉ cần trả lại 10, vì đây là thập phân, :)

Trả về phần còn lại từ bộ phận số nguyên.

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

Trả về

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

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

Trả về

>>> 0.1 + 0.2 == 0.3
False

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

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

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

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

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

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

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

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

Hằng số trong

Các hằng số trong phần này chỉ liên quan đến mô -đun C. Chúng cũng được bao gồm trong phiên bản Python Pure Python để tương thích.

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

Giá trị là

>>> 0.1 + 0.2 == 0.3
False

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

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

>>> 0.1 + 0.2 == 0.3
False

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

Chế độ làm tròn

Vòng hướng về

>>> import math
>>> math.log10(2**53)
15.954589770191003

Vòng về phía 0.

Vòng quay về phía

>>> import math
>>> math.log10(2**53)
15.954589770191003

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

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

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

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

Làm tròn từ 0 nếu chữ số cuối cùng sau khi làm tròn về 0 sẽ là 0 hoặc 5; nếu không tròn về phía bằng không.

Tín hiệu/

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

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

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

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

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

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

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

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

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

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> import math
>>> math.log10(2**53)
15.954589770191003

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

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

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

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

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> Decimal(10)**-4
Decimal('0.0001')

Tràn số.

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

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> import math
>>> math.log10(2**53)
15.954589770191003

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

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

Báo hiệu bất cứ khi nào làm tròn loại bỏ các chữ số; Ngay cả khi các chữ số đó bằng không (chẳng hạn như làm tròn

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

Số mũ thấp hơn

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

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

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

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

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

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

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

>>> 0.1 + 0.2 == 0.3
False

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

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

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

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

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

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

>>> Decimal(10)**-4
Decimal('0.0001')

Ghi chú điểm nổi

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> Decimal(10)**-4
Decimal('0.0001')

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> Decimal(10)**-4
Decimal('0.0001')

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

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

>>> import math
>>> math.log10(2**53)
15.954589770191003

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

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> 0.1 + 0.2 == 0.3
False

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

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

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> import math
>>> math.log10(2**53)
15.954589770191003

>>> 0.1 + 0.2 == 0.3
False

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

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

Hàm

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

>>> Decimal(10)**-4
Decimal('0.0001')

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

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

>>> 0.1 + 0.2 == 0.3
False

Nếu

>>> 0.1 + 0.2 == 0.3
False

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

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

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

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

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

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

>>> 0.1 + 0.2 == 0.3
False

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

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

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

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

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

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

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

A. Phương pháp

>>> 0.1 + 0.2 == 0.3
False

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

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

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

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

>>> 0.1 + 0.2 == 0.3
False

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

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

>>> 0.1 + 0.2 == 0.3
False

>>> for x in [0.1, 0.2, 0.3, ftod(0.1), ftod(0.2), ftod(0.3)]:
...     print("{:8} {:.18f}".format(type(x).__name__+":", x))
... 
float:   0.100000000000000006
float:   0.200000000000000011
float:   0.299999999999999989
Decimal: 0.100000000000000000
Decimal: 0.200000000000000000
Decimal: 0.300000000000000000

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

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

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

A. Phương pháp

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

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

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

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

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

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

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

>>> 0.1 + 0.2 == 0.3
False

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

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

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

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

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

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

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

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

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

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

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

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

A. Có. Trong các triển khai Cpython và Pypy3, các phiên bản C/CFFI của mô-đun thập phân tích hợp thư viện LibMPDEC tốc độ cao để có độ chính xác theo độ chính xác chính xác số.

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

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

>>> from decimal import Decimal
>>> def ftod(val, prec = 15):   # float to Decimal
...     return Decimal(val).quantize(Decimal(10)**-prec)
... 
>>> ftod(0.1) + ftod(0.2) == ftod(0.3)
True

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> Decimal(10)**-4
Decimal('0.0001')

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

>>> Decimal(10)**-4
Decimal('0.0001')

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

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

>>> Decimal(10)**-4
Decimal('0.0001')

>>> for p in [15, 16, 17]:
...     print("Rounding precision: {}. Check  0.1 + 0.2 == 0.3  is {}".format(p,
...         ftod(0.1, p) + ftod(0.2, p) == ftod(0.3, p)))
... 
Rounding precision: 15. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 16. Check  0.1 + 0.2 == 0.3  is True
Rounding precision: 17. Check  0.1 + 0.2 == 0.3  is False

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

>>> Decimal(10)**-4
Decimal('0.0001')

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

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

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

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