How do I check if a string represents a number (float or int)?

Understanding the nature of the beast (the problem)

When checking if a string represents a number, we need to clarify what kind of number we're talking about. We can't just check if a there are digits in a string – we need to be sure that the entire string represents a meaningful integer, float, or even a number in scientific notation. To make this happen, we may need Sherlock Holmes, but a try-except block and float() function largely do the trick.

Hunting down integers with isdigit()

When hunting down integer culprits, str.isdigit() is your detective. It checks if a string contains only digits:

num_str = "123"
print(num_str.isdigit())  # Yay! We caught one. Returns: True


But remember, str.isdigit() is a naive detective that can only spot non-negative integers. It flunks when it confronts negative integers, fractional values or strings in scientific notation.

Casting the net for floats

If you're fishing for floats in a sea of strings, you'd benefit from combining str.replace() and str.isdigit():

print('123.45'.replace('.', '', 1).isdigit())  # Gotcha! Returns: True


This technique eliminates a single decimal point, though it often runs away scared when faced with multiple dots or scientific notation.

Can't touch this: Edge cases & scientific notation

Beware! Non-standard float formats are the sneaky little devils that can run amok in your code. These culprits can either have more than one dot, or come disguised in scientific notation ('1.5e2' which equals 150). But fear not! Our trusty try-except approach shines in the dark alleys of these edge cases, proficiently converting these troubling strings to numbers.

Tackling Unicode characters

In the world where Unicode strings roam the wild, instead of str.isdigit(), you'll need a special ranger called unicode.isnumeric():

unic_num = u"½"
print(unic_num.isnumeric())  # Unicode, Unicode! It works! Returns: True


This function can catch numbers written using Unicode symbols, which str.isdigit() could never dream of taming.

The curious case of 'NaN'

Don't be surprised if you encounter 'NaN' (Not a Number) while parsing your strings. This chameleon can pass as a float but doesn't represent a real number:

nan_str = 'NaN'
print(float(nan_str))  # Nice costume, NaN! But you can't fool us. Returns: nan


Though 'NaN' deftly disguises itself as a float, your task may require you to search and neutralize it.

Performance considerations

Though regex might appear an alluring method for numeric checks, it's no Golden Fleece. Regex patterns can get twisted, fail to spot all numeric edge cases and often collapse under the weight of dissimilar locales or scientific formats. In speed tests, our trusty try-except buddy outperforms regex, proving once again, slow and steady wins the race when handling numbers.

Picking the right tool

In the quest to identify whether strings are numbers, different situations call for different method:

• If you're dealing with positive integers, go for str.isdigit().
• For quickly identifying non-negative integers and floats (minus the scientific notation), use the fusion technique of str.replace() and str.isdigit().
• The try-except method coupled with float() is your universal soldier, equipped to handle positive and negative integers, flaunt floats, and school scientific notation.
• Lastly, when dealing with strings from around the globe, unicode.isnumeric() can handle the diversity of Unicode numeric characters.

More than checking, it's about structure!

Enhancing code readability and reusability is a cardinal rule in computer programming. Encapsulate these methods into schematic functions:

def is_plain_integer(s):  # Plain Jane Integers
    return s.isdigit()

def is_float_or_integer(s):  # Floats and integers, no specialists here
    return s.replace('.', '', 1).isdigit()

def is_number_extended(s):  # The Universal Soldier
    try:
        float(s)
        return True
    except ValueError:
        # Oh no, we have been duped! That string is not a number!
        return False


By crafting these wrapper functions, you not only make your code more concise and readable but also cover all bases when number validation is the game.