Преобразование из строки в логическое значение в Python?

Вы могли всегда делать что-то как

myString = "false"
val = (myString == "true")

бит в parens оценил бы ко Лжи. Это - просто другой способ сделать это, не имея необходимость делать фактический вызов функции.

def str2bool(v):
  return v.lower() in ("yes", "true", "t", "1")

Затем назовите его как так:

>>> str2bool("yes")
True
>>> str2bool("no")
False
>>> str2bool("stuff")
False
>>> str2bool("1")
True
>>> str2bool("0")
False

Обработка истины и лжи явно:

Вы могли также заставить свою функцию явно проверить по Истинному списку слов и Ложному списку слов. Затем, если это не находится ни в каком списке, Вы могли бы выдать исключение.

Я использую

# function
def toBool(x):
    return x in ("True","true",True)

# test cases
[[x, toBool(x)] for x in [True,"True","true",False,"False","false",None,1,0,-1,123]]
"""
Result:
[[True, True],
 ['True', True],
 ['true', True],
 [False, False],
 ['False', False],
 ['false', False],
 [None, False],
 [1, True],
 [0, False],
 [-1, False],
 [123, False]]
"""

Начиная с Python 2.6, теперь есть ast.literal_eval :

>>> import ast
>>> help(ast.literal_eval)
Help on function literal_eval in module ast:

literal_eval(node_or_string)
    Safely evaluate an expression node or a string containing a Python
    expression.  The string or node provided may only consist of the following
    Python literal structures: strings, numbers, tuples, lists, dicts, booleans,
    and None.

Что, похоже, работает, если вы уверены в своем строки будут либо "True" , либо "False" :

>>> ast.literal_eval("True")
True
>>> ast.literal_eval("False")
False
>>> ast.literal_eval("F")
Traceback (most recent call last):
  File "", line 1, in 
  File "/opt/Python-2.6.1/lib/python2.6/ast.py", line 68, in literal_eval
    return _convert(node_or_string)
  File "/opt/Python-2.6.1/lib/python2.6/ast.py", line 67, in _convert
    raise ValueError('malformed string')
ValueError: malformed string
>>> ast.literal_eval("'False'")
'False'

Обычно я бы не рекомендовал это, но он полностью встроен и может быть правильным в зависимости от ваших требований.

вот волосатый, созданный таким образом, чтобы получить многие из тех же ответов. Обратите внимание, что хотя python считает "" ложным, а все остальные строки - истинными, TCL имеет совсем другое представление о вещах.

>>> import Tkinter
>>> tk = Tkinter.Tk()
>>> var = Tkinter.BooleanVar(tk)
>>> var.set("false")
>>> var.get()
False
>>> var.set("1")
>>> var.get()
True
>>> var.set("[exec 'rm -r /']")
>>> var.get()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.5/lib-tk/Tkinter.py", line 324, in get
    return self._tk.getboolean(self._tk.globalgetvar(self._name))
_tkinter.TclError: 0expected boolean value but got "[exec 'rm -r /']"
>>> 

Это хорошо то, что он достаточно снисходителен к значениям, которые вы можете использовать. Ему лениво превращать строки в значения, и он гигиеничен в отношении того, что он принимает, а что отклоняет (обратите внимание, что если бы вышеприведенный оператор был введен в приглашении tcl, он стер жесткий диск пользователя).

Плохо то, что для этого требуется, чтобы был доступен Tkinter, что обычно, но не всегда верно, и, что более важно, требует создания экземпляра Tk, что относительно тяжело.

Что считать истинным или ложным, зависит от поведения Tcl_GetBoolean , который считает 0 , ложным , нет и выкл. ложными и 1 , истинным , да и на , чтобы быть правдой, без учета регистра. Любая другая строка, включая пустую, вызывает исключение.

Обычное правило приведения к типу bool - несколько специальных литералов ( False , 0 , 0.0 , () , [], {} ) неверны, а все остальное верно, поэтому я рекомендую следующее:

def boolify(val):
    if (isinstance(val, basestring) and bool(val)):
        return not val in ('False', '0', '0.0')
    else:
        return bool(val)

Для простых приложений и внутренних помощников я бы использовал статический метод. Для приложений с компонентами мне нравится Managed Extensiability Framework . Вот отрывок из документа, который я пишу, чтобы описать узоры, которые вы найдете в моих API.

• Услуги
  • Определяется интерфейсом службы I [ServiceName] .
  • Экспортировано и импортировано типом интерфейса.
  • Единая реализация обеспечивается серверным приложением и потребляется внутренними и/или внутренними расширениями.
  • Методы на сервисном интерфейсе безопасны для потоков.

В качестве надуманного примера:

public interface ISettingsService
{
    string ReadSetting(string name);

    void WriteSetting(string name, string value);
}

[Export]
public class ObjectRequiringSettings
{
    [Import]
    private ISettingsService SettingsService
    {
        get;
        set;
    }

    private void Foo()
    {
        if (SettingsService.ReadSetting("PerformFooAction") == bool.TrueString)
        {
            // whatever
        }
    }
}

Поскольку все остальные уже дали ответ, я добавлю немного дополнительного контекста.% оператор «модуль» фактически делать оставшуюся операцию. Разница между мод и рем тонкая, но важная.

(-1 mod 2) обычно дает 1. Более конкретно, учитывая два целых числа, X и Y, операция (X mod Y) имеет тенденцию возвращать значение в диапазоне [0, Y). Иначе говоря, модуль X и Y всегда больше или равен нулю и меньше Y.

Выполнение одной и той же операции с оператором «%» или rem сохраняет знак значения X. Если X отрицательный, получается результат в диапазоне (-Y, 0]. Если X положителен, получается результат в диапазоне [0, Y).

Часто это тонкое различие не имеет значения. Однако, возвращаясь к вашему кодовому вопросу, есть несколько способов решения для «равномерности».

Первый подход хорош для начинающих, потому что он особенно многословен.

// Option 1: Clearest way for beginners
boolean isEven;
if ((a % 2) == 0)
{
  isEven = true
}
else
{
  isEven = false
}

Второй подход лучше использует преимущества языка и приводит к более сжатому коду. (Не забывайте, что оператор = = возвращает логическое значение.)

// Option 2: Clear, succinct, code
boolean isEven = ((a % 2) == 0);

Третий подход здесь для полноты и использует оператор ternary . Хотя троичный оператор часто очень полезен, в данном случае считаю второй подход превосходящим.

// Option 3: Ternary operator
boolean isEven = ((a % 2) == 0) ? true : false;

Четвертый и последний подход заключается в использовании знаний о двоичном представлении целых чисел . Если младший значащий бит равен 0, то число равно четному. Это можно проверить с помощью оператора bitwise-and (&). Хотя этот подход является самым быстрым (вы делаете простую битовую маскировку вместо деления), он, возможно, немного продвинутый/сложный для новичка.

// Option 4: Bitwise-and
boolean isEven = ((a & 1) == 0);

Здесь я использовал оператор bitwise-and и представил его в сжатой форме, показанной в опции 2. Переписывание его в форме Варианта 1 (и в качестве альтернативы Варианта 3) оставлено как упражнение читателю.;)

Надежда, которая поможет.

Возможно, у вас уже есть решение, но для других, которые ищут метод преобразования значения в логическое значение с использованием «стандартных» ложных значений, включая None, [], {} и «» в дополнение к false, no и 0.

def toBoolean( val ):
    """ 
    Get the boolean value of the provided input.

        If the value is a boolean return the value.
        Otherwise check to see if the value is in 
        ["false", "f", "no", "n", "none", "0", "[]", "{}", "" ]
        and returns True if value is not in the list
    """

    if val is True or val is False:
        return val

    falseItems = ["false", "f", "no", "n", "none", "0", "[]", "{}", "" ]

    return not str( val ).strip().lower() in falseItems

def str2bool(str):
  if isinstance(str, basestring) and str.lower() in ['0','false','no']:
    return False
  else:
    return bool(str)

идея: проверьте, хотите ли вы, чтобы строка оценивалась как False; в противном случае bool () возвращает True для любой непустой строки.