How to Convert String with Comma/Dot Separators to Float in Python

When dealing with numerical data represented as strings, especially from different regions or sources, you might encounter formats using commas (,) as thousands separators and dots (.) as decimal points (e.g., "1,234.56"), or vice versa (e.g., "1.234,56"). Python's standard float() function expects only a single optional dot as the decimal separator and no thousands separators.

This guide explains how to reliably convert these varied string formats into Python float objects using string manipulation and the locale module.

The Challenge: Non-Standard Number Formats

Python's built-in float() constructor works perfectly for strings like "1234.56" or "-78.9". However, it raises a ValueError if the string contains characters it doesn't recognize as part of a standard float representation, such as thousands separators.

string_us_style = "1,234.56"
string_eu_style = "1.234,56"

try:
    # ⛔️ ValueError: could not convert string to float: '1,234.56'
    val1 = float(string_us_style)
except ValueError as e:
    print(e)

try:
    # ⛔️ ValueError: could not convert string to float: '1.234,56'
    val2 = float(string_eu_style)
except ValueError as e:
    print(e)

We need methods to handle these common separators before conversion.

Method 1: Using String `replace()` (Recommended for Known Formats)

This is often the simplest and most direct approach if you know exactly which characters are used as thousands and decimal separators in your input strings.

Handling Comma Thousands Separator, Dot Decimal (`1,234.56`)

If the comma is the thousands separator and the dot is the decimal point (common in the US, UK), simply remove the commas before converting.

def string_to_float_us(num_str):
  """Converts US/UK-style number string (comma thousands, dot decimal) to float."""
  try:
    # Remove all commas
    cleaned_str = num_str.replace(',', '')
    # Convert the cleaned string to float
    return float(cleaned_str)
  except ValueError:
    print(f"Error: Could not convert '{num_str}' to float after cleaning.")
    return None # Or raise an error

# Example Usage
str_us = "1,234,567.89"
str_simple = "987.65"
str_invalid = "1,23a.45"

float_us = string_to_float_us(str_us)
print(f"'{str_us}' -> {float_us} (Type: {type(float_us)})")
# Output: '1,234,567.89' -> 1234567.89 (Type: <class 'float'>)

float_simple = string_to_float_us(str_simple)
print(f"'{str_simple}' -> {float_simple} (Type: {type(float_simple)})")
# Output: '987.65' -> 987.65 (Type: <class 'float'>)

float_invalid = string_to_float_us(str_invalid)
# Output: Error: Could not convert '1,23a.45' to float after cleaning.
print(f"'{str_invalid}' -> {float_invalid}")
# Output: '1,23a.45' -> None

Output:

'1,234,567.89' -> 1234567.89 (Type: <class 'float'>)
'987.65' -> 987.65 (Type: <class 'float'>)
Error: Could not convert '1,23a.45' to float after cleaning.
'1,23a.45' -> None

num_str.replace(',', ''): Creates a new string with all commas removed.
float(...): Converts the resulting comma-free string.

Handling Dot Thousands Separator, Comma Decimal (`1.234,56`)

If the dot is the thousands separator and the comma is the decimal point (common in many European countries), you need two replacements: first remove the dots, then replace the comma with a dot.

def string_to_float_eu(num_str):
  """Converts EU-style number string (dot thousands, comma decimal) to float."""
  try:
    # Remove dot thousand separators
    cleaned_dots = num_str.replace('.', '')
    # Replace comma decimal separator with a dot
    cleaned_comma = cleaned_dots.replace(',', '.')
    # Convert the standardized string to float
    return float(cleaned_comma)
  except ValueError:
    print(f"Error: Could not convert '{num_str}' to float after cleaning.")
    return None

# Example Usage
str_eu = "1.234.567,89"
str_simple_eu = "987,65"
str_mixed = "1,234.567,89" # Ambiguous/invalid mix

float_eu = string_to_float_eu(str_eu)
print(f"'{str_eu}' -> {float_eu} (Type: {type(float_eu)})")
# Output: '1.234.567,89' -> 1234567.89 (Type: <class 'float'>)

float_simple_eu = string_to_float_eu(str_simple_eu)
print(f"'{str_simple_eu}' -> {float_simple_eu} (Type: {type(float_simple_eu)})")
# Output: '987,65' -> 987.65 (Type: <class 'float'>)

float_mixed = string_to_float_eu(str_mixed)
print(f"'{str_mixed}' -> {float_mixed}")
# Output: Error: Could not convert '1,234.567,89' to float after cleaning.
# Output: '1,234.567,89' -> None

Output:

'1.234.567,89' -> 1234567.89 (Type: <class 'float'>)
'987,65' -> 987.65 (Type: <class 'float'>)
Error: Could not convert '1,234.567,89' to float after cleaning.
'1,234.567,89' -> None

The order of replace calls matters here. Remove the thousands separator first.

Method 2: Using the `locale` Module (For Locale-Awareness)

Python's locale module allows your program to consider regional settings, including number formatting. This is the "correct" way to handle international formats but involves managing locale settings.

Setting the Locale (`locale.setlocale`)

You must first tell the locale module which regional conventions to use.

import locale

# --- Example: Setting to US English ---
# The exact string ('en_US.UTF-8') may vary by OS and available locales.
# Common formats: 'language_COUNTRY.encoding'
try:
    locale.setlocale(locale.LC_ALL, 'en_US.UTF-8') # Or 'English_United States.1252' on Windows
    print(f"Locale set to: {locale.getlocale()}")
except locale.Error as e:
    print(f"Warning: Could not set locale 'en_US.UTF-8'. Using system default. Error: {e}")
    # Fallback to user's default system locale
    try:
        locale.setlocale(locale.LC_ALL, '') # Use system default
        print(f"Using system default locale: {locale.getlocale()}")
    except locale.Error as e_default:
         print(f"Error setting default locale: {e_default}")

# --- Example: Setting to German (often uses '.' thousands, ',' decimal) ---
try:
    locale.setlocale(locale.LC_ALL, 'de_DE.UTF-8') # Or 'German_Germany.1252' on Windows
    print(f"Locale set to: {locale.getlocale()}")
except locale.Error as e:
    print(f"Warning: Could not set locale 'de_DE.UTF-8'. Check if installed.")

# --- Using User's Default Locale (Often Simplest if Consistent) ---
# locale.setlocale(locale.LC_ALL, '') # Reset to user default if needed

Output:

Locale set to: ('en_US', 'UTF-8')
Locale set to: ('de_DE', 'UTF-8')

locale.LC_ALL: Sets the locale for all categories (numbers, currency, time, etc.).
'' (empty string): Tells Python to use the operating system's default locale setting. This is often the easiest if you expect input matching the user's system.
Specific strings ('en_US.UTF-8', 'de_DE.UTF-8'): Explicitly set conventions. These locale names are OS-dependent and might not be installed/available on all systems, leading to locale.Error. You might need error handling or ensure required locales are installed on the target system.

Converting with `locale.atof()`

Once a locale is set, locale.atof(string) converts a string to a float using the rules of the currently active locale.

import locale

string_us = "1,234.56"
string_eu = "1.234,56"

# --- Test with US Locale ---
try:
    locale.setlocale(locale.LC_ALL, 'en_US.UTF-8') # Or '' if US is system default
    float_us_locale = locale.atof(string_us)
    print(f"\nUsing locale '{locale.getlocale()}':")
    print(f"  '{string_us}' -> {float_us_locale}") # Output: 1234.56

    # Trying to parse EU style with US locale will likely fail or give wrong result
    try:
        float_eu_fail = locale.atof(string_eu)
        print(f"  '{string_eu}' -> {float_eu_fail} (Potential misinterpretation)")
    except ValueError as e:
        print(f"  '{string_eu}' -> Error as expected: {e}") # More likely

except locale.Error:
    print("Warning: en_US locale not available.")

# --- Test with German Locale ---
try:
    locale.setlocale(locale.LC_ALL, 'de_DE.UTF-8') # Or '' if German is system default
    float_eu_locale = locale.atof(string_eu)
    print(f"\nUsing locale '{locale.getlocale()}':")
    print(f"  '{string_eu}' -> {float_eu_locale}") # Output: 1234.56

    # Trying to parse US style with DE locale will likely fail
    try:
        float_us_fail = locale.atof(string_us)
        print(f"  '{string_us}' -> {float_us_fail} (Potential misinterpretation)")
    except ValueError as e:
        print(f"  '{string_us}' -> Error as expected: {e}") # More likely

except locale.Error:
     print("Warning: de_DE locale not available.")

# Reset locale to default if necessary
# locale.setlocale(locale.LC_ALL, '')

Example of Output:

Using locale '('en_US', 'UTF-8')':
  '1,234.56' -> 1234.56
  '1.234,56' -> 1.23456 (Potential misinterpretation)
Warning: de_DE locale not available.

note

locale.atof() correctly interprets the thousands and decimal separators based on the locale set by setlocale().
You need to have locale that you want to use.

Handling Different Locales

The challenge with locale is knowing which locale applies to your input data. If you receive data from multiple sources with different formatting, you might need to:

Identify the format (perhaps based on source or heuristics).
Set the appropriate locale using setlocale() before calling atof().
Potentially reset the locale afterward (locale.setlocale(locale.LC_ALL, '')) if the locale change could affect other parts of your application unexpectedly (as setlocale affects the global locale setting for the process).

Choosing the Right Method

Use str.replace() when:
- You know the exact format(s) of your input strings (e.g., always comma-thousands/dot-decimal, or always dot-thousands/comma-decimal).
- You want a simple, self-contained solution without external dependencies or system locale configuration concerns.
- You need fine-grained control over exactly which characters are removed/replaced.
Use locale module when:
- You need to correctly parse numbers based on standard regional conventions.
- You are building internationalized applications where input might genuinely match the user's system locale.
- You are comfortable with managing locale settings and aware of potential OS dependencies for locale names.
- Be cautious about the global nature of setlocale if different parts of your application expect different locale settings simultaneously.

For many common cases where the format is predictable (e.g., processing data from a specific known source), the str.replace() method is often simpler and sufficient.

Conclusion

Converting number strings with thousands separators (like commas or dots) to Python floats requires preprocessing before using the standard float() function.

The str.replace() method provides a straightforward way to remove known thousands separators and standardize the decimal separator (.). This is often the simplest approach for predictable input formats.
The locale module (setlocale, atof) offers a locale-aware solution, correctly interpreting separators based on regional standards. This is more robust for internationalization but requires managing locale settings and understanding their system dependencies.

Choose the method that best suits the variability and origin of your string data and your application's requirements for locale handling.

How to Convert String with Comma/Dot Separators to Float in Python

The Challenge: Non-Standard Number Formats​

Method 1: Using String replace() (Recommended for Known Formats)​

Handling Comma Thousands Separator, Dot Decimal (1,234.56)​

Handling Dot Thousands Separator, Comma Decimal (1.234,56)​

Method 2: Using the locale Module (For Locale-Awareness)​

Setting the Locale (locale.setlocale)​

Converting with locale.atof()​

Handling Different Locales​

Choosing the Right Method​

Conclusion​

Table of Contents

The Challenge: Non-Standard Number Formats

Method 1: Using String `replace()` (Recommended for Known Formats)

Handling Comma Thousands Separator, Dot Decimal (`1,234.56`)

Handling Dot Thousands Separator, Comma Decimal (`1.234,56`)

Method 2: Using the `locale` Module (For Locale-Awareness)

Setting the Locale (`locale.setlocale`)

Converting with `locale.atof()`

Handling Different Locales

Choosing the Right Method

Conclusion