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

Кто-нибудь знает, как сделать преобразование из строки в логическое значение в Python? Я нашел эту ссылку . Но это не похоже на правильный способ сделать это. Т.е. с использованием встроенного функционала и т. Д.

Я спрашиваю об этом потому, что узнал об этом int("string")отсюда. Но при попытке bool("string")всегда возвращается True:

>>> bool("False")
True

На самом деле, вы просто сравниваете строку с тем, что вы ожидаете принять как представляющее истину, так что вы можете сделать это:

s == 'True'

Или для проверки целой связки значений:

s.lower() in ['true', '1', 't', 'y', 'yes', 'yeah', 'yup', 'certainly', 'uh-huh']

Будьте осторожны при использовании следующего:

>>> bool("foo")
True
>>> bool("")
False

Пустые строки оценивают False, но все остальное оценивает True. Так что это не должно использоваться для каких-либо целей анализа.

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

bool(distutils.util.strtobool(some_string))

• Python 2 : http://docs.python.org/2/distutils/apiref.html?highlight=distutils.util#distutils.util.strtobool
• Python 3 : https://docs.python.org/3/distutils/apiref.html#distutils.util.strtobool

Истинными значениями являются y, да, t, true, on и 1; ложными значениями являются n, no, f, false, off и 0. Поднимает ValueError, если val - что-то еще.

Имейте в виду, что distutils.util.strtobool()возвращает целочисленные представления и, следовательно, его необходимо обернуть, bool()чтобы получить логические значения.

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

Обработка true и false явно:

Вы также можете сделать так, чтобы ваша функция явно проверяла список слов True и список слов False. Тогда, если его нет ни в одном списке, вы можете выдать исключение.

Парсер JSON также полезен для общего преобразования строк в приемлемые типы Python.

>>> import json
>>> json.loads("false".lower())
False
>>> json.loads("True".lower())
True

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

>>> импорт аст
>>> помощь (ast.literal_eval)
Справка по функции literal_eval в модуле ast:

literal_eval (node_or_string)
    Безопасно оценивать узел выражения или строку, содержащую Python
    выражение. Предоставленная строка или узел может состоять только из следующих
    Литеральные структуры Python: строки, числа, кортежи, списки, диктанты, логические значения,
    и нет.

Который , кажется, работает, до тех пор , пока вы уверены , что ваши строки будут либо "True"или "False":

>>> ast.literal_eval ("True")
Правда
>>> ast.literal_eval ("Ложь")
Ложь
>>> ast.literal_eval ("F")
Traceback (последний вызов был последним):
  Файл "", строка 1, в 
  Файл "/opt/Python-2.6.1/lib/python2.6/ast.py", строка 68, в literal_eval
    вернуть _convert (node_or_string)
  Файл "/opt/Python-2.6.1/lib/python2.6/ast.py", строка 67, в _convert
    поднять ValueError ('искаженная строка')
ValueError: неправильная строка
>>> ast.literal_eval ("Ложь")
'Ложь'

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

Если вы знаете, что строка будет либо, "True"либо "False", вы можете просто использовать eval(s).

>>> eval("True")
True
>>> eval("False")
False

Используйте это только в том случае, если вы уверены в содержимом строки, так как это вызовет исключение, если строка не содержит допустимого Python, а также выполнит код, содержащийся в строке.

Эта версия сохраняет семантику конструкторов, таких как int (value), и предоставляет простой способ определения допустимых строковых значений.

def to_bool(value):
    valid = {'true': True, 't': True, '1': True,
             'false': False, 'f': False, '0': False,
             }   

    if isinstance(value, bool):
        return value

    if not isinstance(value, basestring):
        raise ValueError('invalid literal for boolean. Not a string.')

    lower_value = value.lower()
    if lower_value in valid:
        return valid[lower_value]
    else:
        raise ValueError('invalid literal for boolean: "%s"' % value)


# Test cases
assert to_bool('true'), '"true" is True' 
assert to_bool('True'), '"True" is True' 
assert to_bool('TRue'), '"TRue" is True' 
assert to_bool('TRUE'), '"TRUE" is True' 
assert to_bool('T'), '"T" is True' 
assert to_bool('t'), '"t" is True' 
assert to_bool('1'), '"1" is True' 
assert to_bool(True), 'True is True' 
assert to_bool(u'true'), 'unicode "true" is True'

assert to_bool('false') is False, '"false" is False' 
assert to_bool('False') is False, '"False" is False' 
assert to_bool('FAlse') is False, '"FAlse" is False' 
assert to_bool('FALSE') is False, '"FALSE" is False' 
assert to_bool('F') is False, '"F" is False' 
assert to_bool('f') is False, '"f" is False' 
assert to_bool('0') is False, '"0" is False' 
assert to_bool(False) is False, 'False is False'
assert to_bool(u'false') is False, 'unicode "false" is False'

# Expect ValueError to be raised for invalid parameter...
try:
    to_bool('')
    to_bool(12)
    to_bool([])
    to_bool('yes')
    to_bool('FOObar')
except ValueError, e:
    pass

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

def to_bool(value):
    """
       Converts 'something' to boolean. Raises exception for invalid formats
           Possible True  values: 1, True, "1", "TRue", "yes", "y", "t"
           Possible False values: 0, False, None, [], {}, "", "0", "faLse", "no", "n", "f", 0.0, ...
    """
    if str(value).lower() in ("yes", "y", "true",  "t", "1"): return True
    if str(value).lower() in ("no",  "n", "false", "f", "0", "0.0", "", "none", "[]", "{}"): return False
    raise Exception('Invalid value for boolean conversion: ' + str(value))

Образцы прогонов:

>>> to_bool(True)
True
>>> to_bool("tRUe")
True
>>> to_bool("1")
True
>>> to_bool(1)
True
>>> to_bool(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 9, in to_bool
Exception: Invalid value for boolean conversion: 2
>>> to_bool([])
False
>>> to_bool({})
False
>>> to_bool(None)
False
>>> to_bool("Wasssaaaaa")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 9, in to_bool
Exception: Invalid value for boolean conversion: Wasssaaaaa
>>>

вы всегда можете сделать что-то вроде

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

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

Крутой, простой трюк (основанный на том, что написал @Alan Marchiori), но использующий yaml:

import yaml

parsed = yaml.load("true")
print bool(parsed)

Если оно слишком широкое, его можно уточнить, протестировав результат типа. Если возвращаемый yaml тип является str, то он не может быть приведен к какому-либо другому типу (о чем я могу думать в любом случае), так что вы можете обработать это отдельно или просто позволить ему быть верным.

Я не буду догадываться о скорости, но так как я все равно работаю с данными yaml в Qt gui, это имеет хорошую симметрию.

Я не согласен с каким-либо решением здесь, поскольку они слишком разрешительны. Обычно это не то, что вы хотите при разборе строки.

Итак, вот решение, которое я использую:

def to_bool(bool_str):
    """Parse the string and return the boolean value encoded or raise an exception"""
    if isinstance(bool_str, basestring) and bool_str: 
        if bool_str.lower() in ['true', 't', '1']: return True
        elif bool_str.lower() in ['false', 'f', '0']: return False

    #if here we couldn't parse it
    raise ValueError("%s is no recognized as a boolean value" % bool_str)

И результаты:

>>> [to_bool(v) for v in ['true','t','1','F','FALSE','0']]
[True, True, True, False, False, False]
>>> to_bool("")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 8, in to_bool
ValueError: '' is no recognized as a boolean value

Просто чтобы быть ясно, потому что, похоже, мой ответ кого-то как-то обидел

Дело в том, что вы не хотите проверять только одно значение, а другое принимаете. Я не думаю, что вы всегда хотите отобразить Абсолютно все на непарсированное значение. Это приводит к ошибочному коду.

Итак, если вы знаете, что вы хотите, закодируйте это в.

DICT (на самом деле, defaultdict) дает вам довольно простой способ сделать этот трюк:

from collections import defaultdict
bool_mapping = defaultdict(bool) # Will give you False for non-found values
for val in ['True', 'yes', ...]:
    bool_mapping[val] = True

print(bool_mapping['True']) # True
print(bool_mapping['kitten']) # False

Очень легко адаптировать этот метод к нужному поведению преобразования - вы можете заполнить его допустимыми значениями Truthy и Falsy и позволить ему вызвать исключение (или вернуть None), когда значение не найдено, или по умолчанию True, или по умолчанию False, или все, что вы хотите.

Возможно, у вас уже есть решение, но для тех, кто ищет метод для преобразования значения в логическое значение, используя «стандартные» ложные значения, включая 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

Вы можете просто использовать встроенную функцию eval () :

a='True'
if a is True:
    print 'a is True, a type is', type(a)
else:
    print "a isn't True, a type is", type(a)
b = eval(a)
if b is True:
    print 'b is True, b type is', type(b)
else:
    print "b isn't True, b type is", type(b)

и вывод:

a isn't True, a type is <type 'str'>
b is True, b type is <type 'bool'>

Еще один вариант

from ansible.module_utils.parsing.convert_bool import boolean
boolean('no')
# False
boolean('yEs')
# True
boolean('true')
# True

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

Обычное правило для отливки к 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)

Это версия, которую я написал. Объединяет несколько других решений в одно.

def to_bool(value):
    """
    Converts 'something' to boolean. Raises exception if it gets a string it doesn't handle.
    Case is ignored for strings. These string values are handled:
      True: 'True', "1", "TRue", "yes", "y", "t"
      False: "", "0", "faLse", "no", "n", "f"
    Non-string values are passed to bool.
    """
    if type(value) == type(''):
        if value.lower() in ("yes", "y", "true",  "t", "1"):
            return True
        if value.lower() in ("no",  "n", "false", "f", "0", ""):
            return False
        raise Exception('Invalid value for boolean conversion: ' + value)
    return bool(value)

Если он получает строку, он ожидает определенных значений, в противном случае возникает исключение. Если он не получает строку, просто дайте понять конструктору bool. Проверены эти случаи:

test_cases = [
    ('true', True),
    ('t', True),
    ('yes', True),
    ('y', True),
    ('1', True),
    ('false', False),
    ('f', False),
    ('no', False),
    ('n', False),
    ('0', False),
    ('', False),
    (1, True),
    (0, False),
    (1.0, True),
    (0.0, False),
    ([], False),
    ({}, False),
    ((), False),
    ([1], True),
    ({1:2}, True),
    ((1,), True),
    (None, False),
    (object(), True),
    ]

Если вы знаете, что ваш ввод будет «True» или «False», то почему бы не использовать:

def bool_convert(s):
    return s == "True"

я использую

# 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]]
"""

Мне нравится использовать троичный оператор для этого, поскольку он более лаконичен для того, что кажется, что оно не должно быть больше 1 строки.

True if myString=="True" else False

Я понимаю, что это старый пост, но некоторые решения требуют немного кода, вот что я в итоге использовал:

def str2bool(value):
    return {"True": True, "true": True}.get(value, False)

Используйте пакет str2bool pip install str2bool

Если я вам нравлюсь, просто нужно логическое значение из переменной, которая является строкой. Вы можете использовать дистилляции, как упоминалось ранее @jzwiener. Однако я не мог импортировать и использовать модуль, как он предложил.

Вместо этого я использую его таким образом на python3.7

from distutils import util # to handle str to bool conversion
enable_deletion = 'False'
enable_deletion = bool(util.strtobool(enable_deletion))

distutils является частью библиотеки python std, поэтому не требует установки. Что здорово! 👍

Я хотел бы поделиться своим простым решением: использовать eval(). Он преобразует строку Trueи Falseв правильный логический тип , если строка точно в формате заголовок TrueилиFalse всегда первая буква капитале или еще функции вызовет ошибку.

например

>>> eval('False')
False

>>> eval('True')
True

Конечно, для динамической переменной вы можете просто использовать .title()для форматирования логической строки.

>>> x = 'true'
>>> eval(x.title())
True

Это выдаст ошибку.

>>> eval('true')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'true' is not defined

>>> eval('false')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'false' is not defined

Вот волосатый, построенный таким образом, чтобы получить много одинаковых ответов. Обратите внимание, что хотя python считает ""false и все остальные строки верными, 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, false, noи offбыть ложными и 1, true, yesи , onчтобы быть правдой, чувствительны к регистру. Любая другая строка, включая пустую строку, вызывает исключение.

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

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

Вот что-то, что я бросил вместе, чтобы оценить истинность строки:

def as_bool(val):
 if val:
  try:
   if not int(val): val=False
  except: pass
  try:
   if val.lower()=="false": val=False
  except: pass
 return bool(val)

более-менее те же результаты, что и при использовании, evalно безопаснее.

Я просто должен был сделать это ... так что, возможно, опоздал на вечеринку - но кто-то может найти это полезным

def str_to_bool(input, default):
    """
    | Default | not_default_str | input   | result
    | T       |  "false"        | "true"  |  T
    | T       |  "false"        | "false" |  F
    | F       |  "true"         | "true"  |  T
    | F       |  "true"         | "false" |  F

    """
    if default:
        not_default_str = "false"
    else:
        not_default_str = "true"

    if input.lower() == not_default_str:
        return not default
    else:
        return default

Если у вас есть контроль над объектом, который возвращает true/ false, один из вариантов - вернуть его 1/ 0вместо true/ false, а затем:

boolean_response = bool(int(response))

Дополнительное приведение для intобработки ответов из сети, которые всегда являются строковыми.

Используя встроенную eval()функцию Python и.capitalize() метод , вы можете преобразовать любую строку «истина» / «ложь» (независимо от начальной заглавной буквы) в истинное логическое значение Python.

Например:

true_false = "trUE"
type(true_false)

# OUTPUT: <type 'str'>

true_false = eval(true_false.capitalize())
type(true_false)

# OUTPUT: <type 'bool'>