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

746

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

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

>>> bool("False")
True
Джоан Венге
источник
2
Я создал для этого микробиблиотеку, в которую также были включены некоторые иностранные слова, например, «tak» для польского, «是 的» на китайском языке означает « Истина» . Если явно не true-ish будет оцениваться как False . Предложения приветствуются. Ссылка на Github: github.com/kmonsoor/str2bool
kmonsoor
18
Вместо того, чтобы заново изобретать колесо и писать кучу кода, который вам нужен для культа, в ответе @ jzwiener используется функция из стандартной библиотеки pythondistutils.util.strtobool(some_string) . Технически, выводом является тип intсо значением 0или 1-> если вы действительно хотите / нуждаетесь, boolвы можете обернуть эту функцию с помощью bool(distutils.util.strtobool(some_string)).
Тревор Бойд Смит
1
pip install str2bool
Symon
Просто один на один. distutils.util.strtoboolне может обрабатывать иностранные да / нет, в отличие от решения @kmonsoor, которое, однако, не может обрабатывать файлы CSV, созданные в Excel с True / False на иностранном языке (например VERO, FALSO). Таким образом, переосмысление колеса иногда требуется.
Маттео Ферла

Ответы:

839

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

s == 'True'

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

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

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

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

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

Кит Гоган
источник
48
+1: не намного проще s == "True". Но я видел, как люди из-за этого путаются. def convert (s): if s == "True": return True; вернуть Ложь.
S.Lott
24
Я предпочитаю возвращать s == "True", а не if / else
Дана,
26
if s == "True": вернуть True elif s == "False": вернуть False else: вернуть рейз
неизвестно
9
Разбор строк для логических значений уже реализован в distutils.util.strtobool: stackoverflow.com/a/18472142/923599
jzwiener
9
Я знаю, что это ДЕЙСТВИТЕЛЬНО старая тема, но я хотел подтвердить, что я только что потратил 4 часа на отладку своего кода. Моя ошибка была в попытке бросить bool("False"). Это всегда приведёт к True.
Ев.
304

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

bool(distutils.util.strtobool(some_string))

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

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

jzwiener
источник
38
К сожалению, это возвращает 1/ 0не True/ False, поэтому вам нужно обернуть результат в bool (), чтобы получить реальное логическое значение:bool(distutils.util.strtobool(some_string))
Mariusz Jamro
2
Эта функция дразнит. Было бы идеально, если бы он обрабатывал целые числа и Noneи в str(None)качестве ввода.
MarkHu
20
Я очень предпочитаю это ответам с более высоким рейтингом ... это от stdlib и делает именно то, что требуется. Как правило, нет необходимости использовать фактическое boolвместо 1/ 0до тех пор, пока вы не делаете плохие вещи вроде if x == False... и если вы имеете дело с ints и Nones, то вам не нужна специальная функция, вы можете просто проверить их прямо if myint:илиif not maybe_none_var:
Anentropic
4
@Secator boolявляется подклассомint
Anentropic
2
Чтобы сохранить кому-нибудь поиск ошибок: импортируйте distutils и import distutils.util, чтобы это работало.
Эдвард Б.
267
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. Тогда, если его нет ни в одном списке, вы можете выдать исключение.

Брайан Р. Бонди
источник
29
небольшое улучшение может быть сделано с помощью str (v) .lower () вместо v.lower () . Тогда он может работать, даже если это не строка, например 1, 0
kmonsoor
RE: обрабатывая true / false в явном виде, вы также можете указать значение по умолчанию, если строка не соответствует, так же, как работают запросы командной строки true / false: Продолжить? (да / нет)
Джонус
114

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

>>> import json
>>> json.loads("false".lower())
False
>>> json.loads("True".lower())
True
Алан Марчиори
источник
31
Обратите внимание, что этот метод работает, только если он в нижнем регистре. Если это прописные буквы, вы не можете. Вы должны позвонить.lower()
CppLearner
107

Начиная с 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 ("Ложь")
'Ложь'

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

Джейкоб Габриэльсон
источник
1
Не уверен в общей применимости этого решения, но это очень приятно, в общем виде. +1!
SingleNegationElimination
3
Гааа, это ужасно! Опять же , вы же говорите , что не рекомендую его, и он делает ответ на вопрос аккуратно. Хорошая находка!
Ванесса Фиппс
4
К сожалению, он не обрабатывает этот случай >>> ast.literal_eval ('true') или ast.literal_eval ('TRUE') Повышает >>> Повышает ValueError ('неправильная строка') Исправление простое, хотя ast.literal_eval (to_test) .title ())
Бхушан
Не лучшее решение этого конкретного вопроса, но ... Вау, literal_eval чертовски полезен! Строка, чтобы перечислить, диктовать, т. Д.
travc
Работает ли на юникоде до? В моем представлении Django у меня есть входящее значение, которое я хочу изменить на булево, оно дает исключение для искаженной строки.
Прахар Мохан Шривастава
48

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

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

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

Жоэль Крото
источник
6
эта строка придет откуда-то. if eval(os.environ["LOL"]): #might never reach here. Might also charge your company's credit card.
nurettin
4
@nurettin, поэтому мой комментарий об использовании только, если вы уверены в содержании строки.
Жоэль Крото
17

Эта версия сохраняет семантику конструкторов, таких как 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
Майкл Ричмонд
источник
3
Nit: Ваш последний «контрольный пример» будет давать ошибку при первом вызове и не будет проверять остальные. Кроме того , это не будет ошибкой , если ошибка не поднимается.
Авгурар
12

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

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
>>>
Petrucio
источник
Кто-то может быть укушен этим: to_bool(["hello"])это должен быть совершенно корректный вызов, если []он поддерживается
Рафаэль Т
1
Возвращает «Исключение: недопустимое значение для логического преобразования: ['hello']», которое ожидается и задокументировано. По моему мнению, пустой список был явно ложным, но ['ложным' 'это явно не было ничего, поэтому я намеренно его исключил - это особенность, а не ошибка. Должно быть легко добавить поддержку для возврата true для непустых списков, если вы этого хотите.
Петруччо
1
уверен, что вы задокументировали это. Но в реальной жизни никто бы не позвонил to_bool([]). Вместо этого он будет делать что-то вроде этого: myList=someFunctionThatReturnAList`if (is_bool (myList)): ... ´, поэтому у каждого есть список, и он хочет знать, является ли этот список пустым или пустым.
Рафаэль Т
Почему бы не попробовать это: >>> def a2b (arg): ... default = bool (arg) ... если isinstance (arg, str): ... вернуть arg.lower () в ['true', ' t ',' yes ',' y ',' 1 '] ... else: ... вернуть значение по умолчанию
ThePracticalOne
5
Незначительный момент: вам, вероятно, следует предпочесть ValueError вместо простого исключения.
dshepherd
10

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

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

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

helloandre
источник
1
Что val = "false"делает строка в этом примере? Почему это там? Что это значит?
S.Lott
9
Я думаю, что это означает 42.
Geo
@ Geo: я согласен; но на какой вопрос ответило это утверждение?
S.Lott
это именно то, что я искал, оценивая поле ввода из файла и основываясь на результате, хранящем логическое значение. благодарю вас.
Джим
9

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

import yaml

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

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

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

Рейф
источник
1
yamlМодуль является библиотекой , третья сторона: PyYAML
Питер Вуд
8

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

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

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

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

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

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

estani
источник
2
Я думаю, что вы упускаете суть: смысл ответов состоял в том, чтобы продемонстрировать общий принцип, а не сказать человеку, который задал вопрос, как именно он должен это сделать. Человек, который задал вопрос изначально, задумался над тем, что на самом деле является простой проблемой.
Кит Гоган
8
@ Я не согласен. Дело в том, чтобы ответить на вопрос так, как он задан.
Эстани
1
Вопрос был в том, как преобразовать строку в логическое значение. На этот вопрос я ответил. Я понятия не имею, что считается допустимой логической строкой для исходного постера, и вы тоже. Вот почему важнее продемонстрировать общий принцип, чем дать автору полный ответ. Первоначальный плакат не нуждался в том, чтобы все было им прописано: все, что им было нужно, - это продемонстрировать общий принцип. От этого любой компетентный получит ваш ответ.
Кит Гоган
2
@dshepherd isinstance, чтобы убедиться, что я разбираю то, что я ожидаю. Я разбираю строки, поэтому метод car_race.lower (), который случайно возвращает '1', не должен возвращать true, он должен выдавать ValueError. Но этого может быть достаточно в других случаях.
Эстани
2
@CivFan интересный момент. Хотя я попробовал это, и это не читалось так хорошо (для меня). elifизбыточно из-за возвращаемого слова, но дает вам больше информации без необходимости поиска return. Но это только я, если есть нарушение стиля PEP, я бы изменил его. Без каких-либо других ограничений, мы всегда должны идти на удобочитаемость (и стандарты делают это). Спасибо за заголовки и интересный комментарий!
Эстани
7

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, или все, что вы хотите.

Nate
источник
5

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

Вы можете просто использовать встроенную функцию 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'>
lumartor
источник
1
Это работает только тогда, когда проверенные значения являются допустимыми Python. «true» и «false» вызовут исключение.
Гордон Бин
13
Кроме того, это действительно плохая привычка использовать 'eval' для анализа, потому что eval будет запускать произвольный код в строке. В некоторых ситуациях это может представлять огромное целое безопасности.
Кристофер Барбер
7
Это действительно плохой ответ. Оценка произвольного выражения для анализа логического значения НЕ является хорошим подходом.
Авгурар
5

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

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

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

Мацей Куча
источник
4

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

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

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),
    ]
Том Экберг
источник
Используйте strвместоtype('')
pppery
3

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

def bool_convert(s):
    return s == "True"
Дэниел ван Флаймен
источник
Вам на самом деле не нужно if s else Falseнемного. Подумай, как "False" == "True"уже вернется False.
Тейлор Эдмистон
Если вы не уверены, является ли ввод s строкой или уже логическим, вы можете добавить if type(s) is bool: return s.
КОНТУР
3

я использую

# 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]]
"""
MrHIDEn
источник
2

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

True if myString=="True" else False
Клейтон Рабенда
источник
1
Как это более кратко чем my_string == 'True'?
С. де Мело
2

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

def str2bool(value):
    return {"True": True, "true": True}.get(value, False)
Рон Э
источник
7
Это функционально эквивалентно и более сложно, чем: возвращаемое значение в ('True', 'true')
Кит Гоган
1

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

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

distutils строка для bool в питоне

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

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

Гунай Анач
источник
1

Я хотел бы поделиться своим простым решением: использовать 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
Рул
источник
0

Вот волосатый, построенный таким образом, чтобы получить много одинаковых ответов. Обратите внимание, что хотя 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чтобы быть правдой, чувствительны к регистру. Любая другая строка, включая пустую строку, вызывает исключение.

SingleNegationElimination
источник
0
def str2bool(str):
  if isinstance(str, basestring) and str.lower() in ['0','false','no']:
    return False
  else:
    return bool(str)

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

XVGA
источник
0

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

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но безопаснее.

tylerl
источник
0

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

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
Rcynic
источник
0

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

boolean_response = bool(int(response))

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

Сэм Малаек
источник
-5

Используя встроенную 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'>
elPastor
источник
4
Что происходит, если строка содержит #\nshutil.rmtree('/someImportantDirectory')? (Не пытайтесь!)
мастов
@mastov - смешное понижение. Очевидно, что если у вас нет контроля над входящей строкой, вам нужно принять меры предосторожности, как и в случае с любым другим кодом. Но если вы контролируете рабочий процесс, это простое решение, которое работает. Не путайте решение, которое не идеально во всех отношениях, с плохим ответом.
elPastor
1
Помимо не упоминания об опасностях (что уже делает это плохим ответом): Вы предлагаете санировать входные данные заранее? Это убьет простоту этого метода, который был его основным плюсом.
мастов
4
Использование evalчего-то такого простого - просто запрос об уязвимости.
мастов
1
Не весь код. Но особенно код, который преобразует строки в другие типы, обычно находится вне вашего контроля. Часто вы можете даже не осознавать этого. Вы можете сказать: «Это моя база данных (или конфигурационный файл), это часть моей системы, под моим контролем». Затем вы предоставляете доступ к базе данных некоторым другим модулям, потому что: «В чем вред? Это только некоторые таблицы со строками». Но с evalэтими строками кто-то мог бы взять на себя всю систему.
мастов