Python: My regular expression doesn't match on some string cases - regex

Question

I try to creating a regular expression and so far I made this code:
(-?['0|1']{1}.[00000000e+00| ]?){1}\s(-?['0|1']{1}.[00000000e+00| ]?){1}
My goal is to detect pattern that ({string pattern}{blank}{string pattern}).
This is my string pattern:
'0'
'-0.'
'1.'
'-1.'
'1.00000000e+00'
'0.00000000e+00'
'-0.00000000e+00'
'-1.00000000e+00'
'0. ' (The blanks can be at least 1 to 8 characters long.)
'-0. ' (The blanks can be at least 1 to 8 characters long.)
'1. ' (The blanks can be at least 1 to 8 characters long.)
'-1. ' (The blanks can be at least 1 to 8 characters long.)
My code is mostly successful in test cases, but problems occur in some test cases.
(e.g. error occurred with '00000000e+00' or ' ')
Especially, it is too difficult for me because there can be at least 1 to 8 blank(' ') characters.
This is my test case:
['0. 0.']
['0. 1.']
['1. 0.']
['1. 1.']
['-0. -0.']
['-0. 0.']
['0. -0.']
['1. -0.']
['1. -1.']
['-1. 1.']
['-1. -1.']
['-1.00000000e+00 0.'] # Fail
['0. -1. '] # Fail
['0. 0. '] # Fail
['-0.00000000e+00 1.00000000e+00'] # Fail
['-0. 1.00000000e+00'] # Fail
Please give me some advice.

Answer 1

You could use
(-?[01]\.(?:00000000e\+00| {1,8})?)\s(-?[01]\.(?:00000000e\+00| {1,8})?)
The pattern matches:
( Capture group 1
-?[01]\. Match an optional - either 0 or 1 and a . (note to escape the dot)
(?: Non capture group for the alternation |
00000000e\+00| {1,8} Match either 00000000e+00 or 1-8 spaces
)? Close non capture group and make it optional
) Close group 1
\s Match a single whitespace char
(-?[01]\.(?:00000000e\+00| {1,8})?) Capture group 2, the same pattern as capture group 1
Regex demo
Note that \s could also match a newline, and if you want the match only you can omit the capture groups.
There is no language tagged, but if supported you might shorten the pattern recursing the first sub pattern as the pattern uses the same part twice.
(-?[01]\.(?:0{8}e\+00| {1,8})?)\s(?1)
Regex demo

Answer 2

Would you please try the following:
import re
l = ['0. 0.',
'0. 1.',
'1. 0.',
'1. 1.',
'-0. -0.',
'-0. 0.',
'0. -0.',
'1. -0.',
'1. -1.',
'-1. 1.',
'-1. -1.',
'-1.00000000e+00 0.',
'0. -1. ',
'0. 0. ',
'-0.00000000e+00 1.00000000e+00',
'-0. 1.00000000e+00']
for s in l:
if re.match(r'-?[0|1]\.?(?:0{8}e\+00|\s{1,8})?\s-?[0|1]\.?(?:0{8}e\+00|\s{1,8})?$', s):
print("match")
else:
print("no match")
Explanation of regex -?[0|1]\.?(?:0{8}e\+00|\s{1,8})?:
-? matches a dash character of length 0 or 1
[0|1]\.? matches 0 or 1 followed by an optional dot character
0{8}e\+00 matches a substring 00000000e+00
\s{1,8} matches whitespaces of length between 1 and 8
(?:0{8}e\+00|\s{1,8})? matches either or none of two regexes above

Answer 3

Apparently you have two false impressions.
You seem to think of [ ] as a group construct while it denotes a character class.
You seem to think you'd have to include the string delimiting quotes in the pattern.
Since one could interpret your question to the effect that you want to test for two numbers of -1, 0 or 1, and others already gave regex answers, here's a regex-free alternative for that problem:
test = ['0. 0.', '0. 1.', '1. 0.', '1. 1.', '-0. -0.', '-0. 0.', '0. -0.', '1. -0.',
'1. -1.', '-1. 1.', '-1. -1.', '-1.00000000e+00 0.', '0. -1. ', '0. 0. ',
'-0.00000000e+00 1.00000000e+00', '-0. 1.00000000e+00', 'x y', '-1 0 1']
for t in test:
print([t], end='\t')
s = t.split()
try:
if len(s) != 2: raise ValueError
for f in s:
g = float(f)
if g!=-1 and g!=0 and g!=1: raise ValueError
except ValueError:
print('Fail')
else:
print('Pass')