w3resource

PCEP-30-02 Exam Prep: Understanding Floating-Point Accuracy in Python

PCEP Certification Practice Test - Questions, Answers and Explanations

This comprehensive set of questions and explanations covers the fundamental topic of choosing operators and data types adequate to the problem, focusing on the accuracy of floating-point numbers. This diverse set of interactions enhances understanding and prepares for the PCEP-30-02 examination.

Question 1: What is the result of the following expression?

0.1 + 0.2 == 0.3
  1. True
  2. False
  3. None
  4. Error
▼

Answer: b) False

Explanation: Due to the inaccuracy of floating-point arithmetic, 0.1 + 0.2 does not exactly equal 0.3. Instead, it results in a value very close to 0.3 but not exactly equal.

Question 2: What is the result of the following code?

round(0.1 + 0.2, 1) == 0.3
  1. True
  2. False
  3. None
  4. Error
▼

Answer: a) True

Explanation: The round function helps mitigate floating-point inaccuracies. round(0.1 + 0.2, 1) rounds the sum to one decimal place, resulting in 0.3.

Question 3: What is the best way to compare two floating-point numbers for equality?

  1. Using the == operator directly
  2. Using the != operator
  3. Using a tolerance value
  4. Using the round function
▼

Answer: c) Using a tolerance value

Explanation: Due to floating-point inaccuracies, it's best to compare floating-point numbers within a small tolerance range rather than checking for exact equality.

Question 4: Which of the following statements about floating-point numbers are true? (Select all that apply)

  1. Floating-point numbers can represent every possible value exactly.
  2. Floating-point numbers are stored as binary fractions.
  3. Floating-point arithmetic can introduce rounding errors.
  4. The precision of floating-point numbers is infinite.
▼

Answer: b) Floating-point numbers are stored as binary fractions., c) Floating-point arithmetic can introduce rounding errors.

Explanation: Floating-point numbers are stored as binary fractions, and arithmetic operations on them can introduce rounding errors due to limited precision.

Question 5: Which of the following methods can be used to mitigate floating-point inaccuracies? (Select all that apply)

  1. Using integer arithmetic instead
  2. Rounding the result to a fixed number of decimal places
  3. Comparing numbers with a small tolerance value
  4. Using the == operator directly
▼

Answer:a) Using integer arithmetic instead, b) Rounding the result to a fixed number of decimal places, c) Comparing numbers with a small tolerance value

Explanation: Using integer arithmetic, rounding results, and comparing numbers with a small tolerance value are effective methods to mitigate floating-point inaccuracies.

Question 6: Place the following steps in the correct order to compare floating-point numbers using a tolerance value: Calculate the absolute difference, Define a tolerance value, Compare the difference with the tolerance.

  1. Calculate the absolute difference
  2. Define a tolerance value
  3. Compare the difference with the tolerance
▼

Answer:

  1. Define a tolerance value
  2. Calculate the absolute difference
  3. Compare the difference with the tolerance

Explanation: First, define a tolerance value. Then, calculate the absolute difference between the numbers. Finally, compare this difference with the tolerance value.

Question 7: Floating-point numbers can introduce ______ errors due to their limited precision.

▼

Answer: rounding

Explanation: Floating-point numbers can introduce rounding errors because they cannot represent every possible value exactly.

Question 8: Comparing floating-point numbers using the == operator is often ______ due to precision.

▼

Answer: inaccurate

Explanation: Due to precision issues, comparing floating-point numbers using the == operator is often inaccurate.

Question 9: Sort the following expressions by their accuracy in comparing floating-point numbers: Using a tolerance value, Using the == operator, Using integer arithmetic.

▼

Answer:

  1. Using integer arithmetic (most accurate)
  2. Using a tolerance value
  3. Using the == operator (least accurate)

Explanation: Integer arithmetic avoids floating-point inaccuracies, using a tolerance value is a practical method for floating-point comparison, and using the == operator is the least accurate due to precision issues.

Question 10: Fill in the missing code to compare a and b using a tolerance value of 1e-9.

a = 0.1 + 0.2
b = 0.3
tolerance = 1e-9
result = abs(a - b) ______ tolerance
▼

Answer: <

Explanation: The correct code is result = abs(a - b) < tolerance, which checks if the absolute difference between a and b is within the tolerance value.

Question 11: Fill in the missing code to round the result of 0.1 + 0.2 to one decimal place.

result = round(0.1 + 0.2, ______)
▼

Answer: 1

Explanation: The correct code is result = round(0.1 + 0.2, 1), which rounds the result to one decimal place.

Question 12: Insert the correct operator to evaluate if a and b are approximately equal with a tolerance of 1e-6.

a = 1.000001
b = 1.000002
tolerance = 1e-6
result = abs(a - b) ______ tolerance
▼

Answer: <

Explanation: The correct code is result = abs(a - b) < tolerance, which checks if the absolute difference between a and b is within the tolerance value.

Question 13: Insert the correct function to round x to two decimal places.

x = 3.14159
result = ______(x, 2)
▼

Answer: round

Explanation: The correct code is result = round(x, 2), which rounds x to two decimal places.

Question 14: What is the result of the following code?

format(0.1 + 0.2, '.2f') == '0.30'
  1. True
  2. False
  3. None
  4. Error
▼

Answer: a) True

Explanation: The format function formats the result to two decimal places, making it '0.30', which equals '0.30'.

Question 15: Which method is used to mitigate floating-point inaccuracies when comparing two numbers?

  1. Using != operator
  2. Using == operator
  3. Using round function
  4. Using a tolerance value
▼

Answer: d) Using a tolerance value

Explanation: Using a tolerance value is a common method to mitigate floating-point inaccuracies when comparing numbers.

Question 16: Which of the following methods help handle floating-point inaccuracies? (Select all that apply)

  1. Using integer arithmetic
  2. Rounding results
  3. Comparing with a tolerance value
  4. Ignoring precision issues
▼

Answer: a) Using integer arithmetic, b) Rounding results, c) Comparing with a tolerance value

Explanation: Using integer arithmetic, rounding results, and comparing with a tolerance value help handle floating-point inaccuracies.

Question 17: Which of the following statements are true about floating-point arithmetic? (Select all that apply)

  1. It can introduce rounding errors
  2. It has infinite precision
  3. It represents numbers as binary fractions
  4. It is always accurate
▼

Answer: a) It can introduce rounding errors, c) It represents numbers as binary fractions

Explanation: Floating-point arithmetic can introduce rounding errors and represents numbers as binary fractions.

Question 18: Place the following steps in the correct order to mitigate floating-point inaccuracies when adding 0.1 and 0.2: Round the result, Perform the addition, Compare the result with the expected value.

▼

Answer:

  1. Perform the addition
  2. Round the result
  3. Compare the result with the expected value

Explanation: First, perform the addition. Then, round the result. Finally, compare the result with the expected value.

Question 19: Floating-point numbers can represent fractions as ______ fractions.

▼

Answer: binary

Explanation: Floating-point numbers represent fractions as binary fractions.

Question 20: Floating-point arithmetic can introduce ______ errors due to precision limitations.

▼

Answer: rounding

Explanation: Floating-point arithmetic can introduce rounding errors due to precision limitations.

Question 21: Sort the following expressions by their accuracy in representing floating-point values: 0.1 + 0.2, round(0.1 + 0.2, 1), format(0.1 + 0.2, '.1f').

▼

Answer:

  1. 'format(0.1 + 0.2, '.1f')' (most accurate representation)
  2. 'round(0.1 + 0.2, 1)'
  3. '0.1 + 0.2' (least accurate due to floating-point inaccuracies)

Explanation: 'format' provides the most accurate representation by formatting the result to one decimal place. 'round' rounds the result to one decimal place, while the direct addition of '0.1 + 0.2' is less accurate due to floating-point inaccuracies.

Question 22: Fill in the missing code to print 0.1 + 0.2 rounded to two decimal places.

result = round(0.1 + 0.2, ______)
print(result)
▼

Answer: 2

Explanation: The correct code is result = round(0.1 + 0.2, 2), which rounds the result to two decimal places before printing.

Question 23: Fill in the missing code to compare two floating-point numbers a and b within a tolerance of 1e-5.

a = 0.1 + 0.2
b = 0.3
tolerance = 1e-5
if abs(a - b) ______ tolerance:
    print("Approximately equal")
else:
    print("Not equal")
▼

Answer: <

Explanation: The correct code is if abs(a - b) < tolerance, which checks if the absolute difference between a and b is within the tolerance.

Question 24: Insert the correct method to print 0.1 + 0.2 formatted to one decimal place.

result = 0.1 + 0.2
print(______)
▼

Answer: format(result, '.1f')

Explanation: The correct code is print(format(result, '.1f')), which formats the result to one decimal place before printing.

Question 25: Insert the correct function to round a floating-point number x to the nearest integer.

▼

Answer: round

Explanation: The correct code is rounded = round(x), which rounds the floating-point number x to the nearest integer.



Follow us on Facebook and Twitter for latest update.