Hi Team,

I have observed a bug in re.groups() function behavior in Python as below:

Issue:
re.groups() is not validating the arguments

Example:
>>> m = re.match(r'(\w+)@(\w+)\.(\w+)','username@hackerrank.com')
>>> m.groups()
('username', 'hackerrank', 'com')
>>> m.groups(1)
('username', 'hackerrank', 'com')
>>> m.groups(100000000000)
('username', 'hackerrank', 'com')
>>>

From the above, its clear that re.groups() and re.groups(<somevalue>) both are same. I think re.groups() is not validating the arguments.

Please review the same and provide your comments whether my views are correct or wrong

All work as designed. In your example you don't see a difference because all groups are defined. Look at other example:

>>> import re
>>> m = re.match(r'(?:(\w+)@)?(\w+)\.(\w+)', 'hackerrank.com')
>>> m.groups()
(None, 'hackerrank', 'com')
>>> m.groups(1)
(1, 'hackerrank', 'com')
>>> m.groups(100000000000)
(100000000000, 'hackerrank', 'com')

Please look in to the following example:

>>> m.groups()
('narendra', 'happiestmidns', 'com')
>>> m.groups(1)
('narendra', 'happiestmidns', 'com')
>>> m.groups(34)
('narendra', 'happiestmidns', 'com')
>>> m.groups(10000000000000000000000000000000000000000000000000000000)
('narendra', 'happiestmidns', 'com')
>>>

There is nothing wrong with this output if you use the first example.

Hi Storchaka,

As per re.groups(), its should work as below:

groups([default])
Return a tuple containing all the subgroups of the match, from 1 up to however many groups are in the pattern. The default argument is used for groups that did not participate in the match; it defaults to None. (Incompatibility note: in the original Python 1.5 release, if the tuple was one element long, a string would be returned instead. In later versions (from 1.5.1 on), a singleton tuple is returned in such cases.)

For example:

>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
('24', '1632')
If we make the decimal place and everything after it optional, not all groups might participate in the match. These groups will default to None unless the default argument is given:

>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
>>> m.groups()      # Second group defaults to None.
('24', None)
>>> m.groups('0')   # Now, the second group defaults to '0'.
('24', '0')

I tested some scenario as below:
Scenario: Suppose i have a match like 
m = re.match(r"(\d+)\.(\d+)", "24.1632")
Here if i pass m.groups(10000), then it should check if there is optional match (optional match, pattern which is specified using ?), it should print 10000 in that match and if not, it should throw error that there is no any optional match (didn't have any pattern with ?).

Expected Output:
>>> m.groups(10000)
There is no any optional argument to use 10000

Received Output:
>>> m.groups(10000)
'24', '1632')

Please review the above and provide your comments?

No, it should not throw error that there is no any optional match.

It is not easy to check if there is optional match. For example, the pattern '(a)|(b)' contains optional matches, while the group in the pattern '()?' always matches.

@Narendra: The argument, if provided, is merely a default. Checking whether it _could_ be used would not be straightforward, and raising an exception if it would never be used would have little, if any, benefit.

It's not a bug, and it's not worth changing.