Detecting float or int in a string

[Clunk_Head]

The str.isnumeric() function is lacking when it comes to detecting floats.
Several sites say to use a try/except to attempt the conversion. I was taught not to depend on try except in the regular program flow, and that it should only be used in the case of real exceptions, like catching runtime errors.
To that end, I made the function below.
Is there a better way?
Would you change anything about this?

def is_number(string):
    if string.isnumeric():
        return True
    if string.count('.') == 1:
        if string.replace('.', '').isnumeric():
            return True
    return False

Thanks for looking.

[Gribouillis]

I was taught not to depend on try except in the regular program flow, and that it should only be used in the case of real exceptions, like catching runtime errors.

I disagree completely with this philosophy. Exceptions must be raised and sometimes (often) caught in regular Python program flow. Their role goes far beyond signaling errors.

[Clunk_Head]

I disagree completely with this philosophy

Can you please provide an example where an exception must be used in place of anything else? I'd like to expand my understanding of it. A link to reading is fine.

[bowlofred]

I don't see anything wrong with using a try/except for handling an attempt to see if something is or is not compatible with float().

Float will handle exponential notation while yours will not. Up to you if that's a problem. Yours will not handle negative numbers or numbers with an explicit plus sign.

>>> [float(x) for x in ("1e3", "-12", "+3.5")]
[1000.0, -12.0, 3.5]

[Clunk_Head]

I don't see anything wrong with using a try/except for handling an attempt to see if something is or is not compatible with float().

How much memory does it use? That's part of the reasoning behind not relying on it.
While the topic of this thread is for general use, I've found that try blocks in circuitpython are memory hogs.

exponential notation while yours will not. Up to you if that's a problem. Yours will not handle negative numbers or numbers with an explicit plus sign.

That's what I was looking for. Thanks a bunch.
Still have a bit of work to do.

[Gribouillis]

Can you please provide an example where an exception must be used in place of anything else?

Exceptions free intermediary code from checking all the obstacles that can occur for completing a task. For example

def get_cup_of_coffee():
    go_to_recreation_room()
    open_the_door()
    go_to_coffee_machine()
    insert_coin()
    push_button()
    cup = take_coffee()
    return cup

Many things can go wrong. The door could be locked, the machine could be in maintenance, the coin could be rejected, etc. All these events, which are not errors should raise an exception when the corresponding function is called. But the logic of get_cup_of_coffee() does not need to handle these exceptions. It lets them propagate and they all result in get_cup_of_coffee() sending an exception.

Now the code that uses this function can freely decide to catch the exceptions or not, for example

def ten_o_clock_routine():
    try:
        coffee = get_cup_of_coffee()
    except RecreationRoomLocked:
        # take appropriate action
    except Exception:
        # other errors
    else:
        coffee.drink()

The main gain is to choose at which level we catch the exceptions in the code (if they are caught).

In a language without exceptions, such as C, get_cup_of_coffee() would have the responsibility to handle all the exceptional cases that can happen in the functions that it calls. In some other languages, we would need to declare all the exception types that are thrown by the function, which is tedious. But not in Python.

[Clunk_Head]

Float will handle exponential notation while yours will not. Up to you if that's a problem. Yours will not handle negative numbers or numbers with an explicit plus sign.

Think I've got it fixed:

def is_number(string):
    if string.isnumeric():
        return True
    if string[0] == '-' or string[0] == '+':
        return is_number(string[1: ])
    if string.count('.') == 1:
        return is_number(string.replace('.', '')
    elif string.count('e') == 1:
        index = string.find('e')
        return is_number(string[ :index]) and is_number(string[index+1: ])
    return False

There's probably another case that I've missed. Please let me know if you see one.

[Gribouillis]

A more classical way to implement your parsing strategy would be to use regular expressions.

[bowlofred]

All depends on how much you care to make it identical. You're doing recursive function calls. Would need to test, but I'd worry that would have a bigger impact on memory than a try block.

I believe your function will pass the strings ++-+3 and 3e, while float() will not.

[Clunk_Head]

regular expressions

I understand that python has a fast regex engine. I haven't timed it since python 2 though, but then I found regex to be slower than replace() by at least a factor of 10. I never timed it against count or find.

Sounds like it's worth investigating it again, as I could probably consolidate it using regex.
I will also look into using translate.

Good advice, thank you.