Hướng dẫn how do you set floating points in python? - làm thế nào để bạn đặt dấu chấm động trong python?

15. Số học dấu phẩy động: Các vấn đề và giới hạnFloating Point Arithmetic: Issues and Limitations¶

Số điểm nổi được thể hiện trong phần cứng máy tính dưới dạng phân số cơ sở 2 (nhị phân). Ví dụ: phân số thập phân

0.0001100110011001100110011001100110011001100110011...

0.0001100110011001100110011001100110011001100110011...

0.0001100110011001100110011001100110011001100110011...

0.0001100110011001100110011001100110011001100110011...

Thật không may, hầu hết các phân số thập phân không thể được biểu diễn chính xác dưới dạng phân số nhị phân. Một hậu quả là, nói chung, các số điểm nổi thập phân bạn nhập chỉ được xấp xỉ bằng các số điểm nổi nhị phân thực sự được lưu trữ trong máy.

Vấn đề dễ hiểu hơn lúc đầu trong cơ sở 10. Xem xét phân số 1/3. Bạn có thể xấp xỉ đó là một phân số cơ sở 10:

hoặc tốt hơn,

hoặc tốt hơn,

và như thế. Cho dù bạn có sẵn sàng viết ra bao nhiêu chữ số, kết quả sẽ không bao giờ chính xác là 1/3, nhưng sẽ là xấp xỉ ngày càng tốt hơn 1/3.

Theo cách tương tự, cho dù có bao nhiêu chữ số cơ sở mà bạn sẵn sàng sử dụng, giá trị thập phân 0.1 không thể được biểu diễn chính xác dưới dạng phân số cơ sở 2. Trong cơ sở 2, 1/10 là phần lặp lại vô hạn

0.0001100110011001100110011001100110011001100110011...

Dừng lại ở bất kỳ số lượng bit hữu hạn, và bạn nhận được một xấp xỉ. Trên hầu hết các máy ngày nay, các phao được xấp xỉ bằng cách sử dụng phần nhị phân với tử số sử dụng 53 bit đầu tiên bắt đầu với bit quan trọng nhất và với mẫu số làm sức mạnh của hai. Trong trường hợp 1/10, phần nhị phân là

0.0001100110011001100110011001100110011001100110011...

Nhiều người dùng không nhận thức được xấp xỉ vì cách hiển thị các giá trị. Python chỉ in một xấp xỉ thập phân cho giá trị thập phân thực của xấp xỉ nhị phân được lưu trữ bởi máy. Trên hầu hết các máy, nếu Python in giá trị thập phân thực sự của xấp xỉ nhị phân được lưu trữ cho 0,1, nó sẽ phải hiển thị

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

Đó là nhiều chữ số hơn hầu hết mọi người thấy hữu ích, vì vậy Python giữ cho số chữ số có thể quản lý được bằng cách hiển thị giá trị tròn thay thế

Chỉ cần nhớ, mặc dù kết quả được in trông giống như giá trị chính xác là 1/10, giá trị được lưu trữ thực tế là phần nhị phân có thể đại diện gần nhất.

Thật thú vị, có nhiều số thập phân khác nhau có chung phân số nhị phân gần đúng gần nhất. Ví dụ: các số

0.0001100110011001100110011001100110011001100110011...

0.0001100110011001100110011001100110011001100110011...

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

0.0001100110011001100110011001100110011001100110011...

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

Trong lịch sử, lời nhắc Python và chức năng

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

0.0001100110011001100110011001100110011001100110011...

0.0001100110011001100110011001100110011001100110011...

Lưu ý rằng đây là bản chất của điểm nổi nhị phân: Đây không phải là một lỗi trong Python và nó cũng không phải là một lỗi trong mã của bạn. Bạn sẽ thấy cùng một loại trong tất cả các ngôn ngữ hỗ trợ số học dấu phẩy động phần cứng của bạn (mặc dù một số ngôn ngữ có thể không hiển thị sự khác biệt theo mặc định hoặc trong tất cả các chế độ đầu ra).

Để có đầu ra dễ chịu hơn, bạn có thể muốn sử dụng định dạng chuỗi để tạo ra một số chữ số quan trọng hạn chế:

>>> format(math.pi, '.12g')  # give 12 significant digits
'3.14159265359'

>>> format(math.pi, '.2f')   # give 2 digits after the point
'3.14'

>>> repr(math.pi)
'3.141592653589793'

Điều quan trọng là phải nhận ra rằng, theo một nghĩa thực tế, là một ảo tưởng: Bạn chỉ đơn giản là làm tròn màn hình của giá trị máy thật.

Một ảo ảnh có thể quên đi một ảo ảnh khác. Ví dụ, vì 0,1 không chính xác 1/10, tổng hợp ba giá trị là 0,1 có thể không mang lại chính xác 0,3, cũng vậy:

>>> .1 + .1 + .1 == .3
False

Ngoài ra, vì 0.1 không thể đến gần hơn với giá trị chính xác là 1/10 và 0.3 không thể tiến gần hơn đến giá trị chính xác là 3/10, sau đó hoạt động trước với hàm

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

>>> round(.1, 1) + round(.1, 1) + round(.1, 1) == round(.3, 1)
False

Mặc dù các số không thể được gần với các giá trị chính xác dự định của chúng, hàm

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

>>> round(.1 + .1 + .1, 10) == round(.3, 10)
True

Số học dấu phẩy động nhị phân giữ nhiều bất ngờ như thế này. Vấn đề với các loại 0.1 0,1 được giải thích chi tiết chính xác dưới đây, trong phần Lỗi đại diện trên mạng. Xem những nguy hiểm của điểm nổi để biết một tài khoản đầy đủ hơn về những bất ngờ phổ biến khác.

Như đã nói gần cuối, không có câu trả lời dễ dàng. Tuy nhiên, don không nên cảnh giác quá mức với điểm nổi! Các lỗi trong các hoạt động nổi Python được kế thừa từ phần cứng dấu phẩy động và trên hầu hết các máy theo thứ tự không quá 1 phần trong 2 ** 53 mỗi hoạt động. Điều đó nhiều hơn đủ cho hầu hết các nhiệm vụ, nhưng bạn cần phải nhớ rằng nó không phải là số học thập phân và mọi hoạt động nổi đều có thể bị lỗi làm tròn mới.

Mặc dù các trường hợp bệnh lý tồn tại, nhưng đối với hầu hết các phép số học thông thường của số học dấu phẩy động, bạn sẽ thấy kết quả mà bạn mong đợi cuối cùng nếu bạn chỉ cần hiển thị kết quả cuối cùng của mình với số chữ số thập phân bạn mong đợi.

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

Đối với các trường hợp sử dụng yêu cầu biểu diễn thập phân chính xác, hãy thử sử dụng mô-đun

>>> format(math.pi, '.12g')  # give 12 significant digits
'3.14159265359'

>>> format(math.pi, '.2f')   # give 2 digits after the point
'3.14'

>>> repr(math.pi)
'3.141592653589793'

Một dạng khác của số học chính xác được hỗ trợ bởi mô -đun

>>> format(math.pi, '.12g')  # give 12 significant digits
'3.14159265359'

>>> format(math.pi, '.2f')   # give 2 digits after the point
'3.14'

>>> repr(math.pi)
'3.141592653589793'

Nếu bạn là người dùng nặng về các hoạt động nổi, bạn nên xem gói Numpy và nhiều gói khác cho các hoạt động toán học và thống kê do dự án SCIPY cung cấp. Nhìn thấy .

Python cung cấp các công cụ có thể giúp trong những dịp hiếm hoi khi bạn thực sự muốn biết giá trị chính xác của một chiếc phao. Phương pháp

>>> format(math.pi, '.12g')  # give 12 significant digits
'3.14159265359'

>>> format(math.pi, '.2f')   # give 2 digits after the point
'3.14'

>>> repr(math.pi)
'3.141592653589793'

>>> x = 3.14159
>>> x.as_integer_ratio()
(3537115888337719, 1125899906842624)

Vì tỷ lệ này là chính xác, nó có thể được sử dụng để tái tạo giá trị ban đầu:

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

Phương pháp

>>> format(math.pi, '.12g')  # give 12 significant digits
'3.14159265359'

>>> format(math.pi, '.2f')   # give 2 digits after the point
'3.14'

>>> repr(math.pi)
'3.141592653589793'

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

Biểu diễn thập lục phân chính xác này có thể được sử dụng để xây dựng lại giá trị nổi chính xác:

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

Vì biểu diễn là chính xác, nó rất hữu ích cho việc chuyển các giá trị đáng tin cậy trên các phiên bản khác nhau của Python (tính độc lập nền tảng) và trao đổi dữ liệu với các ngôn ngữ khác hỗ trợ cùng định dạng (như Java và C99).

Một công cụ hữu ích khác là chức năng

>>> format(math.pi, '.12g')  # give 12 significant digits
'3.14159265359'

>>> format(math.pi, '.2f')   # give 2 digits after the point
'3.14'

>>> repr(math.pi)
'3.141592653589793'

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

>>> format(math.pi, '.12g')  # give 12 significant digits
'3.14159265359'

>>> format(math.pi, '.2f')   # give 2 digits after the point
'3.14'

>>> repr(math.pi)
'3.141592653589793'

>>> format(math.pi, '.12g')  # give 12 significant digits
'3.14159265359'

>>> format(math.pi, '.2f')   # give 2 digits after the point
'3.14'

>>> repr(math.pi)
'3.141592653589793'

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

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

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

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

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

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

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

>>> format(math.pi, '.12g')  # give 12 significant digits
'3.14159265359'

>>> format(math.pi, '.2f')   # give 2 digits after the point
'3.14'

>>> repr(math.pi)
'3.141592653589793'

>>> format(math.pi, '.12g')  # give 12 significant digits
'3.14159265359'

>>> format(math.pi, '.2f')   # give 2 digits after the point
'3.14'

>>> repr(math.pi)
'3.141592653589793'

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