Approximate comparisons (pytest.approx) - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is pytest.approx used for in testing?

pytest.approx is used to compare floating-point numbers approximately, allowing small differences due to rounding errors.

beginner

How do you write an assertion to check if result is approximately equal to 3.14 using pytest.approx?

Use assert result == pytest.approx(3.14) to allow a small tolerance in the comparison.

intermediate

What are the two main ways to control tolerance in pytest.approx?

You can control tolerance by setting rel (relative tolerance) and abs (absolute tolerance) parameters.

beginner

Why is approximate comparison important when testing floating-point numbers?

Because floating-point arithmetic can introduce tiny rounding errors, exact equality checks often fail. Approximate comparison avoids false test failures.

intermediate

Can pytest.approx be used to compare lists or arrays of numbers?

Yes, pytest.approx supports comparing lists or arrays element-wise approximately.

What does pytest.approx(1.0, rel=1e-3) mean?

A Accept values within 1% relative difference of 1.0

B Accept values within 0.001 absolute difference of 1.0

C Accept values within 0.1% relative difference of 1.0

D Accept values exactly equal to 1.0

The rel=1e-3 means relative tolerance of 0.001, or 0.1% difference allowed.

Which of these is a correct way to assert approximate equality in pytest?

A assert approx(x) == y

B assert x == pytest.approx(y)

C assert x.approx(y)

D assert x.equals(y)

The correct syntax is assert x == pytest.approx(y).

If you want to allow a fixed small difference regardless of value size, which parameter do you use?

A abs

B rel

C tol

D delta

abs sets absolute tolerance, a fixed allowed difference.

What happens if you compare two floats with assert a == b and they differ by a tiny rounding error?

A Test raises an exception

B Test passes

C Test is skipped

D Test fails

Exact equality fails if floats differ even slightly, so test fails.

Can pytest.approx be used to compare nested lists of floats?

A No, only single floats

B Only flat lists, not nested

C Yes, it compares element-wise recursively

D Only numpy arrays

pytest.approx supports nested lists and compares elements recursively.

Explain why approximate comparisons are needed when testing floating-point numbers.

Think about how computers store decimal numbers.

Describe how to use pytest.approx to check if a value is close to 10 with a relative tolerance of 0.01.

Use the rel parameter for relative tolerance.

Practice

1. What is the main purpose of using pytest.approx in tests?

easy

A. To compare floating-point numbers allowing small differences

B. To check if two strings are exactly the same

C. To test if a function raises an exception

D. To verify if a list contains a specific element

Solution

1. Step 1: Understand floating-point comparison issues

   Floating-point numbers can have tiny differences due to rounding, so exact equality often fails.

2. Step 2: Role of pytest.approx

   pytest.approx allows tests to pass if numbers are close within a tolerance, avoiding false failures.

3. Final Answer:

   To compare floating-point numbers allowing small differences -> Option A

4. Quick Check:

   Approximate comparison = floating-point tolerance [OK]

Hint: Use approx for floats, not exact matches [OK]

Common Mistakes:

• Using == for floats causing flaky tests
• Confusing approx with exception testing
• Using approx for string comparisons

2. Which of the following is the correct syntax to assert that result is approximately equal to 3.14 using pytest.approx?

easy

A. assert result == pytest.approx[3.14]

B. assert result == approx(3.14)

C. assert result = pytest.approx(3.14)

D. assert result == pytest.approx(3.14)

Solution

1. Step 1: Identify correct usage of pytest.approx

   The correct syntax uses the function call form: pytest.approx(value).

2. Step 2: Check assertion syntax

   Assertions use '==' to compare, '=' is assignment and brackets [] are invalid here.

3. Final Answer:

   assert result == pytest.approx(3.14) -> Option D

4. Quick Check:

   Use '==' and parentheses with pytest.approx [OK]

Hint: Use '==' and parentheses with pytest.approx [OK]

Common Mistakes:

• Using '=' instead of '==' in assert
• Calling approx without pytest prefix if not imported
• Using square brackets instead of parentheses

3. What will be the result of this test code?

def test_value():
    value = 0.1 + 0.2
    assert value == pytest.approx(0.3)

medium

A. Test passes because 0.1 + 0.2 is exactly 0.3

B. Test fails due to floating-point precision error

C. Test passes because pytest.approx allows small differences

D. SyntaxError because pytest.approx is used incorrectly

Solution

1. Step 1: Understand floating-point addition

   0.1 + 0.2 is not exactly 0.3 due to floating-point precision limits.

2. Step 2: Effect of pytest.approx in assertion

   pytest.approx allows a small tolerance, so the assertion passes despite tiny difference.

3. Final Answer:

   Test passes because pytest.approx allows small differences -> Option C

4. Quick Check:

   Floating-point sum ≈ 0.3 passes with approx [OK]

Hint: Use approx to handle float rounding errors [OK]

Common Mistakes:

• Assuming 0.1 + 0.2 equals exactly 0.3
• Expecting test to fail without approx
• Thinking pytest.approx causes syntax errors

4. Identify the error in this test code snippet:

def test_approx():
    result = 1.0001
    assert result == pytest.approx(1.0, rel=0.00001)

medium

A. The relative tolerance is too small, causing test to fail

B. pytest.approx does not accept rel parameter

C. The assertion syntax is incorrect

D. The variable result should be an integer

Solution

1. Step 1: Check relative tolerance meaning

   rel=0.00001 means allowed difference is 0.00001 * 1.0 = 0.00001.

2. Step 2: Compare actual difference with tolerance

   Difference is 0.0001, which is greater than 0.00001, so assertion fails.

3. Final Answer:

   The relative tolerance is too small, causing test to fail -> Option A

4. Quick Check:

   Difference > rel tolerance causes failure [OK]

Hint: Check if difference fits within rel tolerance [OK]

Common Mistakes:

• Assuming rel parameter is invalid
• Ignoring difference size vs tolerance
• Confusing syntax error with logic error

5. You want to test that a function returns a value close to 100, but it may vary by up to 0.5 units. Which is the best way to write this assertion using pytest.approx?

hard

A. assert result == pytest.approx(100, rel=0.5)

B. assert result == pytest.approx(100, abs=0.5)

C. assert result == pytest.approx(100, abs=0.05)

D. assert result == pytest.approx(100, rel=0.005)

Solution

1. Step 1: Understand absolute vs relative tolerance

   Absolute tolerance (abs) allows fixed difference; relative (rel) allows percentage difference.

2. Step 2: Match tolerance to requirement

   Variation up to 0.5 units means absolute tolerance of 0.5 is correct.

3. Final Answer:

   assert result == pytest.approx(100, abs=0.5) -> Option B

4. Quick Check:

   Use abs=0.5 for fixed unit tolerance [OK]

Hint: Use abs for fixed tolerance, rel for percentage [OK]

Common Mistakes:

• Using rel when fixed tolerance needed
• Setting abs too small to cover variation
• Confusing abs and rel parameters