如何在Python中存储带后缀零且满足指定精度要求的十进制数？

Great question—this is a common pitfall with floating-point arithmetic in Python, and the issue you're seeing boils down to two key points: how binary floats work under the hood, and a mistake in how you're formatting Decimal/Fraction outputs. Let's break this down step by step and fix the problem.

Why the Weird Tail Digits in Float? #

First, let's get the basics out of the way: Python's native float type is a binary floating-point number. Binary floats can't represent all decimal fractions exactly—numbers like 245.353 get stored as an approximation, which is why you see those non-zero digits starting at the 14th decimal place when you print with high precision. This is the core limitation the Python docs talk about.

The Problem with Your Decimal/Fraction Tests #

Your tests with Decimal and Fraction didn't work as expected, but that's not a flaw in the libraries—it's how you were formatting the output. When you used print('%.50f'%d) with a Decimal object, Python converts the Decimal to a float to apply the %f format specifier. Since float can't represent 245.353 exactly, you end up with the same approximation issue all over again.

For Fraction, the library stores values as exact fractions—245.353 and 245.353000... are numerically identical, so Fraction simplifies them to 245353/1000 and doesn't retain the trailing zeros (they don't change the value, after all).

Correct Ways to Store & Work with Precise Decimal Numbers #

If you need to accurately store a decimal number with trailing zeros (preserving both the exact value and the decimal place representation), here's what you should do:

1. Use the decimal Library Correctly #

The decimal library is designed for exact decimal arithmetic, and it can retain trailing zeros if you initialize it with a string and format outputs properly.

from decimal import Decimal, getcontext

# Set a sufficient precision level for your calculations
getcontext().prec = 50

# Initialize with a string to preserve trailing zeros
d = Decimal('245.353000000000000000000000000000000000')

# Directly print the Decimal object to retain all specified digits
print(d)  # Output: 245.353000000000000000000000000000000000

# Use Decimal's native formatting to output fixed precision
print(d.to_eng_string())  # Outputs the exact stored value as a string

# Use string formatting that respects Decimal's type (avoid %f!)
print("{0:.50f}".format(d))

2. Avoid Conversion to float at All Costs #

Never use %f format specifiers with Decimal objects—this forces a conversion to float, which reintroduces the approximation error. Stick to Decimal's own methods or str.format() which handles Decimal natively.

3. For Exact Numeric Calculations (No Trailing Zero Need) #

If you don't need to preserve trailing zeros and just want exact arithmetic, Fraction works great—just remember it stores values as reduced fractions, so trailing zeros won't be retained:

from fractions import Fraction

g = Fraction('245.353')
print(g)  # Output: 245353/1000
# To get a precise decimal string, convert to Decimal first
print(Decimal(g))  # Output: 245.353

4. Precise Multiplication Without Error #

To replicate your manual multiplication results without precision loss, use Decimal for all operands and calculations:

from decimal import Decimal

num1 = Decimal('5.132435246464363423432432432342432324342')
num2 = Decimal('245.353000000000000000000000000000000000')
result = num1 * num2

print(result)
# Output will match your manual calculation's exact value

Summary #

• Native float is not suitable for storing exact decimal values with trailing zeros—use decimal.Decimal instead.
• When using Decimal, initialize with a string and avoid converting to float (especially when formatting outputs).
• Fraction is great for exact numeric calculations but doesn't retain trailing zeros (since they don't affect the value).

内容的提问来源于stack exchange，提问作者Pera