Is there a builtin way to define a function that takes either 1 argument or 3?

Question

There's this error in Python when calling builtin type() with no arguments:

TypeError: type() takes 1 or 3 arguments

How can we define such a method? Is there a builtin way? Or we need to do something like this:

>>> def one_or_three(*args):
...   if len(args) not in [1,3]:
...     raise TypeError("one_or_three() takes 1 or 3 arguments")
... 
>>> one_or_three(1)
>>> one_or_three()
TypeError: one_or_three() takes 1 or 3 arguments
>>> one_or_three(1,2)
TypeError: one_or_three() takes 1 or 3 arguments

Answer 1

First, type is not native Python (at least in CPython), but C.

The inspect module can confirm it easily (even if documented as a builtin function, type is implemented as a class in CPython):

>>> print(inspect.signature(type.__init__))
(self, /, *args, **kwargs)
>>> print(sig.parameters['self'].kind)
POSITIONAL_ONLY

The parameter kind is POSITIONAL_ONLY, which cannot be created in Python.

That means that it will not be possible to reproduce exactly the behaviour of type.

Python source allows only 2 signatures for variable number of arguments:

• 3 parameters, 2 of them being optional:

  type(object_or_name, bases = None, dict = None)
  

  This would be very different, because it will accept gladly type(obj, None) which is definitely not what is expected here

• a simple *args parameter whose length will be tested by hand - your proposal. This will be much closer to native type behaviour, because it really requires 1 or 3 parameters, whatever the values.

TL/DR: the answer to your question is that we really need the something like that way.

Answer 2

This behavior is perfectly possible in Python.

def one_or_three(one, two=object(), three=object()):
    two_sentinel, three_sentinel = one_or_three.__defaults__
    if (two == two_sentinel) != (three == three_sentinel):
        raise TypeError("one_or_three() takes 1 or 3 arguments")
    ...

This has the benefits of named arguments (semantic value, passing in by name, etc) but is basically a variation on checking the values of some variables to know whether one or three things were passed.

Note that the two calls to object() produce two different objects and bind them to the function:

>>> one_or_three.__defaults__
(<object object at 0x00168540>, <object object at 0x00168ED0>)

This way, they are globally unique. If you instead used None as your sentinel object, then it wouldn't be possible to pass in None as an argument (though of course that may be desired).