Custom placeholder like None in python

Question

I'm using argspec in a function that takes another function or method as the argument, and returns a tuple like this:

(("arg1", obj1), ("arg2", obj2), ...)

This means that the first argument to the passed function is arg1 and it has a default value of obj1, and so on.

Here's the rub: if it has no default value, I need a placeholder value to signify this. I can't use None, because then I can't distinguish between no default value and default value is None. Same for False, 0, -1, etc. I could make it a tuple with a single element, but then the code for checking it would be ugly, and I can't easily turn it into a dict. So I thought I'd create a None-like object that isn't None, and this is what I've come up with:

class MetaNoDefault(type):
    def __repr__(cls):
        return cls.__name__
    __str__ = __repr__

class NoDefault(object):
    __metaclass__ = MetaNoDefault

Now ("arg1", NoDefault) indicates arg1 has no default value, and I can do things like if obj1 is NoDefault: etc. The metaclass makes it print as just NoDefault instead of <class '__main__.NoDefault'>.

Is there any reason not to do it like this? Is there a better solution?

Is there any reason why you can not have tuple of just one element for no defaults? Something like: `(("arg1",), ("arg2", obj2), ...)` where "arg1" has no default. You can then do if `len(the_tuple) == 1` etc. — Fenikso, May 31 '11 at 10:05
@FMc: In order to avoid mistakes coming from the accidental modification of the default arguments, it is better to never use mutable defaults. — lunaryorn, May 31 '11 at 10:07
@Fenikso I've covered this possibility in my question. In short, I find it inelegant, even though it _is_ intuitive. — Lauritz V. Thaulow, May 31 '11 at 10:21

score 6 · Accepted Answer · edited May 23 '17 at 12:18

6

My favourite sentinel is Ellipsis, and if I may quote myself:

it's there, it's an object, it's a singleton, and its name means "lack of", and it's not the overused None (which could be put in a queue as part of normal data flow). YMMV.

edited May 23 '17 at 12:18

Community

1
1

answered May 31 '11 at 10:50

tzot

87,612
28
135
198

1

However, it's disappearing in Python 3. :-o – Keith May 31 '11 at 11:36
4

@Keith: citation, please. AFAIK in Python 3 you can even say `a = ...` (i.e. the `...` syntax can be used outside of slices), so I have the impression that it's not disappearing. – tzot May 31 '11 at 12:26
It seems I could quote myself from [even earlier](http://mail.python.org/pipermail/python-list/2004-August/273139.html) :) – tzot May 31 '11 at 14:30
1

@Keith: `Ellipsis` is still present in Python 3. Just read the documentation for proof. – lunaryorn May 31 '11 at 14:39
I could have swore I read that somewhere... but I guess not. I should stop writing here in the middle of the night when I'm tired. – Keith May 31 '11 at 16:32
This is what I ended up using, along with a comment explaining its purpose. – Lauritz V. Thaulow Jun 01 '11 at 15:08

score 5 · Answer 2 · answered May 31 '11 at 10:25

I had a similar situation some time ago. Here's what I came up with.

# Works like None, but is also a no-op callable and empty iterable.
class NULLType(type):
    def __new__(cls, name, bases, dct):
        return type.__new__(cls, name, bases, dct)
    def __init__(cls, name, bases, dct):
        super(NULLType, cls).__init__(name, bases, dct)
    def __str__(self):
        return ""
    def __repr__(self):
        return "NULL"
    def __nonzero__(self):
        return False
    def __len__(self):
        return 0
    def __call__(self, *args, **kwargs):
        return None
    def __contains__(self, item):
        return False
    def __iter__(self):
        return self
    def next(*args):
        raise StopIteration
NULL = NULLType("NULL", (type,), {})

It can also act as a null callable and sequence.

score 4 · Answer 3 · answered May 31 '11 at 10:15

There isn't any reason to not use such sentinel objects for such purposes. As an alternative to a class object, you could also create a singleton instance of a dynamically created type:

NoDefault = type('NoDefault', (object,), {
    '__str__': lambda s: 'NoDefault', '__repr__': lambda s: 'NoDefault'})()

Custom placeholder like None in python

3 Answers3

Linked