Converting Python Strings to Floats While Ignoring Letters

Rate this post
πŸ’‘ Problem Formulation:

Python developers often encounter the task of extracting numerical values from strings when handling data that mixes letters and numbers. For instance, you might be dealing with input like '123abc456' and you need to obtain the float value 123.456. The question is, how can you extract and convert these mixed strings to floats, disregarding any non-numeric characters? This article presents several methods to address this common issue.

Method 1: Using Regular Expressions

Regular Expressions (regex) provide a powerful tool for pattern matching in text. By using Python’s re module, you can define a pattern to find all numbers in a string and then convert them to a float.

Here’s an example:

import re

def string_to_float(s):
    numbers = re.findall(r"\d+\.?\d*", s)
    return float(''.join(numbers))


Output: 1234.56

This function uses the re.findall() method to find all substrings that match the defined pattern of digits possibly followed by a dot and more digits. The result is a list of number strings that gets joined into a single string and converted to a float. Note that this method concatenates all numeric parts together.

Method 2: Iterative Character Check

This method involves checking each character in the string to see if it’s a digit or a decimal point. If it’s one of those, we keep it; otherwise, we skip it.

Here’s an example:

def string_to_float_iterative(s):
    numeric_string = ''.join([c for c in s if c.isdigit() or c == '.'])
    return float(numeric_string)


Output: 123.456

In this example, we create a list comprehension that filters out any characters that are not digits or decimal points. We then join this filtered list into a string that represents a number which can be converted to a float. It’s a straightforward method but may not work correctly if the string has multiple decimal points.

Method 3: Using the filter() Function

Python’s built-in filter() function makes it possible to achieve the same result as Method 2 but with a more concise expression.

Here’s an example:

def string_to_float_filter(s):
    numeric_string = ''.join(filter(lambda x: x.isdigit() or x == '.', s))
    return float(numeric_string)


Output: 1234.56

The lambda function provided to the filter() function serves the same purpose as the conditional in the list comprehension: to select only numeric characters and the decimal point from the string. Then those filtered characters are joined and converted to float.

Method 4: Using String Methods and List Comprehension

Python string methods coupled with list comprehension can be used to extract digits and decimal points from a string before conversion.

Here’s an example:

def string_to_float_str_methods(s):
    numeric_string = ''.join(c for c in s if c.isnumeric() or c == '.')
    return float(numeric_string)


Output: 123.45

This code uses str.isnumeric(), which returns True for numerical characters. The list comprehension filters these out and adds the decimal points before combining into a single string and converting to float. It’s a clean and easily readable method.

Bonus One-Liner Method 5: Compact Regex Approach

If you want a compact solution using regex, here’s a one-liner that applies a similar approach to Method 1.

Here’s an example:

import re

print(float(re.sub("[^0-9.]", "", "12ab34.56cd78")))

Output: 1234.5678

This one-liner uses the re.sub() method to replace all characters that are not digits or a dot with an empty string, directly converting the result to float. It’s concise but could introduce errors if not used with caution (e.g., multiple decimal points).


  • Method 1: Regular Expressions. Highly flexible. It may concatenate numbers inappropriately if not used correctly.
  • Method 2: Iterative Character Check. Easy to understand. May fail with improper input such as multiple decimal points.
  • Method 3: Using filter() function. Concise. Similar limitations as Method 2 with the potential for mistakes with multiple decimals.
  • Method 4: String Methods and List Comprehension. Readable. Can be more CPU-intensive for long strings compared to regex.
  • Bonus Method 5: Compact Regex One-Liner. Super concise. Risk of incorrect conversion with multiple decimal points or misplaced digits.