Булевы имеют два возможных значения. Существуют ли типы, которые имеют три возможных значения?

Ответ 1

В Python я бы сделал это с объектом-оболочкой, который содержит одно из этих трех значений; Я использовал бы True, False и None. Поскольку значение неявной правдивости объекта с булевым значением с тремя возможными значениями проблематично, мы разрешим это, полностью отказавшись от этого (создание исключения в __nonzero__() или в Python 3, __bool__()), что требует, чтобы сравнения всегда выполняться явно, используя in, == или !=. Мы будем применять равенство как идентификатор, чтобы были сопоставлены только конкретные значения одноэлементности True, False и None.

class Tristate(object):

    def __init__(self, value=None):
       if any(value is v for v in (True, False, None)):
          self.value = value
       else:
           raise ValueError("Tristate value must be True, False, or None")

    def __eq__(self, other):
       return (self.value is other.value if isinstance(other, Tristate)
               else self.value is other)

    def __ne__(self, other):
       return not self == other

    def __nonzero__(self):   # Python 3: __bool__()
       raise TypeError("Tristate object may not be used as a Boolean")

    def __str__(self):
        return str(self.value)

    def __repr__(self):
        return "Tristate(%s)" % self.value

Использование:

t = Tristate(True)
t == True           # True
t != False          # True
t in (True, False)  # True
bool(t)             # Exception!
if t: print "woo"   # Exception!

При использовании объектов Tristate вы должны явно указать, какие значения будут соответствовать, т.е. foo == True or bar != None. Вы также можете сделать foo in (False, None) для соответствия нескольким значениям (хотя, конечно, in два значения противоположны != с одним значением). Если есть другие логические операции, которые вы хотите выполнить с этими объектами, вы можете реализовать их как методы или, возможно, переопределить некоторые операторы (к сожалению, логические not, and и or не являются overrideable, хотя предложение, чтобы добавить это).

Также обратите внимание, что вы не можете переопределить id() в Python, так, например, Tristate(None) is None - False; два объекта на самом деле разные. Поскольку хороший стиль Python заключается в использовании is при сравнении с одиночными играми, это несчастливо, но неизбежно.

Редактировать 4/27/16: Добавлена ​​поддержка сравнения одного объекта Tristate с другим.

Ответ 2

Это называется Тернарная логика или Трехзначная логика. Как и другие ответы, вы можете либо реализовать класс:

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

Я сам, вероятно, поеду для вашего решения (True, False, None), но я понимаю вашу озабоченность.

Ответ 3

Параллель с проблемой None существует с false = 0, true = 1, unknown = 2 (неизвестно тоже не истинно), но будет eval для True, если вы не будете осторожны).

Я придумал хакерский способ получить то, что по крайней мере приближается к тому, что вы хотите, я думаю. Это, по крайней мере, даст вам то, что будет оцениваться триниально в if/else и других булевых вариантах eval.

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)

Использование:

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'

Вы можете сделать "Да", "Нет" и "Неизвестные псевдо-синглтоны", которые позволили бы вам немного улучшить оценку. Вы все равно можете сделать простые, если вы проверите, когда знаете, что ваше значение будет да или нет, но если вы попытаетесь сделать прямое bool() (т.е. если x) в Unknown, вы получите TypeError. Это сделало бы ваш код более явным, так как каждый раз, когда вы проверяли значение типа trinary, вам нужно было бы определить в своем коде, как вы хотите, чтобы неизвестный обрабатывался в контексте этого условного, так что это было бы плюсом.

Изменить: Я подумал об альтернативе, которая потребует меньше специальной обработки, но менее гибкой. Выполните следующее:

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))

Использование:

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'

Это имеет преимущество, позволяя отличным от нуля работать в качестве спецификаций в Unknown, но имеет недостаток в том, что для экземпляра "Неизвестно", установленного в камне, существует свойство eval, и больше не позволяет Unknown быть псевдо-синглетом.

Ответ 4

Он обычно известен как "enum", после конструкции C этого имени.

Вы можете легко создать свой собственный класс, объекты которого должны быть инициализированы значениями из набора, и вы можете соответствующим образом создать соответствующие функции сравнения, равенства и правды.

Ответ 5

• По крайней мере, на одном языке это: C#: int? num = null;, теперь num на самом деле Nullable<Int32> (вопросительный знак является "синтаксическим сахаром" ) см. http://msdn.microsoft.com/en-us/library/1t3y8s4s%28v=vs.80%29.aspx и http://en.wikipedia.org/wiki/Nullable_type
• Не знаю Python, но это зависит от ваших предпочтений: юзабилити (enum или class) против эффективности (4-битные поля)

Ответ 6

У меня есть 3-значный логический класс в моем dbf-модуле.

Он реализует False/True/Unknown как одиночные значения Falsth/Truth/Unknown. Он реализует все операторы сравнения, а также позволяет сравнивать с синглонами Python False/True/None (None, принятыми как неизвестные). Любое сравнение с значением Unknown приводит к Unknown, и попытка неявно использовать значение Unknown в операторе if (или в другом контексте bool) приведет к повышению TypeError, хотя Truth и Falsth можно использовать в булевых контекстах, а Unknown можно сравнивать напрямую.

Поскольку невозможно переопределить поведение and, or и not, тип переопределяет побитовые операторы &, | и ~.

Он также реализует __index__ с Unknown, имеющим значение 2.

Пример:

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."

Ответ 7

Нет таких встроенных типов. И перечисление также не поддерживается как тип. Однако вы можете использовать константу как:

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

reply = Option.YES

Ответ 8

Я не очень люблю программирование на Python, но вы можете вернуть None в случае Do not Know. Вызывающий должен будет проверить "Да", "Нет" или "Нет", но по крайней мере они будут знать, что вы не знаете.

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

Ответ 9

Я никогда не видел тип, похожий на boolean, который имел более двух значений. Ведь "логическое" означает, что функция работает над "булевым доменом", которая, в свою очередь, имеет ровно 2 значения.

Тем не менее, вполне нормально использовать целые числа, перечисления или даже строки. В python вы можете создать модуль, содержащий только переменные YES, NO, MAYBE и импортировать оттуда в любое другое место.