Cách xử lý lỗi làm tròn dấu chấm động python

Số dấu phẩy động là một cách nhanh chóng và hiệu quả để lưu trữ và làm việc với các con số, nhưng chúng đi kèm với một loạt cạm bẫy chắc chắn đã khiến nhiều lập trình viên non nớt bối rối — có lẽ cả một số lập trình viên có kinh nghiệm. Ví dụ cổ điển chứng minh những cạm bẫy của phao diễn ra như thế này

>>> 0.1 + 0.2 == 0.3
False

Nhìn thấy điều này lần đầu tiên có thể mất phương hướng. Nhưng đừng ném máy tính của bạn vào thùng rác. Hành vi này là đúng

Bài viết này sẽ cho bạn thấy tại sao các lỗi dấu phẩy động như lỗi trên lại phổ biến, tại sao chúng lại có ý nghĩa và bạn có thể làm gì để xử lý chúng trong Python

📹

Thích video hơn?

Máy tính của bạn là một kẻ nói dối [Sắp xếp]

Bạn đã thấy rằng

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

0 không bằng

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

1 nhưng sự điên rồ không dừng lại ở đó. Dưới đây là một số ví dụ khó hiểu hơn

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

Vấn đề cũng không bị hạn chế đối với các phép so sánh bình đẳng

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

Vì vậy những gì đang xảy ra?

Khi bạn nhập số

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

2 vào trình thông dịch Python, nó sẽ được lưu trong bộ nhớ dưới dạng số dấu phẩy động. Có một chuyển đổi diễn ra khi điều này xảy ra.

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

2 là một số thập phân trong cơ số 10, nhưng các số dấu phẩy động được lưu trữ ở dạng nhị phân. Nói cách khác,

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

2 được chuyển đổi từ cơ số 10 sang cơ số 2

Số nhị phân kết quả có thể không đại diện chính xác cho số cơ sở 10 ban đầu.

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

2 là một ví dụ. Biểu diễn nhị phân là \[0. 0\overline{0011}\]. Nghĩa là,

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

2 là số thập phân lặp vô hạn khi viết trong cơ số 2. Điều tương tự cũng xảy ra khi bạn viết phân số ⅓ dưới dạng số thập phân trong cơ số 10. Bạn kết thúc với số thập phân lặp lại vô tận \[0. \overline{33}\]

Bộ nhớ máy tính là hữu hạn, do đó biểu diễn phân số nhị phân lặp lại vô hạn của

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

2 được làm tròn thành một phân số hữu hạn. Giá trị của số này phụ thuộc vào kiến ​​trúc máy tính của bạn [32-bit so với. 64-bit]. Một cách để xem giá trị dấu phẩy động được lưu trữ cho

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

2 là sử dụng phương thức

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

9 cho số float để lấy tử số và mẫu số của biểu diễn dấu phẩy động

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

3

Bây giờ sử dụng

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

30 để hiển thị phân số chính xác đến 55 chữ số thập phân

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

5

Vì vậy,

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

2 được làm tròn thành một số lớn hơn một chút so với giá trị thực của nó

🐍

Tìm hiểu thêm về các phương thức số như

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

9 trong bài viết của tôi 3 điều bạn có thể chưa biết về số trong Python

Lỗi này, được gọi là lỗi biểu diễn dấu chấm động, xảy ra thường xuyên hơn bạn có thể nhận ra

Muốn nhiều hơn như thế này?

Một email vào thứ Bảy hàng tuần với một mẹo hữu ích.
Luôn mất ít hơn 5 phút thời gian của bạn.

Theo dõi ngay

Đang xử lý đơn đăng ký của bạn Tuyệt vời. Kiểm tra hộp thư đến của bạn và xác nhận đăng ký của bạn Đã xảy ra lỗi khi gửi email

Lỗi đại diện là thực sự phổ biến

Có ba lý do khiến một số được làm tròn khi được biểu diễn dưới dạng số dấu phẩy động

1. Số có nhiều chữ số có nghĩa hơn số dấu phẩy động cho phép
2. Con số là vô lý
3. Số này là số hữu tỷ nhưng có biểu diễn nhị phân không chấm dứt

Số dấu phẩy động 64 bit tốt cho khoảng 16 hoặc 17 chữ số có nghĩa. Số nào có nhiều chữ số có nghĩa hơn thì được làm tròn. Các số vô tỷ, như π và e, không thể được biểu diễn bằng bất kỳ phân số tận cùng nào trong bất kỳ cơ số nguyên nào. Vì vậy, một lần nữa, không có vấn đề gì, các số vô tỷ sẽ được làm tròn khi được lưu trữ dưới dạng số float

Hai tình huống này tạo ra một tập hợp vô hạn các số không thể được biểu diễn chính xác dưới dạng số dấu phẩy động. Nhưng trừ khi bạn là một nhà hóa học xử lý các số nhỏ hoặc một nhà vật lý xử lý các số lớn về mặt thiên văn, bạn sẽ không gặp phải những vấn đề này

Còn các số hữu tỷ không tận cùng, như

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

2 trong cơ số 2 thì sao?

Trong cơ số 10, một phân số kết thúc nếu mẫu số của nó là tích của các lũy thừa của các thừa số nguyên tố là 10. Hai thừa số nguyên tố của 10 là 2 và 5, vì vậy các phân số như ½, ¼, ⅕, ⅛ và ⅒ đều có tận cùng, nhưng ⅓, ⅐ và ⅑ thì không. Tuy nhiên, trong cơ sở 2, chỉ có một thừa số nguyên tố. 2. Vậy chỉ những phân số có mẫu số là lũy thừa của 2 mới chấm dứt. Kết quả là, các phân số như ⅓, ⅕, ⅙, ⅐, ⅑ và ⅒ đều không có tận cùng khi được biểu diễn dưới dạng nhị phân

Bây giờ bạn có thể hiểu ví dụ ban đầu trong bài viết này.

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

2,

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

35 và

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

1 đều được làm tròn khi chuyển sang số dấu phẩy động

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

2

Khi

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

2 và

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

35 được thêm vào, kết quả là một số lớn hơn một chút so với

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

1

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

6

Vì

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

0 lớn hơn một chút so với

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

1 và

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

1 được biểu thị bằng một số nhỏ hơn chính nó một chút, nên biểu thức

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

53 có giá trị là

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

54

❗

Lỗi biểu diễn dấu phẩy động là điều mà mọi lập trình viên ở mọi ngôn ngữ cần lưu ý và biết cách xử lý. Nó không dành riêng cho Python. Bạn có thể xem kết quả của việc in

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

0 bằng nhiều ngôn ngữ khác nhau tại trang web được đặt tên phù hợp của Erik Wiffin 0. 30000000000000004. com

Cách so sánh số float trong Python

Vì vậy, làm cách nào để bạn xử lý các lỗi biểu diễn dấu phẩy động khi so sánh số float trong Python? . Không bao giờ sử dụng

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

56,

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

57 hoặc

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

58 với phao nổi. Sử dụng chức năng thay thế

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

6

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59 kiểm tra xem đối số thứ nhất có gần với đối số thứ hai không. Nhưng chính xác điều đó có nghĩa là gì?

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

8

Nếu

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

21 nhỏ hơn một số tỷ lệ phần trăm lớn hơn của

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

22 hoặc

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

23, thì

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

22 được coi là đủ gần với

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

23 để "bằng" với

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

23. Tỷ lệ phần trăm này được gọi là dung sai tương đối. Bạn có thể chỉ định dung sai tương đối với đối số từ khóa

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

27 của

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59 mặc định là

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

29. Nói cách khác, nếu

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

21 nhỏ hơn

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

61, thì

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

22 và

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

23 được coi là "gần" nhau. Điều này đảm bảo rằng

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

22 và

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

23 bằng khoảng chín chữ số thập phân

Bạn có thể thay đổi dung sai tương đối nếu cần

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

4

Tất nhiên, dung sai tương đối phụ thuộc vào các ràng buộc do vấn đề bạn đang giải quyết đặt ra. Tuy nhiên, đối với hầu hết các ứng dụng hàng ngày, dung sai tương đối mặc định là đủ

Tuy nhiên, có vấn đề nếu một trong số

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

22 hoặc

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

23 bằng 0 và

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

27 nhỏ hơn một. Trong trường hợp đó, cho dù giá trị khác không gần bằng 0 đến mức nào, dung sai tương đối đảm bảo rằng việc kiểm tra độ gần sẽ luôn thất bại. Trong trường hợp này, sử dụng dung sai tuyệt đối có tác dụng như một biện pháp dự phòng

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

0

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59 sẽ tự động thực hiện việc kiểm tra này cho bạn. Đối số từ khóa

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

60 xác định dung sai tuyệt đối. Tuy nhiên,

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

60 mặc định là

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

62Vì vậy, bạn sẽ cần đặt giá trị này theo cách thủ công nếu bạn cần kiểm tra xem một giá trị gần bằng 0 đến mức nào

Nói chung,

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59 trả về kết quả so sánh sau đây, kết hợp các kiểm tra tương đối và tuyệt đối thành một biểu thức duy nhất

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

1

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59 đã được giới thiệu trong PEP 485 và đã có sẵn kể từ Python 3. 5

Vượt qua "cái bướu trung gian". "

Một email, vào thứ Bảy hàng tuần, để thử thách kỹ năng của bạn và khơi dậy trí tò mò. Luôn ít hơn 5 phút thời gian của bạn

Theo dõi ngay

Đang xử lý đơn đăng ký của bạn Tuyệt vời. Kiểm tra hộp thư đến của bạn và xác nhận đăng ký của bạn Đã xảy ra lỗi khi gửi email

Khi nào bạn nên sử dụng

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59?

Nói chung, bạn nên sử dụng

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59 bất cứ khi nào bạn cần so sánh các giá trị dấu phẩy động. Thay thế

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

56 bằng

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

2

Bạn cũng cần cẩn thận với các phép so sánh giữa

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

57 và

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

58. Xử lý đẳng thức một cách riêng biệt bằng cách sử dụng

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59 và sau đó kiểm tra so sánh nghiêm ngặt

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

3

Nhiều lựa chọn thay thế cho

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59 tồn tại. Nếu bạn sử dụng NumPy, bạn có thể tận dụng

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

83 và

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

84

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

4

Hãy nhớ rằng dung sai tương đối và tuyệt đối mặc định không giống như

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59. Dung sai tương đối mặc định cho cả

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

86 và

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

87 là

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

88 và dung sai tuyệt đối mặc định cho cả hai là

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

89

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59 đặc biệt hữu ích cho các bài kiểm tra đơn vị, mặc dù có một số lựa chọn thay thế. Mô-đun

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

41 tích hợp sẵn của Python có phương thức

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

42. Tuy nhiên phương pháp đó chỉ sử dụng phép thử chênh lệch tuyệt đối. Nó cũng là một sự khẳng định, nghĩa là những thất bại làm tăng

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

43, khiến nó không phù hợp để so sánh trong logic kinh doanh của bạn

Một giải pháp thay thế tuyệt vời cho

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59 để kiểm thử đơn vị là hàm

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

45 từ gói

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

46. Không giống như

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59,

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

48 chỉ nhận một đối số — cụ thể là giá trị mà bạn mong đợi

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

5

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

48 có các đối số từ khóa

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

27 và

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

60 để đặt dung sai tương đối và tuyệt đối. Tuy nhiên, các giá trị mặc định khác với

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

59.

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

27 có giá trị mặc định là

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

04 và

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

60 có giá trị mặc định là

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

06

Nếu đối số được truyền cho

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

48 giống như mảng, nghĩa là nó có thể lặp lại trong Python giống như danh sách hoặc bộ dữ liệu hoặc thậm chí là mảng NumPy, thì

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

48 hoạt động tương tự như

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

86 và trả về việc hai mảng có bằng nhau trong dung sai hay không

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

6

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2
True

>>> 0.8 - 0.1 > 0.7
True

48 thậm chí sẽ hoạt động với các giá trị từ điển

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

7

Các số dấu phẩy động rất tốt để làm việc với các số bất cứ khi nào không cần độ chính xác tuyệt đối. Chúng nhanh và hiệu quả về bộ nhớ. Nhưng nếu bạn cần độ chính xác, thì có một số lựa chọn thay thế cho số float mà bạn nên cân nhắc

Các lựa chọn thay thế dấu phẩy động chính xác

Có hai loại số tích hợp trong Python cung cấp độ chính xác đầy đủ cho các tình huống không đủ số float.

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

11 và

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

12

Loại

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

11

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

14 có thể lưu trữ các giá trị thập phân một cách chính xác với độ chính xác mà bạn cần. Theo mặc định,

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

11 giữ nguyên 28 chữ số có nghĩa, nhưng bạn có thể thay đổi giá trị này thành bất kỳ giá trị nào bạn cần để phù hợp với vấn đề cụ thể mà bạn đang giải quyết

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

8

Bạn có thể đọc thêm về loại

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

11 trong tài liệu Python

Loại

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

12

Một cách thay thế khác cho số dấu phẩy động là.

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

12 có thể lưu trữ chính xác các số hữu tỷ và khắc phục các sự cố lỗi biểu diễn mà các số dấu phẩy động gặp phải

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

9

Cả

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

12 và

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

11 đều mang lại nhiều lợi ích so với các giá trị dấu phẩy động tiêu chuẩn. Tuy nhiên, những lợi ích này có giá. giảm tốc độ và tiêu thụ bộ nhớ cao hơn. Nếu bạn không cần độ chính xác tuyệt đối, tốt hơn hết là bạn nên sử dụng phao. Nhưng đối với những thứ như các ứng dụng quan trọng về tài chính và nhiệm vụ, sự cân bằng phát sinh bởi

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

12 và

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

11 có thể đáng giá

Phần kết luận

Các giá trị dấu phẩy động vừa là một may mắn vừa là một lời nguyền. Chúng cung cấp các phép tính số học nhanh và sử dụng bộ nhớ hiệu quả với chi phí biểu diễn không chính xác. Trong bài viết này, bạn đã học

• Tại sao số dấu phẩy động không chính xác
• Tại sao lỗi biểu diễn dấu phẩy động lại phổ biến
• Cách so sánh chính xác các giá trị dấu phẩy động trong Python
• Cách thể hiện số chính xác bằng cách sử dụng các loại

  >>> 0.2 + 0.2 + 0.2 == 0.6
  False
  
  >>> 1.3 + 2.0 == 3.3
  False
  
  >>> 1.2 + 2.4 + 3.6 == 7.2
  False

  12 và

  >>> 0.2 + 0.2 + 0.2 == 0.6
  False
  
  >>> 1.3 + 2.0 == 3.3
  False
  
  >>> 1.2 + 2.4 + 3.6 == 7.2
  False

  11 của Python

Nếu bạn đã học được điều gì đó mới, thì có thể còn nhiều điều bạn chưa biết về các con số trong Python. Ví dụ, bạn có biết loại

>>> 0.2 + 0.2 + 0.2 == 0.6
False

>>> 1.3 + 2.0 == 3.3
False

>>> 1.2 + 2.4 + 3.6 == 7.2
False

26 không phải là loại số nguyên duy nhất trong Python không?

3 điều có thể bạn chưa biết về số trong Python

Nếu bạn đã viết bất cứ thứ gì bằng Python, có lẽ bạn đã sử dụng một số trong một trong các chương trình của mình. Nhưng có nhiều con số hơn là giá trị thô của chúng

Cách hoạt động làm tròn của float

có thể nổi