Cách tốt nhất để so sánh số float cho gần như bằng nhau trong Python là gì?

Người ta biết rằng so sánh phao cho sự bình đẳng là một chút khó khăn do các vấn đề làm tròn và chính xác.

Ví dụ: https://randomascii.wordpress.com/2012/02/25/compared-floating-point-numbers-2012-edition/

Cách được đề xuất để đối phó với điều này trong Python là gì?

Chắc chắn có một chức năng thư viện tiêu chuẩn cho điều này ở đâu đó?

Python 3.5 thêm math.isclosevà các cmath.isclosechức năng như được mô tả trong PEP 485 .

Nếu bạn đang sử dụng phiên bản Python trước đó, chức năng tương đương sẽ được cung cấp trong tài liệu .

def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
    return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

rel_tollà một dung sai tương đối, nó được nhân với độ lớn hơn của hai đối số; khi các giá trị trở nên lớn hơn, thì sự khác biệt được phép giữa chúng trong khi vẫn xem xét chúng bằng nhau.

abs_tollà một dung sai tuyệt đối được áp dụng nguyên trạng trong mọi trường hợp. Nếu chênh lệch nhỏ hơn một trong hai dung sai đó, các giá trị được coi là bằng nhau.

Là một cái gì đó đơn giản như sau không đủ tốt?

return abs(f1 - f2) <= allowed_error

Tôi đồng ý rằng câu trả lời của Gareth có lẽ thích hợp nhất là một chức năng / giải pháp nhẹ.

Nhưng tôi nghĩ sẽ hữu ích khi lưu ý rằng nếu bạn đang sử dụng NumPy hoặc đang xem xét nó, có một chức năng đóng gói cho việc này.

numpy.isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)

Mặc dù có một chút từ chối: cài đặt NumPy có thể là một trải nghiệm không hề nhỏ tùy thuộc vào nền tảng của bạn.

Sử dụng decimalmô-đun của Python , cung cấp Decimallớp.

Từ các ý kiến:

Điều đáng chú ý là nếu bạn đang làm công việc nặng về toán học và bạn hoàn toàn không cần độ chính xác từ số thập phân, thì điều này thực sự có thể làm hỏng mọi thứ. Phao là cách, cách nhanh hơn để đối phó, nhưng không chính xác. Số thập phân cực kỳ chính xác nhưng chậm.

Tôi không biết bất cứ điều gì trong thư viện chuẩn Python (hoặc ở nơi khác) thực hiện AlmostEqual2sComplementchức năng của Dawson . Nếu đó là loại hành vi bạn muốn, bạn sẽ phải tự thực hiện. (Trong trường hợp đó, thay vì sử dụng các cách hack bitwise thông minh của Dawson, có lẽ bạn nên sử dụng các thử nghiệm thông thường hơn về hình thức if abs(a-b) <= eps1*(abs(a)+abs(b)) + eps2hoặc tương tự. Để có được hành vi giống Dawson, bạn có thể nói điều gì đó giống như if abs(a-b) <= eps*max(EPS,abs(a),abs(b))đối với một số lỗi nhỏ EPS; giống như Dawson, nhưng nó giống nhau về tinh thần.

Sự khôn ngoan phổ biến rằng các số dấu phẩy động không thể so sánh được cho đẳng thức là không chính xác. Số dấu phẩy động không khác với số nguyên: Nếu bạn đánh giá "a == b", bạn sẽ nhận được đúng nếu chúng là số giống nhau và sai khác (với cách hiểu rằng hai NaN tất nhiên không phải là số giống nhau).

Vấn đề thực tế là đây: Nếu tôi đã thực hiện một số tính toán và không chắc hai số tôi phải so sánh là chính xác, thì sao? Vấn đề này tương tự đối với dấu phẩy động giống như đối với số nguyên. Nếu bạn đánh giá biểu thức số nguyên "7/3 * 3", nó sẽ không so sánh bằng "7 * 3/3".

Vì vậy, giả sử chúng tôi hỏi "Làm thế nào để tôi so sánh các số nguyên cho bình đẳng?" trong tình huống như vậy Không có câu trả lời duy nhất; những gì bạn nên làm phụ thuộc vào tình huống cụ thể, đáng chú ý là loại lỗi nào bạn có và những gì bạn muốn đạt được.

Dưới đây là một số lựa chọn có thể.

Nếu bạn muốn có kết quả "đúng" nếu các số chính xác về mặt toán học sẽ bằng nhau, thì bạn có thể thử sử dụng các thuộc tính của các phép tính bạn thực hiện để chứng minh rằng bạn có cùng một lỗi trong hai số. Nếu điều đó là khả thi và bạn so sánh hai số kết quả từ các biểu thức sẽ cho các số bằng nhau nếu được tính toán chính xác, thì bạn sẽ nhận được "đúng" từ so sánh. Một cách tiếp cận khác là bạn có thể phân tích các thuộc tính của các phép tính và chứng minh rằng lỗi không bao giờ vượt quá một số tiền nhất định, có thể là một số tiền tuyệt đối hoặc một số tiền liên quan đến một trong các đầu vào hoặc một trong các đầu ra. Trong trường hợp đó, bạn có thể hỏi liệu hai số được tính có khác nhau nhiều nhất không và trả về "true" nếu chúng nằm trong khoảng. Nếu bạn không thể chứng minh một lỗi bị ràng buộc, bạn có thể đoán và hy vọng điều tốt nhất. Một cách đoán là đánh giá nhiều mẫu ngẫu nhiên và xem loại phân phối bạn nhận được trong kết quả.

Tất nhiên, vì chúng tôi chỉ đặt yêu cầu là bạn phải "đúng" nếu kết quả chính xác về mặt toán học bằng nhau, chúng tôi bỏ ngỏ khả năng bạn nhận được "đúng" ngay cả khi chúng không bằng nhau. (Trên thực tế, chúng ta có thể đáp ứng yêu cầu bằng cách luôn trả về "true". Điều này làm cho phép tính đơn giản nhưng thường không mong muốn, vì vậy tôi sẽ thảo luận về việc cải thiện tình huống bên dưới.)

Nếu bạn muốn nhận được kết quả "sai" nếu các số chính xác về mặt toán học sẽ không bằng nhau, bạn cần chứng minh rằng đánh giá của bạn về các số mang lại các số khác nhau nếu các số chính xác về mặt toán học sẽ không bằng nhau. Điều này có thể là không thể cho các mục đích thực tế trong nhiều tình huống phổ biến. Vì vậy, hãy để chúng tôi xem xét một sự thay thế.

Một yêu cầu hữu ích có thể là chúng ta nhận được kết quả "sai" nếu các con số chính xác về mặt toán học khác nhau nhiều hơn một số tiền nhất định. Ví dụ, có lẽ chúng ta sẽ tính toán nơi một quả bóng ném trong trò chơi máy tính đi qua, và chúng ta muốn biết liệu nó có đánh một con dơi không. Trong trường hợp này, chúng tôi chắc chắn muốn nhận được "đúng" nếu quả bóng đập vào người dơi và chúng tôi muốn nhận được "sai" nếu quả bóng cách xa con dơi và chúng tôi có thể chấp nhận câu trả lời "không đúng" nếu quả bóng rơi vào một mô phỏng chính xác về mặt toán học đã bỏ lỡ con dơi nhưng chỉ trong một milimet khi đánh con dơi. Trong trường hợp đó, chúng tôi cần chứng minh (hoặc đoán / ước tính) rằng tính toán của chúng tôi về vị trí của quả bóng và vị trí của người dơi có lỗi kết hợp tối đa là một milimet (cho tất cả các vị trí quan tâm). Điều này sẽ cho phép chúng tôi luôn trở về "

Vì vậy, cách bạn quyết định trả lại những gì khi so sánh các số có dấu phẩy động phụ thuộc rất nhiều vào tình huống cụ thể của bạn.

Đối với cách bạn đi về việc chứng minh giới hạn lỗi cho các tính toán, đó có thể là một chủ đề phức tạp. Bất kỳ triển khai điểm nổi nào sử dụng tiêu chuẩn IEEE 754 ở chế độ từ tròn đến gần nhất đều trả về số dấu phẩy động gần nhất với kết quả chính xác cho bất kỳ thao tác cơ bản nào (đáng chú ý là nhân, chia, cộng, trừ, căn bậc hai). (Trong trường hợp hòa, làm tròn nên bit thấp là chẵn.) (Đặc biệt cẩn thận về căn bậc hai và phép chia; việc triển khai ngôn ngữ của bạn có thể sử dụng các phương thức không phù hợp với IEEE 754 cho những điều đó.) Vì yêu cầu này, chúng tôi biết lỗi trong một kết quả duy nhất nhiều nhất bằng 1/2 giá trị của bit có trọng số thấp nhất. (Nếu nhiều hơn, số làm tròn sẽ chuyển sang một số khác trong phạm vi 1/2 giá trị.)

Tiếp tục từ đó trở nên phức tạp hơn nhiều; bước tiếp theo là thực hiện một thao tác trong đó một trong các đầu vào đã có một số lỗi. Đối với các biểu thức đơn giản, các lỗi này có thể được theo dõi thông qua các tính toán để đạt đến một ràng buộc về lỗi cuối cùng. Trong thực tế, điều này chỉ được thực hiện trong một vài tình huống, chẳng hạn như làm việc trên một thư viện toán học chất lượng cao. Và, tất nhiên, bạn cần kiểm soát chính xác đối với chính xác các hoạt động được thực hiện. Các ngôn ngữ cấp cao thường cung cấp cho trình biên dịch rất nhiều sự chậm chạp, do đó bạn có thể không biết các thao tác theo thứ tự nào được thực hiện.

Có nhiều hơn nữa có thể (và) được viết về chủ đề này, nhưng tôi phải dừng lại ở đó. Tóm lại, câu trả lời là: Không có thói quen thư viện cho việc so sánh này bởi vì không có giải pháp duy nhất nào phù hợp với hầu hết các nhu cầu đáng để đưa vào thói quen thư viện. (Nếu so sánh với một khoảng thời gian lỗi tương đối hoặc tuyệt đối đủ cho bạn, bạn có thể làm điều đó một cách đơn giản mà không cần một thói quen thư viện.)

Nếu bạn muốn sử dụng nó trong bối cảnh thử nghiệm / TDD, tôi muốn nói rằng đây là một cách tiêu chuẩn:

from nose.tools import assert_almost_equals

assert_almost_equals(x, y, places=7) #default is 7

math.isclose () đã được thêm vào Python 3.5 cho điều đó ( mã nguồn ). Đây là một cổng của nó cho Python 2. Điểm khác biệt của Mark Ransom là nó có thể xử lý "inf" và "-inf" đúng cách.

def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
    '''
    Python 2 implementation of Python 3.5 math.isclose()
    https://hg.python.org/cpython/file/tip/Modules/mathmodule.c#l1993
    '''
    # sanity check on the inputs
    if rel_tol < 0 or abs_tol < 0:
        raise ValueError("tolerances must be non-negative")

    # short circuit exact equality -- needed to catch two infinities of
    # the same sign. And perhaps speeds things up a bit sometimes.
    if a == b:
        return True

    # This catches the case of two infinities of opposite sign, or
    # one infinity and one finite number. Two infinities of opposite
    # sign would otherwise have an infinite relative tolerance.
    # Two infinities of the same sign are caught by the equality check
    # above.
    if math.isinf(a) or math.isinf(b):
        return False

    # now do the regular computation
    # this is essentially the "weak" test from the Boost library
    diff = math.fabs(b - a)
    result = (((diff <= math.fabs(rel_tol * b)) or
               (diff <= math.fabs(rel_tol * a))) or
              (diff <= abs_tol))
    return result

Tôi thấy so sánh sau đây hữu ích:

str(f1) == str(f2)

Đối với một số trường hợp bạn có thể ảnh hưởng đến biểu diễn số nguồn, bạn có thể biểu diễn chúng dưới dạng phân số thay vì số float, sử dụng tử số và mẫu số nguyên. Bằng cách đó bạn có thể có sự so sánh chính xác.

Xem Phân số từ mô-đun phân số để biết chi tiết.

Tôi thích đề xuất của @Sesquipedal nhưng có sửa đổi (trường hợp sử dụng đặc biệt khi cả hai giá trị đều trả về Sai). Trong trường hợp của tôi, tôi đã dùng Python 2.7 và chỉ sử dụng một hàm đơn giản:

if f1 ==0 and f2 == 0:
    return True
else:
    return abs(f1-f2) < tol*max(abs(f1),abs(f2))

Hữu ích cho trường hợp bạn muốn đảm bảo 2 số giống nhau 'chính xác', không cần chỉ định dung sai:

• Tìm độ chính xác tối thiểu của 2 số

• Làm tròn cả hai đến độ chính xác tối thiểu và so sánh

def isclose(a,b):                                       
    astr=str(a)                                         
    aprec=len(astr.split('.')[1]) if '.' in astr else 0 
    bstr=str(b)                                         
    bprec=len(bstr.split('.')[1]) if '.' in bstr else 0 
    prec=min(aprec,bprec)                                      
    return round(a,prec)==round(b,prec)                               

Như đã viết, chỉ hoạt động đối với các số không có 'e' trong biểu diễn chuỗi của chúng (có nghĩa là 0.9999999999995e-4 <số <= 0.9999999999995e11)

Thí dụ:

>>> isclose(10.0,10.049)
True
>>> isclose(10.0,10.05)
False

Để so sánh với một số thập phân nhất định mà không có atol/rtol:

def almost_equal(a, b, decimal=6):
    return '{0:.{1}f}'.format(a, decimal) == '{0:.{1}f}'.format(b, decimal)

print(almost_equal(0.0, 0.0001, decimal=5)) # False
print(almost_equal(0.0, 0.0001, decimal=4)) # True 

Đây có thể là một chút hack xấu xí, nhưng nó hoạt động khá tốt khi bạn không cần nhiều hơn độ chính xác float mặc định (khoảng 11 số thập phân).

Hàm round_to sử dụng phương thức định dạng từ lớp str dựng sẵn để làm tròn số float thành một chuỗi đại diện cho số float với số thập phân cần thiết, sau đó áp dụng eval cho chuỗi float được làm tròn để lấy lại đến kiểu số float.

Hàm is_close chỉ áp dụng một điều kiện đơn giản cho float nổi lên.

def round_to(float_num, prec):
    return eval("'{:." + str(int(prec)) + "f}'.format(" + str(float_num) + ")")

def is_close(float_a, float_b, prec):
    if round_to(float_a, prec) == round_to(float_b, prec):
        return True
    return False

>>>a = 10.0
10.0
>>>b = 10.0001
10.0001
>>>print is_close(a, b, prec=3)
True
>>>print is_close(a, b, prec=4)
False

Cập nhật:

Theo đề xuất của @stepehjfox, một cách sạch hơn để xây dựng hàm rount_to để tránh "eval" đang sử dụng định dạng lồng nhau :

def round_to(float_num, prec):
    return '{:.{precision}f}'.format(float_num, precision=prec)

Theo cùng một ý tưởng, mã có thể đơn giản hơn nữa bằng cách sử dụng chuỗi f mới tuyệt vời (Python 3.6+):

def round_to(float_num, prec):
    return f'{float_num:.{prec}f}'

Vì vậy, chúng ta thậm chí có thể gói tất cả trong một chức năng 'is_c Đóng' đơn giản và gọn gàng :

def is_close(a, b, prec):
    return f'{a:.{prec}f}' == f'{b:.{prec}f}'

Về lỗi tuyệt đối, bạn chỉ cần kiểm tra

if abs(a - b) <= error:
    print("Almost equal")

Một số thông tin về lý do tại sao float hành động kỳ lạ trong Python https://youtu.be/v4HhvoNLILk?t=1129

Bạn cũng có thể sử dụng math.isclose cho các lỗi tương đối