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.



Become a Patron!

Follow us on Facebook and Twitter for latest update.

It will be nice if you may share this link in any developer community or anywhere else, from where other developers may find this content. Thanks.

https://w3resource.com/python/certificate/operators-and-data-types-accuracy-of-floating-point-numbers.php