# Check if a String is a Number in Python

Checking if a string represents a number is a fundamental Python skill. It unlocks numerous possibilities, such as validating user input, seamlessly handling file data, and performing accurate calculations.

In this guide, we will discuss the following approaches to check if a string is a number in Python:

• Using try-except block
• Using isdigit() method
• Using isnumeric() method
• Using regular expression

## #1 Using try-except block

In Python, a `try-except` block is used to handle exceptions (errors) that may occur during the execution of a program.

In this method, we attempt to convert a string to a number using the `float()` method. If the conversion is successful, it means the string is a number. Otherwise, it’s not a number.

Here’s an example:

``````def is_number(str):
# Check if a string is a number using try-except block
try:
x = float(str)
# Return True if the conversion to float is successful
return True
except ValueError:
# Return False if the conversion fails
return False

print(is_number("22"))       # True -> Integer
print(is_number("3.14"))     # True -> Float
print(is_number("-35"))      # True -> Negative Integer
print(is_number("-44.71"))   # True -> Negative float
print(is_number("hello"))    # False -> String with alphabets
print(is_number("5e7"))      # True -> Scientific Notation
print(is_number("   22  "))
# True -> Integer with leading and trailing whitespace
print(is_number("3a4"))      # False -> Alphanumeric string
print(is_number("5.6.7"))    # False -> Invalid float with multiple dots
print(is_number(""))         # False -> Empty string
print(is_number(" "))        # False -> Whitespace
print(is_number("1,000"))    # False -> Comma in integer
print(is_number("300 000"))  # False ->Integer with whitespace in between``````

The `try-except` block handles a wide range of number formats, including integers, floats, negative, and even scientific notation. It also handles unexpected input scenarios such as leading/trailing whitespaces, alphanumeric strings, or strings with multiple dots.

The versatility of this approach makes it a reliable choice for validating numeric strings in diverse situations. However, the `try-except` approach is slower than other methods, especially for non-numbers. Benchmarks show the `try-except` approach can be slower for non-numbers, but faster for numbers, which are more likely in practice.

## #2 Using isdigit() method

The `isdigit()` method checks if a string consists of only digits. It returns `True` if all characters in the string are digits (`0-9`), and `False` otherwise.

For example:

``````def is_number(str):
return str.isdigit()

print(is_number("22"))     # True
print(is_number("hello"))  # False``````

### Handling decimal numbers (float)

The `isdigit()` method only checks for digits (`0-9`) in a string. This means it doesn’t recognize decimal numbers like `"3.14"`, even though we might consider them numeric.

If you need to consider numbers with decimal points as numeric values, you must handle them explicitly.

You can use the `replace()` method to remove the decimal point and check if the resulting string consists only of digits.

Here’s an example:

``````def is_number(str):
# Remove leading and trailing whitespace
str = str.strip()

# Remove the first occurrence of ‘.’ if present
str = str.replace('.', '', 1)
return str.isdigit()

print(is_number("22"))     # True
print(is_number("hello"))  # False
print(is_number("3.14"))   # True
print(is_number("2.6.3"))  # False``````

In the example above, we first use the `strip()` method to remove the leading and trailing whitespace.

Then, we use the `replace()` method to replace the first occurrence of the dot (`'.'`) in the string `str` with an empty string (`''`).

The third argument `1` specifies that only the first occurrence should be replaced. This is important because if there are multiple dots in the string, you want to retain the rest. This allows you to correctly identify the string with one decimal point as a number. However, strings with multiple decimal points (e.g. `"192.168.1.1"`) will be considered non-numeric.

### Handling negative numbers

To handle negative numbers, you can extend the check by allowing a minus sign at the beginning of the string.

Here’s an updated example:

``````def is_number(str):
# Remove leading and trailing whitespace
str = str.strip()

# Remove the first occurrence of '.' if present
str = str.replace('.', '', 1)

# Check if the first character is "-". If yes, remove it
if str[0] == "-":
str = str[1:]

# Check if the remaining string is composed of only digits
return str.isdigit()

print(is_number("22"))     # True
print(is_number("-24"))    # True
print(is_number("--66"))   # False
print(is_number("+29"))    # False``````

In the example above, we check if the first character in the string is `"-"`. If it is, we remove it by using the slice notation. The slice notation `str = str[1:]` extracts the substring starting from the index `1` to the end of the string. Then, we check if the string contains only digits.

If you want to handle the positive sign (`"+"`) in your code, you can further modify the `is_number()` function to consider the possibility of a positive sign at the beginning of the string.

Here is an updated version of the code:

``````def is_number(str):
# Remove leading and trailing whitespace
str = str.strip()

# Remove the first occurrence of '.' if present
str = str.replace('.', '', 1)

# Check if the first character is '+' or '-'. If yes, remove it
if str[0] in ["+", "-"]:
str = str[1:]

return str.isdigit()

print(is_number("22"))     # True
print(is_number("-24"))    # True
print(is_number("--66"))   # False
print(is_number("+29"))    # True``````

### Handling scientific notation numbers

If you want to handle scientific notation numbers, you can further modify the `is_number()` function to handle scientific numbers.

Here’s an updated code:

``````def is_number(str):
# Remove leading and trailing whitespace
str = str.strip()

# Remove the first occurrence of '.' if present
str = str.replace('.', '', 1)

# Check if the first character is '+' or '-'. If yes, remove it
if str[0] in ["+", "-"]:
str = str[1:]

# Convert the string to lowercase to handle 'e' and 'E'
str = str.lower()

# check if the string is a scientific notation number
parts = str.split('e', 1)

if len(parts) == 2 and parts[0].isdigit() and (parts[1].isdigit() or (parts[1][0] in ["+", "-"] and parts[1][1:].isdigit())):
return True

return str.isdigit()

print(is_number("22"))     # True
print(is_number("hello"))  # False
print(is_number("2e5"))    # True
print(is_number("-3e7"))   # True
print(is_number("7e-5"))   # True
print(is_number("4E7"))    # True``````

Handling scientific notation numbers using the `isdigit()` method can be tricky. First, we convert the string to lowercase to handle both `'e'` and `'E'`

Then, we split the string at the first occurrence of `'e'`. The result is stored in the `parts` list. If the length of the `parts` is `2` and the first part (before `'e'`) consists of digits, and the second part (after `'e'`) consists of digits or starts with `'+'` or `'-'`, followed by digits, then the function returns `True`, indicating the string is a valid scientific notation number.

If the first part (before `'e'`)  contains a negative sign, it has already been removed in a previous step. If the conditions for scientific notation are not met, the function falls back to check if the entire string consists of digits using the `isdigit()` method.

## #3 Using isnumeric() method

The `isnumeric()` method checks if a string consists of only numbers. It returns `True` if all characters in the string are numbers, and `False` otherwise.

For example:

``````def is_number(str):
return str.isnumeric()

print(is_number("22"))     # True
print(is_number("hello"))  # False``````

### Differences between isdigit() and isnumeric() method

In Python, both `isdigit()` and `isnumeric()` methods are used to check if all characters in a string are numeric, but they differ in their level of strictness and the type of characters they consider valid.

Here’s a breakdown of their key differences.

#### isdigit():

Stricter: Only considers characters classified as Unicode digits (`0-9`)

Example: `"123"` returns `True`, `"\u0031"` returns `True` (Unicode for `1`),  `"\u2165"` returns `False` (Unicode for Roman numeral `Ⅵ`)

#### isnumeric():

More inclusive: Considers a wide range of characters including:

• Unicode digits (`0-9`)
• Fractions
• Some specific characters like Roman numerals and superscripts/subscripts

Example: `"123"` returns `True``"\u0031"` returns `True` (Unicode for `1`), `"¼"` returns `True`, `"\u2165"` returns `True `(Unicode for Roman numeral `Ⅵ`)

### Handling decimal point numbers (float)

The `isnumeric()` method, like `isdigit()`, is also limited to checking for numeric characters in a string. This means it won’t recognize decimal numbers like `"3.14"` as valid.

To handle decimal point numbers, you can use the `replace()` method to remove the decimal point and check if the resulting string consists only of digits.

Here’s an updated code:

``````def is_number(str):
# Remove leading and trailing whitespace
str = str.strip()

# Remove the first occurrence of '.' if present
str = str.replace('.', '', 1)
return str.isnumeric()

print(is_number("22"))     # True
print(is_number("hello"))  # False
print(is_number("3.14"))   # True``````

In the example above, we first use the `strip()` method to remove the unnecessary leading and trailing whitespace.

Then, we use the `replace()` method to remove the first occurrence of the dot (`'.'`) in the string `str` with an empty string (`''`).

The third argument `1` specifies that only the first occurrence of the dot (`'.'`) should be replaced.

### Handling negative numbers

To handle negative numbers, you can extend the check by removing a minus sign (`'-'`) at the beginning of the string if present.

Here’s an updated code:

``````def is_number(str):
# Remove leading and trailing whitespace
str = str.strip()

# Remove the first occurrence of '.' if present
str = str.replace('.', '', 1)

# Check if the first character is "-". If yes, remove it
if str[0] == "-":
str = str[1:]

# Check if the remaining string is composed of only digits
return str.isnumeric()

print(is_number("22"))     # True
print(is_number("-24"))    # True
print(is_number("--66"))   # False
print(is_number("+29"))    # False``````

In the example above, we use the slice notation `str = str[1:]` to extract the substring starting from the index `1` to the end of the string.

If you want to handle the positive sign (`'+'`) in your code, you can further modify the `is_number()` function to consider the possibility of a positive sign at the beginning of the string.

Here is an updated version of the code:

``````def is_number(str):
# Remove leading and trailing whitespace
str = str.strip()

# Remove the first occurrence of '.' if present
str = str.replace('.', '', 1)

# Check if the first character is '+' or '-'. If yes, remove it
if str[0] in ["+", "-"]:
str = str[1:]

return str.isnumeric()

print(is_number("22"))     # True
print(is_number("-24"))    # True
print(is_number("--66"))   # False
print(is_number("+29"))    # True``````

### Handling scientific notation numbers

Handling scientific notation numbers using the `isnumeric()` method is not a good idea because it accepts digits and their Unicode representations from various languages.

Even adding checks for `'e'` or `'E'` isn’t foolproof. It will fail if the string contains mixed exponential and characters from different languages like `"2E๑5"`.

## #4 Using regular expression

A regular expression (regex) is a powerful tool that allows us to find and manipulate specific patterns in a string. It can extract valuable information, validate data, and even transform text in creative ways.

You can use a regular expression to check if a string is a number. It makes sense to use regular expressions if you already know what kind of number format you are looking for.

### Checking if a string is an integer

Below is a code example that checks if a string is an integer:

``````import re

def is_number(str):
# Remove leading and trailing whitespace
str = str.strip()

# Define a regular expression pattern for an integer
pattern = re.compile(r'^\d+\$')

# Return True if the pattern matches the entire string
return bool(pattern.match(str))

print(is_number("22"))     # True
print(is_number("hello"))  # False``````

First, you need to import the `re` module to use regular expressions in Python.

In the `is_number()` function:

• We first define the pattern using `re.compile()` method. The `re.compile()` method takes a regular expression pattern as a string and compiles it to a reusable `Pattern` object.
• Then, we call the `match()` method on the compiled pattern object with the string to be checked. The `match()` method attempts to match the compiled pattern against the beginning of the given string.
• If the `match()` method returns a `Match` object (meaning the pattern matches the beginning of the string), the `bool` conversion returns `True`, indicating the string is a valid integer.
• If the `match()`method returns `None` (no full match), the `bool` conversion returns `False`, indicating the string is not a valid integer.

In the regular expression `'^\d+\$'`:

`^`: Asserts the start of the string. The `^` indicates the start of the string.

`\d+`: Matches one or more digits. `\d` represents any digits (`0-9`), and the `+` quantifier means “one or more”.

`\$`: Asserts the end of the string. The `\$` indicates the end of the string.

This pattern ensures that the string starts with a digit, contains one or more digits, and ends with a digit.

### Handling optional positive (+) or (-) sign

Below is a code that checks if a string is an integer with an optional positive or negative sign:

``````import re

def is_number(str):
# Remove leading and trailing whitespace
str = str.strip()

# Define a regular expression pattern
pattern = re.compile(r'^[+-]?\d+\$')

# Return True if the pattern matches the entire string
return bool(pattern.match(str))

print(is_number("22"))     # True
print(is_number("hello"))  # False
print(is_number("-36"))    # True``````

In the regular expression `'^[+-]?\d+\$'`:

`^`: Asserts the start of the string. The `^` indicates the start of the string.

`[+-]?`: Matches an optional plus (`+`) or minus (`-`) sign. The `?` makes the preceding character class `[+-]` optional.

`\d+`: Matches one or more digits. `\d` represents any digits (`0-9`), and the `+` quantifier means “one or more”.

`\$`: Asserts the end of the string. The `\$` indicates the end of the string.

This pattern checks for an optional sign at the beginning and one or more digits, ensuring the entire string is a valid integer.

### Handling decimal point numbers (float)

Below is a code example that checks if a string is a number with an optional sign and decimal point.

``````import re

def is_number(str):
# Remove leading and trailing whitespace
str = str.strip()

# Define a regular expression pattern
pattern = re.compile(r'^[+-]?\d+(\.\d+)?\$')

# Return True if the pattern matches the entire string
return bool(pattern.match(str))

print(is_number("22"))     # True
print(is_number("-36"))    # True
print(is_number("3.14"))   # True
print(is_number("2."))     # False
print(is_number(".9"))     # False
``````

In the regular expression `'^[+-]?\d+(\.\d+)?\$'`:

`^`: Asserts the start of the string. The `^` indicates the start of the string.

`[+-]?`: Matches an optional plus (`+`) or minus (`-`) sign. The `?` makes the preceding character class `[+-]` optional.

`\d+`: Matches one or more digits. `\d` represents any digits (`0-9`), and the `+` quantifier means “one or more”.

`(\.\d+)?`: This part makes an optional decimal point followed by one or more digits.

• `(` and `)`: Parentheses create a capturing group for the decimal part. This allows you to group parts of the regular expression and apply quantifiers to them.
• `\.`: The backslash `\` is an escape character. It escapes the dot, making it match a literal dot (decimal point).
• `\d+`: Matches one or more digits after the decimal point.
• `?`: The `?` makes the entire capturing group optional.

`\$`: Asserts the end of the string. The `\$` indicates the end of the string.

### Handling scientific notation numbers

Below is a code example that checks if a string is a number (integer, float, or scientific notation number):

``````import re

def is_number(str):
# Remove leading and trailing whitespace
str = str.strip()

# Define a regular expression pattern for a number (integer, float, or scientific notation)
pattern = re.compile(r'^[+-]?\d+(\.\d+)?([eE][+-]?\d+)?\$')

# Return True if the pattern matches the entire string
return bool(pattern.match(str))

print(is_number("22"))     # True
print(is_number("3.14"))   # True
print(is_number("3e2"))    # True
print(is_number("5e3"))    # True
print(is_number("9a3"))    # False``````

In this updated code, the regular expression` '^[+-]?\d+(\.\d+)?([eE][+-]?\d+)?\$'` has been extended to include an optional exponent part:

`([eE][+-]?\d+)?`: This part allows for an optional exponent part in the form of `e` or `E` followed by an optional plus or minus sign and one or more digits.

• `(` and `)`: Parentheses create a capturing group for the decimal part. This allows you to group parts of the regular expression and apply quantifiers to them.
• `[eE]`: Mathes either an `'e'` or `'E'`, representing the exponent part in scientific notation. The square brackets `[eE]` define a character class that matches either `'e'` or `'E'`
• `[+-]?`: Matches an optional plus (`+`) or minus (`-`) sign. The `?` makes the preceding character class `[+-]` optional.
• `\d+`: Matches one or more digits. `\d` represents any digits (`0-9`), and the `+` quantifier means “one or more”.
• `?`: The entire capturing group `([eE][+-]?\d+)` is followed by a `?`, which makes the entire group optional. This means that the exponent part is not required in the pattern. The `?` quantifier applies to the entire capturing group, making it optional as a whole.

Putting it all together, `([eE][+-]?\d+)?` allows for an optional exponent part in the number, specifically in scientific notation. If present, it consists of an `'e'` or `'E'`, an optional plus or minus sign, and one or more digits. If absent, the entire exponent part is optional.

## Conclusion:

In conclusion, selecting the appropriate method for checking if a string is a number in Python depends on your specific requirements.

While the `try-except` block offers flexibility, it’s generally slower than other methods, especially for non-numeric strings. If speed is crucial, consider `isdigit()` or `isnumeric()` methods instead.

For cases where you want to ensure the string consists of only digits (`0-9`), the `isdigit()` method is a straightforward choice. While it doesn’t directly handle floats or scientific notation, you can extend its functionality using regular expression or string-splitting techniques to accommodate those number formats.

For broader number recognition across various languages and Unicode characters, the `isnumeric()` method provides flexibility. However, you cannot extend its functionality to handle scientific notation.

Finally, for more complex scenarios or specific number formats, utilizing regular expression provides a flexible solution.

Consider your project’s demands and choose the right method that best aligns with your objectives.

Happy Coding !!!—