Come fare assert almost equalcon py.test per i float senza ricorrere a qualcosa di simile:

assert x - 0.00001 <= y <= x + 0.00001

Più specificamente sarà utile conoscere una soluzione pulita per confrontare rapidamente coppie di float, senza decomprimerle:

assert (1.32, 2.4) == i_return_tuple_of_two_floats()

Ho notato che questa domanda è stata posta specificamente su py.test. py.test 3.0 include una approx()funzione (beh, davvero di classe) che è molto utile per questo scopo.

import pytest

assert 2.2 == pytest.approx(2.3)
# fails, default is ± 2.3e-06
assert 2.2 == pytest.approx(2.3, 0.1)
# passes

# also works the other way, in case you were worried:
assert pytest.approx(2.3, 0.1) == 2.2
# passes

La documentazione è qui: https://docs.pytest.org/en/latest/reference.html#pytest-approx

Dovrai specificare ciò che è "quasi" per te:

assert abs(x-y) < 0.0001

da applicare alle tuple (o qualsiasi sequenza):

def almost_equal(x,y,threshold=0.0001):
  return abs(x-y) < threshold

assert all(map(almost_equal, zip((1.32, 2.4), i_return_tuple_of_two_floats())

Se hai accesso a NumPy ha ottime funzioni per il confronto a virgola mobile che già fanno un confronto a coppie numpy.testing.

Quindi puoi fare qualcosa del tipo:

numpy.testing.assert_allclose(i_return_tuple_of_two_floats(), (1.32, 2.4))

Qualcosa di simile a

assert round(x-y, 5) == 0

Questo è ciò che fa unittest

Per la seconda parte

assert all(round(x-y, 5) == 0 for x,y in zip((1.32, 2.4), i_return_tuple_of_two_floats()))

Probabilmente meglio avvolgerlo in una funzione

def tuples_of_floats_are_almost_equal(X, Y):
    return all(round(x-y, 5) == 0 for x,y in zip(X, Y))

assert tuples_of_floats_are_almost_equal((1.32, 2.4), i_return_tuple_of_two_floats())

Queste risposte sono in circolazione da molto tempo, ma penso che il modo più semplice e anche più leggibile sia quello di utilizzare unittest per le sue molte affermazioni belle senza usarlo per la struttura dei test.

Ottieni affermazioni, ignora il resto di unittest.TestCase

(basato su questa risposta )

import unittest

assertions = unittest.TestCase('__init__')

Fai alcune affermazioni

x = 0.00000001
assertions.assertAlmostEqual(x, 0)  # pass
assertions.assertEqual(x, 0)  # fail
# AssertionError: 1e-08 != 0

Implementare il test di decompressione automatica delle domande originali

Usa * per decomprimere il valore restituito senza dover introdurre nuovi nomi.

i_return_tuple_of_two_floats = lambda: (1.32, 2.4)
assertions.assertAlmostEqual(*i_return_tuple_of_two_floats())  # fail
# AssertionError: 1.32 != 2.4 within 7 places

Se vuoi qualcosa che funzioni non solo con i float ma ad esempio i decimali puoi usare quelli di Python math.isclose:

    # - rel_tol=0.01` is 1% difference tolerance.
    assert math.isclose(actual_value, expected_value, rel_tol=0.01)

Documenti - https://docs.python.org/3/library/math.html#math.isclose

Userei nose.tools. Gioca bene con py.test runner e ha altri assertori altrettanto utili: assert_dict_equal (), assert_list_equal (), ecc.

from nose.tools import assert_almost_equals
assert_almost_equals(x, y, places=7) #default is 7