Я пытаюсь утверждать, что два словаря почти равны, но у меня это не получается.
Вот пример:
>>> import nose.tools as nt
>>> nt.assert_dict_equal({'a' : 12.4}, {'a' : 5.6 + 6.8})
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/usr/lib/python2.7/unittest/case.py", line 838, in assertDictEqual
self.fail(self._formatMessage(msg, standardMsg))
File "/usr/lib/python2.7/unittest/case.py", line 413, in fail
raise self.failureException(msg)
AssertionError: {'a': 12.4} != {'a': 12.399999999999999}
- {'a': 12.4}
+ {'a': 12.399999999999999}
Я хотел бы, чтобы это прошло, вот так:
>>> nt.assert_almost_equal(12.4, 5.6 + 6.8)
Я надеюсь, что я пропустил что-то простое, например, nt.assert_almost_dict_equal, или, может быть, есть параметр, который я мог бы передать nt.assert_dict_equal, который указывает, насколько близко должны быть числа с плавающей запятой, но я ничего не могу найти.
Конечно, я мог бы просто перебрать словари и использовать nt.assert_almost_equal для сравнения значений по отдельности; однако в моем случае словарь сложнее, поэтому я надеялся этого избежать.
Как лучше всего утверждать, что два словаря почти равны?
Я думаю, вам нужно будет повторить и сравнить значения самостоятельно. assert_almost_equal предоставляется только для числовых типов, разница которых может быть вычислена напрямую. BrenBarn 08.05.2014
Если вы обнаружите, что вам нужно свернуть свой собственный, проверьте assertDeepAlmostEqual здесь: github.com/larsbutler/oq-engine/blob/master/tests/utils/ dano 08.05.2014
import unittest
import numpy
def assertDeepAlmostEqual(test_case, expected, actual, *args, **kwargs):
"""
Assert that two complex structures have almost equal contents.
Compares lists, dicts and tuples recursively. Checks numeric values
using test_case's :py:meth:`unittest.TestCase.assertAlmostEqual` and
checks all other values with :py:meth:`unittest.TestCase.assertEqual`.
Accepts additional positional and keyword arguments and pass those
intact to assertAlmostEqual() (that's how you specify comparison
precision).
:param test_case: TestCase object on which we can call all of the basic
'assert' methods.
:type test_case: :py:class:`unittest.TestCase` object
"""
is_root = not '__trace' in kwargs
trace = kwargs.pop('__trace', 'ROOT')
try:
if isinstance(expected, (int, float, long, complex)):
test_case.assertAlmostEqual(expected, actual, *args, **kwargs)
elif isinstance(expected, (list, tuple, numpy.ndarray)):
test_case.assertEqual(len(expected), len(actual))
for index in xrange(len(expected)):
v1, v2 = expected[index], actual[index]
assertDeepAlmostEqual(test_case, v1, v2,
__trace=repr(index), *args, **kwargs)
elif isinstance(expected, dict):
test_case.assertEqual(set(expected), set(actual))
for key in expected:
assertDeepAlmostEqual(test_case, expected[key], actual[key],
__trace=repr(key), *args, **kwargs)
else:
test_case.assertEqual(expected, actual)
except AssertionError as exc:
exc.__dict__.setdefault('traces', []).append(trace)
if is_root:
trace = ' -> '.join(reversed(exc.traces))
exc = AssertionError("%s\nTRACE: %s" % (exc.message, trace))
raise exc
# My part, using the function
class TestMyClass(unittest.TestCase):
def test_dicts(self):
assertDeepAlmostEqual(self, {'a' : 12.4}, {'a' : 5.6 + 6.8})
def test_dicts_2(self):
dict_1 = {'a' : {'b' : [12.4, 0.3]}}
dict_2 = {'a' : {'b' : [5.6 + 6.8, 0.1 + 0.2]}}
assertDeepAlmostEqual(self, dict_1, dict_2)
def main():
unittest.main()
if __name__ == "__main__":
main()
Результат:
Ran 2 tests in 0.000s
OK
Ответ 2 · рейтинг 3 · Bill
Я понимаю, что вы не стали бы импортировать pandas только для этого, но если вы используете pandas, вы можете преобразовать dicts в серию и использовать assert_series_equal из pandas.testing, который по умолчанию имеет check_exact=False.
>>> import pandas as pd
>>> from pandas.testing import assert_series_equal
>>> a = pd.Series({'a' : 12.4})
>>> b = pd.Series({'a': 12.399999999999999})
>>> assert_series_equal(a, b)
Ответ 3 · Viragos
Я не мог запустить функцию Akavall, поэтому сделал свою собственную. Это слишком просто, но работает для моих целей. Код для проверки работы этой функции, написанный с использованием pytest
from numbers import Number
from math import isclose
def dictsAlmostEqual(dict1, dict2, rel_tol=1e-8):
"""
If dictionary value is a number, then check that the numbers are almost equal, otherwise check if values are exactly equal
Note: does not currently try converting strings to digits and comparing them. Does not care about ordering of keys in dictionaries
Just returns true or false
"""
if len(dict1) != len(dict2):
return False
# Loop through each item in the first dict and compare it to the second dict
for key, item in dict1.items():
# If it is a nested dictionary, need to call the function again
if isinstance(item, dict):
# If the nested dictionaries are not almost equal, return False
if not dictsAlmostEqual(dict1[key], dict2[key], rel_tol=rel_tol):
return False
# If it's not a dictionary, then continue comparing
# Put in else statement or else the nested dictionary will get compared twice and
# On the second time will check for exactly equal and will fail
else:
# If the value is a number, check if they are approximately equal
if isinstance(item, Number):
# if not abs(dict1[key] - dict2[key]) <= rel_tol:
# https://stackoverflow.com/questions/5595425/what-is-the-best-way-to-compare-floats-for-almost-equality-in-python
if not isclose(dict1[key], dict2[key], rel_tol=rel_tol):
return False
else:
if not (dict1[key] == dict2[key]):
return False
return True
Проверить вывод функции с помощью pytest
import pytest
import dictsAlmostEqual
def test_dictsAlmostEqual():
a = {}
b = {}
assert dictsAlmostEqual(a, b)
a = {"1": "a"}
b = {}
assert not dictsAlmostEqual(a, b)
a = {"1": "a"}
b = {"1": "a"}
assert dictsAlmostEqual(a, b)
a = {"1": "a"}
b = {"1": "b"}
assert not dictsAlmostEqual(a, b)
a = {"1": "1.23"}
b = {"1": "1.23"}
assert dictsAlmostEqual(a, b)
a = {"1": "1.234"}
b = {"1": "1.23"}
assert not dictsAlmostEqual(a, b)
a = {"1": 1.000000000000001, "2": "a"}
b = {"1": 1.000000000000002, "2": "a"}
assert not dictsAlmostEqual(a, b, rel_tol=1e-20)
assert dictsAlmostEqual(a, b, rel_tol=1e-8)
assert dictsAlmostEqual(a, b)
# Nested dicts
a = {"1": {"2": 1.000000000000001}}
b = {"1": {"2": 1.000000000000002}}
assert not dictsAlmostEqual(a, b, rel_tol=1e-20)
assert dictsAlmostEqual(a, b, rel_tol=1e-8)
assert dictsAlmostEqual(a, b)
a = {"1": {"2": 1.000000000000001, "3": "a"}, "2": "1.23"}
b = {"1": {"2": 1.000000000000002, "3": "a"}, "2": "1.23"}
assert not dictsAlmostEqual(a, b, rel_tol=1e-20)
assert dictsAlmostEqual(a, b, rel_tol=1e-8)
assert dictsAlmostEqual(a, b)
Ответ 4 · Arnaud Fouchet
Pytest "приблизительно" делает свою работу
In [10]: {'a': 2.000001} == pytest.approx({'a': 2})
Out[10]: True
