Checking if a string can be converted to float in Python

A deep dive into checking float convertibility

Time to meet regex, the 'pattern' whisperer!

What if you have a giant block of text and you need to check if a substring is a floating-point number? Enter the crown prince of pattern, regular expressions!

import re

def is_float_re(s):
    return bool(re.match(r'^-?\d+(\.\d+)?$', s)) # Returns True if 's' fits the bill!

print(is_float_re("3.14"))  # True, pi is always constant!
print(is_float_re("3."))    # False, we are being decimal about it!


But beware, regex can be slow, like a sloth climbing a tree, so use it only for precision checks.

Handling the None-troversial and empty cases

What about None and empty strings ""? Yes, those sneaky little fellas can cause exceptions if not handled:

def can_convert_with_none_check(s):
    if s is None or s == '':
        return False
    try:
        float(s)
        return True  # Victory screech! 's' is a float.
    except ValueError:
        return False  # We've been bamboozled! 's' wasn't a float.

print(can_convert_with_none_check(None))  # False, None shall pass!
print(can_convert_with_none_check(""))    # False, it's empty, like my coffee mug on a Monday.


When speed is life — 'fastnumbers'

For you folks doing big data, you'll love fastnumbers. Shaves milliseconds off your timing like a ninja!

from fastnumbers import fast_float

def can_convert_fast(s):
    return fast_float(s, default=False) is not False # True only if 's' can float!

print(can_convert_fast("Infinity"))  # True - to infinity and beyond!
print(can_convert_fast("$99.99"))    # False; sorry, we don't accept cash or card, only floats.


Beware of the fringe!

Unicode strings and overflows are rare but possible challenges:

• OverflowError can happen with massive numbers, but your try-except block has got you covered, just like a superhero!
• Unicode normalization: String representation across Python versions can differ, like twins in different outfits, causing conversion issues.

Exception handling is key

Don't silence exceptions; they're like fortune cookies, providing wisdom on where your code fumbles. Specifically state the exceptions you're catching, or you're opening Pandora's box!

Testing is your best friend

Would you run a marathon without any training? Nope. So, unit testing is your best pal. It ensures your code holds up well even when Python twists and turns.

import unittest

class TestStringToFloat(unittest.TestCase):
    def test_valid_float(self):
        self.assertTrue(can_convert("42.0"))  # True, The answer to life, universe, and everything is accepted!

    def test_invalid_float(self):
        self.assertFalse(can_convert("NaN")) # False, Not a Number, not a float!

if __name__ == '__main__':
    unittest.main()  # Let the testing games begin!


Keep up with the Pythons

Assumptions can be risky. It's important to keep up with changes in the Python family that might affect your code. Don't let your code be caught off-guard!