Перетворення з рядка в булеве в 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))

• Пітон 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; значення false - 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

Поводження з правдою та помилкою явно:

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

Аналізатор JSON також корисний для перетворення рядків у розумні типи пітона.

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

Починаючи з Python 2.6, зараз є ast.literal_eval:

>>> імпорт ast
>>> допомога (ast.literal_eval)
Довідка щодо функції literal_eval в модулі ast:

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

Який , здається, працює, до тих пір , поки ви впевнені , що ваші рядки будуть або "True"або "False":

>>> ast.literal_eval ("Правда")
Правда
>>> ast.literal_eval ("Неправдиво")
помилковий
>>> ast.literal_eval ("F")
Відстеження (останній останній дзвінок):
  Файл "", рядок 1, в 
  Файл "/opt/Python-2.6.1/lib/python2.6/ast.py", рядок 68, у літеральному_евалі
    return _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")

біт у паренах оцінюватиметься як False. Це просто ще один спосіб зробити це без необхідності виконувати фактичний виклик функції.

Класний, простий трюк (заснований на публікації @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

Просто, щоб було зрозуміло, бо виглядає так, ніби моя відповідь когось образила когось:

Справа в тому, що ви не хочете перевіряти лише одне значення, а припускати інше. Я не думаю, що ти завжди хочеш позначати абсолютно все на неадекватне значення. Це створює код, схильний до помилок.

Отже, якщо ви знаєте, що ви хочете, введіть його.

Дікт (насправді, вирок за замовчуванням) дає вам досить простий спосіб виконати цю хитрість:

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 вважає ""помилковим і всі інші рядки є правдивими, 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'>