Booleans have two possible values. Are there types that have three possible values?

It’s generally known as an ‘enum’, after the C construct of that name.

You can easily create your own class, objects of which must be initialised with values from a set, and you can create the appropriate comparison, equality, and truth functions accordingly.

There is no such built-in types. And enum are also not supported as a type. However, you can use constant as:

class Option:
    NO = 0
    DONT_KNOW = 1
    YES = 2

reply = Option.YES

I am not much of a Python programming but could you return None in the Don’t Know case. The caller would have to check for “Yes”, “No” or None but atleast they would know that you don’t know.

http://boodebr.org/main/python/tourist/none-empty-nothing

This is called Ternary logic or Three-valued Logic. As other answers suggest, you could either implement a class:

class Ternary:
    FALSE = 0
    TRUE = 1
    UNKNOWN = 2

Myself, I would probably go for your solution (True, False, None) but I understand your concern.

I never saw a type similar to boolean which had more than two values. After all “boolean” means that the function operates over “Boolean domain”, which in turn has exactly 2 values.

That said, it is perfectly ok to use integers, enums, or even strings. In python you can create a module containing just variables YES, NO, MAYBE and import from there to every other place.

1. At least one language has this: C#: int? num = null;, now num is actually Nullable<Int32> (the question mark is a “syntactic sugar”)
   see: http://msdn.microsoft.com/en-us/library/1t3y8s4s%28v=vs.80%29.aspx and http://en.wikipedia.org/wiki/Nullable_type
2. Don’t know Python, but it depends on your preference: usability (enum or class) vs. efficiency (4 bit fields)

The parallel to the None problem exists with false = 0, true = 1, unknown = 2 (unknown is not actually true either, but will eval to True if you aren’t careful).

I came up with a hackish way to get something that at least approximates what you want, I think. It will at least get you something that will evaluate in a trinary fashion in if/else and other boolean eval instances.

class Yes(object):
    def __nonzero__(self):
        return True

class No(object):
    def __nonzero__(self):
        return False

class Unknown(object):
    def __nonzero__(self):
        raise ValueError('Unknown typed values do not evaluate to True/False.  Try using Ternary.eval().')

class Ternary(object):
    def __init__(self, yes, no, unknown):
        setattr(self, yes, Yes())
        setattr(self, no, No())
        setattr(self, unknown, Unknown())
    @staticmethod
    def eval(value, unknown_eval):
        if isinstance(value, Unknown):
            return unknown_eval
        return bool(value)

Usage:

t = Ternary('yes', 'no', 'unknown')
# Do stuff to assign ternary value to x
if Ternary.eval(x, True):
    print 'x is yes or unknown'
if Ternary.eval(x, False):
    print 'x is yes only'

You could make Yes, No, and Unknown pseudo-singletons which would let you refine eval a little bit. You could still do simple if checks when you know that your value is going to be yes or no, but if you tried to do a straight bool() (ie if x) on Unknown you’d get a TypeError. This would make your code more explicit though, as every time you checked a value of the trinary type, you’d have to define in your code how you wanted unknown to be treated in the context of that conditional, so that would be a plus.

Edit:
I thought of an alternative that would require less special handling but less flexible. Alter above thusly:

class Unknown(object):
    def __init__(self, eval):
        self._eval = eval
    def __nonzero__(self):
        return self._eval

class Ternary(object):
    def __init__(self, yes, no, unknown, unknown_eval):
        setattr(self, yes, Yes())
        setattr(self, no, No())
        setattr(self, unknown, Unknown(unknown_eval))

Usage:

t1 = Ternary('yes', 'no', 'unknown', True)
t2 = Ternary('yes', 'no', 'unknown', False)
# Do stuff to assign ternary values to x1 and x2
if x1:
    print 'x is yes or unknown'
if x2:
    print 'x is yes only'

This has the benefit of allowing nonzero to work as spec calls for in Unknown, but it has the downside of having the eval for Unknown set in stone from instantiation and of no longer allowing Unknown to be a pseudo-singleton.

I have a 3-valued Logical class in my dbf module.

It implements False/True/Unknown as singleton values Falsth/Truth/Unknown. It implements all the comparison operators, and also allows comparison with the Python singletons False/True/None (None taken to mean unknown). Any comparison with an Unknown value results in Unknown, and an attempt to implicitly use an Unknown value in an if statement (or other bool context) will raise a TypeError, although Truth and Falsth can be used in boolean contexts, and Unknown can be compared against directly.

Because it is not possible to override the and, or, and not behavior the type overrides the bitwise operators &, |, and ~.

It also implements __index__ with Unknown having the value of 2.

Example:

from dbf import Logical, Truth, Falsth, Unknown

middle_name = raw_input("What is the middle name? ['?' if unknown] ").strip()
if middle_name == '?':
    middle_name = ''
    middle_exists = Unknown
elif middle_name:
    middle_exists = Truth
else:
    middle_exists = Falsth
.
.
.
if middle_exists is Unknown:
    print "The middle name is unknown."
elif middle_exists:
    print "The middle name is %s." % middle_name
else:
    print "This person does not have a middle name."