Of course! Formatting floats in Python is a common task, and Python offers several powerful ways to do it. The best method depends on your specific needs, like whether you're displaying data for a user, performing calculations, or writing to a file.

Here’s a comprehensive guide covering the most common methods, from modern to legacy.

Quick Guide: Which Method to Use?

Method 1: f-strings (Formatted String Literals) - Recommended

f-strings are the most popular and readable way to format strings in modern Python (3.6+). They are fast and intuitive.

Syntax

f"{variable:format_spec}"

The format_spec inside the curly braces controls how the float is displayed.

Common Format Specifications

• f - Fixed-point notation: Displays the number with a fixed number of decimal places.

  pi = 3.14159
  print(f"Pi is approximately {pi:.2f}")
  # Output: Pi is approximately 3.14

  • .2f means "format this as a float with 2 digits after the decimal point."

• e - Scientific notation: Useful for very large or very small numbers.

  large_num = 123456789.0
  print(f"Large number: {large_num:.2e}")
  # Output: Large number: 1.23e+08
  small_num = 0.00000012345
  print(f"Small number: {small_num:.2e}")
  # Output: Small number: 1.23e-07

• - Percentage format: Multiplies the number by 100 and adds a sign.

  ratio = 0.85
  print(f"Success rate: {ratio:.1%}")
  # Output: Success rate: 85.0%

• Padding and Alignment: You can specify a total width and align the number.

  
  （图片来源网络，侵删）

  num = 12.3
  # Right-aligned in a field of 10 characters
  print(f"Right: {num:>10.2f}")
  # Output: Right:      12.30
  # Left-aligned in a field of 10 characters
  print(f"Left:  {num:<10.2f}")
  # Output: Left:  12.30
  # Center-aligned in a field of 10 characters
  print(f"Center:{num:^10.2f}")
  # Output: Center:   12.30

• Adding a Thousands Separator: Use a comma as a separator for thousands.

  big_num = 9876543.21
  print(f"With commas: {big_num:,.2f}")
  # Output: With commas: 9,876,543.21

Method 2: The format() Function

This function is very similar to f-strings and works in all Python versions from 2.6 onwards. It's the "manual" way of doing what f-strings do automatically.

Syntax

"format string".format(variables)

The format spec uses the same syntax as f-strings, just placed inside the format() method.

pi = 3.14159
# Basic formatting
print("Pi is approximately {:.2f}".format(pi))
# Output: Pi is approximately 3.14
# Multiple variables
name = "Alice"
score = 95.875
print("User: {}, Score: {:.1f}".format(name, score))
# Output: User: Alice, Score: 95.9
# Using positional arguments
print("{0} has a score of {1:.2f}".format(name, score))
# Output: Alice has a score of 95.88
# Using keyword arguments
print("{n} has a score of {s:.2f}".format(n=name, s=score))
# Output: Alice has a score of 95.88

Method 3: round() - For Rounding Numbers (Not Just Formatting)

It's crucial to understand the difference between formatting (changing the string representation) and rounding (changing the actual numerical value).

round() performs actual mathematical rounding. The result is still a float, which will be displayed with its default precision unless you format it.

price = 19.995
# This ROUNDS the number to 2 decimal places
rounded_price = round(price, 2)
print(f"The rounded number is: {rounded_price}")
# Output: The rounded number is: 20.0
# If you just print it, it might show more digits due to float representation
print(f"The rounded number (without formatting): {rounded_price}")
# Output: The rounded number (without formatting): 20.0
# You still need formatting to control how it's DISPLAYED
print(f"The formatted rounded number: {rounded_price:.2f}")
# Output: The formatted rounded number: 20.00

Use round() when: You are performing calculations and need a numerically rounded result. Use formatting (f-string or format()) for display purposes.

Method 4: The decimal Module - For High Precision

Standard Python floats are binary floating-point numbers and can have small precision errors, which is a big problem in financial calculations. The decimal module provides a Decimal type that offers precise decimal representation.

This is the correct tool for financial data.

from decimal import Decimal, getcontext
# Set the precision for calculations
getcontext().prec = 6
# Create Decimal objects from strings (not floats, to avoid float errors)
price1 = Decimal('19.99')
price2 = Decimal('0.01')
total = price1 + price2
print(f"Total (as Decimal): {total}")
# Output: Total (as Decimal): 20.00
# Formatting a Decimal works just like a float
print(f"Formatted total: {total:.2f}")
# Output: Formatted total: 20.00
# Quantize is the proper way to round a Decimal
# This rounds to the nearest cent (2 decimal places)
rounded_total = total.quantize(Decimal('0.01'))
print(f"Quantized total: {rounded_total}")
# Output: Quantized total: 20.00

Method 5: Legacy %-formatting (Old Style)

This is the C-style method from Python 2. It's still supported in Python 3 for backward compatibility, but you should avoid it in new code. It's less readable and more error-prone.

pi = 3.14159
# %f for float, %.2f for 2 decimal places
print("Pi is approximately %.2f" % pi)
# Output: Pi is approximately 3.14
# Multiple values need to be in a tuple
name = "Bob"
score = 88.666
print("%s has a score of %.1f" % (name, score))
# Output: Bob has a score of 88.7

Summary and Best Practices

1. For Displaying Data to Users: Use f-strings. They are the most readable, modern, and efficient choice.

   print(f"The value is {my_float:.2f}")

2. For Actual Calculations (Rounding): Use the round() function if you need a rounded number for further math. Be aware of its limitations with floating-point arithmetic.

   my_float = 10.555
   rounded_value = round(my_float, 2) # rounded_value is 10.56

3. For Financial or Scientific Data: Use the decimal module to avoid floating-point precision errors. Format the Decimal object using f-strings for display.

   from decimal import Decimal
   price = Decimal('19.99')
   print(f"Price: ${price:.2f}")

4. For Legacy Code: You might encounter %-formatting. You can update it to f-strings or format() for better readability.