How can I match a number with an optional sign and decimal part?

Assuming your intended format requires at least one digit before the decimal point and, if a decimal point appears, at least one digit after it, use this Python re pattern:

r'^[+-]?[0-9]+(?:\.[0-9]+)?$'

The sign is optional; the digits before the decimal are required. The final group makes the decimal point and its following digits optional as one unit. The ^ and $ anchors specify the beginning and end of the string in Python’s regular-expression context. [S1]

For example, 12, -12, +12, 3.14, and -0.5 fit that stated shape. This is intentionally narrower than every way people write numbers.

Read the pattern from left to right:

1. ^ starts the match at the beginning of the string.
2. [+-]? allows one plus or minus sign, or no sign.
3. [0-9]+ requires one or more digits before any decimal point.
4. (?:\.[0-9]+)? allows either no fractional part, or a literal dot followed by one or more digits.
5. $ anchors the pattern at the string’s end. [S1]

The group matters because the dot and its following digits belong together: making the whole group optional allows an integer such as 12, without also allowing a dangling dot such as 12.. The ?: form is a non-capturing group; here, grouping is used to apply the optional marker to the whole decimal portion.

Under the format above, the pattern rejects .5 because there are no digits before the dot; 5. because the dot has no following digit; and an empty string because at least one digit is required. It also rejects --5, 1e3, and 1,5: those forms are not included in this deliberately limited pattern. [S1]

That last point is important. A comma may be a decimal separator in some conventions, but this pattern allows a dot, not locale-specific separators. It checks whether text has the chosen shape; it does not establish that the value follows every numeric convention or decide how an application should parse it. [S1]

Here is a small Python example you can adapt. The expected results are illustrative checks for the stated pattern, not a complete test suite:

import re

number_text = re.compile(r'^[+-]?[0-9]+(?:\.[0-9]+)?$')

examples = {
    '12': True,
    '-12': True,
    '+3.14': True,
    '.5': False,
    '5.': False,
    '1,5': False,
}

for text, expected in examples.items():
    print(text, bool(number_text.fullmatch(text)), expected)

A useful review note is: “Accept an optional leading sign, one or more digits, and optionally a dot plus one or more digits. This format requires digits on both sides of a decimal point and uses a dot as the separator.” Python’s re documentation gives this pattern for the limited format and notes that it does not cover leading-dot fractions or locale-specific separators. [S1] If your product needs those forms, define them explicitly before changing the pattern.