Detecting float or int in a string

[Gribouillis]

I found regex to be slower than replace() by at least a factor of 10

I'm pretty confident that regex will be faster than your recursive function with many ifs. Still, the officially pythonic way is to try to convert and catch an exception...

[Clunk_Head]

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.

Good point. I will test it and see. I may have to unroll the recursion and test that too.

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

Unrolling the recursion should allow me to correct that.

[Clunk_Head]

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.

I think therein lies my issue, having been raised on ASM/C/C++

[perfringo]

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

Python documentation, glossary:

EAFP
Easier to ask for forgiveness than permission. This common Python coding style assumes the existence of valid keys or attributes and catches exceptions if the assumption proves false. This clean and fast style is characterized by the presence of many try and except statements. The technique contrasts with the LBYL style common to many other languages such as C.

There are many countries out there with different notations. 1.000,42 and 1,000.42 are perfectly 'legal' and equal numbers, just depending your locale.

There is ast.literal_eval() which can be used (locale thingy still applies):

>>> import ast
>>> ast.literal_eval('1.0')
1.0
>>> ast.literal_eval('+3')
3
>>> ast.literal_eval('-42')
-42
>>> type(ast.literal_eval('-42'))
<class 'int'>

If you feed invalid value then you get SyntaxError:

>>> ast.literal_eval('1.0.0')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/ast.py", line 62, in literal_eval
    node_or_string = parse(node_or_string.lstrip(" \t"), mode='eval')
  File "/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/ast.py", line 50, in parse
    return compile(source, filename, mode, flags,
  File "<unknown>", line 1
    1.0.0
       ^^
SyntaxError: invalid syntax

You can use EAFP style with try to literally evaluate value, catch syntax error if it's raised and do something about it

[Clunk_Head]

Here's how I settled it to meet pythonic standards as well as those I was raised on.
In this application, a calculator, I was originally doing this:
1) Try to convert to float
2) except, check against operator list
3) if not in list, then it's an invalid expression

But if I swap those checks around:
1) Check against operator list
2) if not in list, try to convert to float
3) except, invalid expression
While minor it satisfies my desire to keep exceptions for exceptions.

Thanks to all who replied, I learned a lot. I will be more open-minded about try/except blocks in python.

[Pedroski55]

I don't know, but I suspect, behind the scenes, within isnumeric(), re is being used anyway.

Is there another, better way to find numbers?

Why not just use re explicitly? Then you can see exactly what is going on.

import re
things = [1.5, '2.5', 3.5, '4.5', 'a.bc', 'cde. do', 2, 7, '2.A', '2.2.', '2.A2', 1.56, 2.77, '3.33.33']
my_pattern = re.compile("\d+\.\d+")
for t in things:
    match_f = re.search(my_pattern, str(t))
    print(t, match_f)

And with the output of match_f.span() you can slice the number from a string!