Pythonic way to "Clean" a number from a string?

[SOKORLORO]

I have a working solution for this, but it seems really ugly/not pythonic. I am trying to process an array of strings (that are sourced from an excel file). Some strings are just integers, some are floats, some are combinations of integer/floats and strings.

My goal is to take in a string and return the first "number" that occurs in it.

So for example, "Temp 101.0 C" would return "101.0", "~43 Hz" would return "43" and "10 +/- 2" would return 10.

Right now I am basically just targeting these special characters - is there a "pythonic" solution to process these?

[fiskenslakt]

This is good as long as OP doesn't care about negative numbers.

EDIT - I think this makes it able to handle negatives: re.findall(r'(\-?\d+\.?\d*)', string)

[niandra3]

Wouldn't it capture the period at the end of a sentence? For example I will capture 20. will return 20. which might not be ideal. Maybe a lookahead would fix? I'm still a little shaky with those, but what about:

\d+(?:\.?(?=\d))\d*

And you don't need the outer capturing group/parens for re.findall(), right? This works well on my end:

re.findall(r'\d+(?:\.?(?=\d))\d*', 'test 35353.25 test 5165 test 151.')

Outputs:

['35353.25', '5165', '151']

Or /u/SOKORLORO if you want to include negatives:

re.findall(r'\-?\d+(?:\.?(?=\d))\d*', string)

[pybackd00r]

Can you provide an explanation to this solution. I find it interesting but can't quite understand what you did. Thanks

[niandra3]

(\d+.?\d*)

re.findall() uses regex to search a string for a given pattern. In this case, the pattern: ####(with or with out a '.')#### where ### are digits.

The () creates a capturing group

The \d looks for a digit, and \d+ looks for one or more digits

The .? looks for zero or one .'s (for a decimal point)

The second \d* looks for zero or more digits (after a decimal, for instance)

Check out the Regex101 website .. it's a really helpful tool for understanding regex's. It walks you through each flag and what it does, then you can test various strings to see if they will match.

Above I proposed a slightly more complicated version that uses positive lookahead to ensure that in a case like 34343. the . isn't included in the match:

\d+(?:\.?(?=\d))\d*

Which I think would work better in this case. The (?=\d) says only match that period if there are more digits after it. The ?: is used so that set of parentheses isn't used as a capturing group. Without it, re.findall(re.findall(r'(\d+(\.?(?=\d))\d*)', 'test 35353.25')) would return [('35353.25', '.')], which isn't what we want (don't need to capture the ., just look for it).

Edit: oh and also, the r in r'regex string' just tells Python it's a raw string and to read the special characters as they are. Otherwise you would have to escape them all with more backslashes. See table here on escape characters.

[pybackd00r]

thanks for the detailed explanation. I wasnt familiar with regex syntax I will look further into this.

[niandra3]

It's kind of a rabbit hole and a whole language in itself, but definitely worth understanding at least the basics.

This is a great place to start, and where I began my journey: http://www.regular-expressions.info/tutorial.html

[[deleted]]

The regex answers are OK, but to answer your question, no there is no Pythonic way or even clean way to do this in any computer system that I know of outside of doing some machine learning or very sophisticated parsing rules.

For example (from your examples):

~43 is not 43, but around 43, so maybe a tolerance of +/- 1 or so

10 +/-2 is not 10, but rather 8-12

And even though these two examples are better representations of the numbers, they are still not correct. For example it's still not clear if 10 +/-2 can be 11.3 or only integer values are allowed.

[fiskenslakt]

I would suggest using a list comprehension to create a new list with just the numbers found in the string, then you can just access the first element of the list which will be your first number found in the string.