在 Python 中将字符串转换为布尔值

Question

如何在 Python 中将字符串转换为布尔值？ 此尝试返回True ：

>>> bool("False")
True

Answer 1

真的，您只需将字符串与您期望接受的表示 true 的字符串进行比较，因此您可以这样做：

s == 'True'

或者检查一大堆值：

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

使用以下内容时要小心：

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

空字符串评估为False ，但其他所有字符串评估为True 。 所以这不应该用于任何类型的解析目的。

Answer 2

警告：自 Python 3.12 起，此答案将不再有效（自 3.10 起已弃用）

利用：

bool(distutils.util.strtobool(some_string))

• Python 2 : http://docs.python.org/2/distutils/apiref.html?highlight=distutils.util#distutils.util.strtobool
• Python >=3, <3.12 : https://docs.python.org/3/distutils/apiref.html#distutils.
• Python >=3.12 ：由于PEP 632 ，不再是标准库的一部分

真值为 y、yes、t、true、on 和 1； false 值为 n、no、f、false、off 和 0。如果 val 是其他值，则引发 ValueError。

请注意， distutils.util.strtobool()返回 integer 表示，因此需要用bool()包装以获取 Boolean 值。

Answer 3

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 明确检查 True 单词列表和 False 单词列表。 然后，如果它不在两个列表中，则可以抛出异常。

Answer 4

JSON 解析器通常也可用于将字符串转换为合理的 python 类型。

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

Answer 5

由于 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'

我通常不会推荐这个，但它是完全内置的，根据您的要求可能是正确的。

Answer 6

如果您知道字符串将是"True"或"False" ，则可以使用eval(s) 。

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

仅当您确定字符串的内容时才使用它，因为如果字符串不包含有效的 Python，它将引发异常，并且还将执行字符串中包含的代码。

Answer 7

注意：永远不要使用eval()如果它直接从用户那里获取输入，因为它很容易被滥用：

eval('os.system('rm -rf /')')

但是欢呼研究也发现eval()不是邪恶的，它对于TRUSTED CODE是完全可以的。 您可以使用它将 boolean 字符串（例如"False"和"True"转换为 boolean 类型。

---

我想分享我的简单解决方案：使用eval() 。 它将字符串True和False转换为正确的 boolean 类型如果字符串完全是标题格式True或False总是首字母大写，否则 function 将引发错误。

例如

>>> eval('False')
False

>>> eval('True')
True

当然，对于动态变量，您可以简单地使用.title()来格式化 boolean 字符串。

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

Answer 8

此版本保留了 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

Answer 9

这是我的版本。 它检查正值和负值列表，引发未知值的异常。 它不接收字符串，但任何类型都应该这样做。

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

Answer 10

你总是可以做类似的事情

my_string = "false"
val = (my_string == "true")

括号中的位将评估为False 。 这只是另一种无需进行实际 function 调用的方法。

Answer 11

一个很酷的简单技巧（基于@Alan Marchiori 发布的内容），但使用 yaml：

import yaml

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

如果这太宽，可以通过测试类型结果来细化。 如果 yaml 返回的类型是 str，那么它不能转换为任何其他类型（无论如何我都能想到），所以你可以单独处理它，或者让它成为真的。

我不会对速度做出任何猜测，但由于我正在使用 Qt gui 下的 yaml 数据，因此它具有很好的对称性。

Answer 12

我不同意这里的任何解决方案，因为它们太宽容了。 在解析字符串时，这通常不是您想要的。

所以这里是我正在使用的解决方案：

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

为了清楚起见，因为看起来我的回答似乎以某种方式冒犯了某人：

关键是您不想只测试一个值并假设另一个值。 我不认为你总是想要 map 绝对所有非解析值。 这会产生容易出错的代码。

因此，如果您知道要在其中编写什么代码。

Answer 13

通过使用以下简单逻辑，您可以将字符串a = 'true'或'false'转换为 boolean。

a = a.lower() == 'true'

如果a == 'true'那么这将设置a=True并且如果a == 'false'然后a=False 。

Answer 14

pydantic有一个优雅的解决方案：

import pydantic

>>> pydantic.parse_obj_as(bool, "true")
True

Answer 15

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 值填充它，并在未找到值或默认为 True 时让它引发异常（或返回 None），或默认为 False，或任何您想要的。

Answer 16

我用

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

# test cases
[[x, to_bool(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]]
"""

Answer 17

您可能已经有了解决方案，但对于其他正在寻找一种方法来使用“标准”假值（包括无、[]、{} 和“”以及假、否和 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

Answer 18

您可以简单地使用内置函数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'>

Answer 19

另一种选择

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

Answer 20

转换为 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)

Answer 21

如果您可以控制返回true / false的实体，一种选择是让它返回1 / 0而不是true / false ，那么：

boolean_response = bool(int(response))

对int的额外转换处理来自网络的响应，这些响应始终是字符串。

2021 年更新：“它们总是字符串”——这是一个幼稚的观察。 这取决于库使用的序列化协议。 高级库（大多数 web 开发人员使用的库）的默认序列化通常是在序列化为字节之前转换为字符串。 然后另一方面，它从字节反序列化为字符串，因此您丢失了任何类型信息。

Answer 22

这是我写的版本。 将其他几种解决方案合并为一个。

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

Answer 23

如果您知道您的输入将是"True"或其他内容，那么为什么不使用：

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

Answer 24

如果你喜欢我，只需要来自字符串变量的 boolean 。 您可以使用@jzwiener 提到的 distils 。 但是我无法按照他的建议导入和使用该模块。

相反，我最终在 python3.7 上以这种方式使用它

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

distutils 是 python 标准库的一部分，所以不需要安装任何东西，这很棒👍

Answer 25

您还可以评估任何字符串文字：

import ast
ast.literal_eval('True')  # True
type(ast.literal_eval('True'))  # <class 'bool'>


ls = '[1, 2, 3]'
ast.literal_eval(ls)  # [1, 2, 3]
type(ast.literal_eval(ls))  # <class 'list'>

Answer 26

我完全同意@Jacob\ Gabrielson 的解决方案，但问题是ast.literal_eval仅适用于True和False的字符串值，而不适用于true或false 。 所以你只需要使用.title()就可以了

import ast
ast.literal_eval("false".title())
# or
ast.literal_eval("False".title())

Answer 27

我喜欢为此使用三元运算符，因为对于感觉不应该超过 1 行的东西来说，它更简洁一些。

True if myString=="True" else False

Answer 28

我意识到这是一篇旧文章，但有些解决方案需要相当多的代码，这就是我最终使用的：

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

Answer 29

使用 package str2bool pip install str2bool

Answer 30

我还需要将 function 的输入更改为bool ，并且主要输入在string中只有True或False 。 所以，我只是这样编码：

def string_to_bool(s):
    bool_flag = True
    if s == "False":
        bool_flag = False
    elif s == "True":
        bool_flag = True
    else:
        print("Invalid Input")
    return bool_flag

您还可以检查它是否更缩短了True和False ，例如Y/N或y/n等。

Answer 31

使用此解决方案：

def to_bool(value) -> bool:
    if value == 'true':
        return True
    elif value == 'True':
        return True
    elif value == 'false':
        return False
    elif value == 'False':
        return False
    elif value == 0:
        return False
    elif value == 1:
        return True
    else:
        raise ValueError("Value was not recognized as a valid Boolean.")

Answer 32

如果是这样，我们可能需要捕捉“真”不区分大小写：

>>> x="TrUE"  
>>> x.title() == 'True'  
True  

>>> x="false"  
>>> x.title() == 'True'  
False  

另请注意，对于任何其他既不是真也不是假的输入，它将返回 False

Answer 33

对于您可以对正在处理的数据做出强有力的假设的有限情况或情况，评分最高的答案很好。 但是，由于自定义对象可以覆盖 Python 中的__eq__相等性检查，因此存在一个重大缺陷。 考虑下面故意过度简化的玩具示例：

In [1]: class MyString: 
   ...:     def __init__(self, value): 
   ...:         self.value = value 
   ...:     def __eq__ (self, obj): 
   ...:         if hasattr(obj, 'value'): 
   ...:             return obj.value == self.value 
   ...:         return False 
   ...:                                                                                                                                           

In [2]: v = MyString("True")                                                                                                                      

In [3]: v == "True"                                                                                                                               
Out[3]: False

如果您想象有人从MyString的string类型继承或实现各种本地字符串方法、repr 等，以便MyString实例的大部分行为与字符串完全相同，但在相等性检查中具有特殊的额外value步骤，那么简单使用== 'True'会失败，从用户的角度来看，这很可能是无声的失败。

这就是为什么将类型强制转换为您要执行的平等检查的确切性质，将其封装到辅助函数中，并迂腐地依赖这种“注册”方式来验证事物的原因。 例如对于MyString你可能会写这样的东西，

def validate(s):
    if isinstance(s, str):
        return s == 'True'
    elif isinstance(s, MyString):
        return s.value == 'True' # <-- business logic
    ...
    raise ValueError(f"Type {type(s)} not supported for validation.")

或者另一个经常使用的模式是反向透视图，您定义了一个验证行为，但是您有一个辅助函数强制转换为适合该单一验证行为的类型，例如

def to_str(s):
    if isinstance(s, str):
        return s
    elif isinstance(s, MyString):
        return s.value
    ...
    raise ValueError(f"Unsupported type {type(s)}")

def validate(s):
    return to_str(s) == 'True'
    

看起来我们添加了很多样板和冗长的内容。 我们可以通过说“如果你能写s == 'True'就写那么多？”来流利地表达批评。 - 但它忽略了一点，当你验证某些东西时，你需要确保所有先决条件都适用于验证逻辑。 如果您可以假设某些数据是普通str类型并且您不需要执行任何前提条件（例如类型）检查，那就太好了 - 但这是一种非常罕见的情况并且可能会误导这种情况的一般情况问题是适合一个超短和简洁的平等检查。

Answer 34

这是一个毛茸茸的内置方法，可以得到许多相同的答案。 请注意，尽管 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为真，不区分大小写。 任何其他字符串，包括空字符串，都会导致异常。

Answer 35

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

想法：检查您是否希望将字符串评估为 False； 否则 bool() 对任何非空字符串返回 True。

Answer 36

我只需要这样做......所以聚会可能迟到了 - 但有人可能会觉得它很有用

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

Answer 37

我在Python中搜索三元运算符时发现了一个简单的解决方案：

(False, True)[val == "true"]

因为在Python中True = 1和False = 0，并且比较结果一经评估，结果就用于通过索引0或1从元组中获取项目，所以它起作用。一个缺点是，对于除“ true”以外的任何内容，它都将返回False。 ”，但对于我的环境变量解析方案来说效果很好。

Answer 38

在 python 3.10 版中，你可以做这样的事情；

def stringToBool(string: str) -> bool:
    match(string.lower()):
        case 'true':
            return True
        case 'false':
            return False

匹配语句相当于 C++ 中的 switch。

Answer 39

这是一个使用Django Rest Framework (DRF) 3.14代码的答案。

您可以：

from rest_framework.fields import BooleanField
f = BooleanField(allow_null=True)
test_values = [ True, "True", "1", 1, -1, 1.0, "true", "t", "on",
         None, "null", "NULL",
         False, "False", "0", 0, "false", "f", 0.0, "off" ]
for item in test_values:
    r = f.to_internal_value(item)
    print(r)
   
# a shorter version
from rest_framework.fields import BooleanField
test_values = [ True, "True", "1", 1, -1, 1.0, "true", "t", "on",
         None, "null", "NULL",
         False, "False", "0", 0, "false", "f", 0.0, "off" ]
for item in test_values:
    print(BooleanField(allow_null=True).to_internal_value(item))

或者您可以调整 BooleanField 的代码以满足您的需要。 这是 DRF 3.x 中 BooleanField 类的实际代码

# from rest_framework.fields 
# ...

class BooleanField(Field):
    default_error_messages = {
        'invalid': _('Must be a valid boolean.')
    }
    default_empty_html = False
    initial = False
    TRUE_VALUES = {
        't', 'T',
        'y', 'Y', 'yes', 'Yes', 'YES',
        'true', 'True', 'TRUE',
        'on', 'On', 'ON',
        '1', 1,
        True
    }
    FALSE_VALUES = {
        'f', 'F',
        'n', 'N', 'no', 'No', 'NO',
        'false', 'False', 'FALSE',
        'off', 'Off', 'OFF',
        '0', 0, 0.0,
        False
    }
    NULL_VALUES = {'null', 'Null', 'NULL', '', None}
    
    def to_internal_value(self, data):
        try:
            if data in self.TRUE_VALUES:
                return True
            elif data in self.FALSE_VALUES:
                return False
            elif data in self.NULL_VALUES and self.allow_null:
                return None
        except TypeError:  # Input is an unhashable type
            pass
        self.fail('invalid', input=data)
    
    def to_representation(self, value):
        if value in self.TRUE_VALUES:
            return True
        elif value in self.FALSE_VALUES:
            return False
        if value in self.NULL_VALUES and self.allow_null:
            return None
        return bool(value)

# ...

Answer 40

这是我汇总的一些东西来评估字符串的真实性：

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的结果或多或少相同，但更安全。

Answer 41

通过使用 Python 的内置eval()函数和.capitalize()方法，您可以将任何“true”/“false”字符串（不管初始大写）转换为真正的 Python 布尔值。

例如：

true_false = "trUE"
type(true_false)

# OUTPUT: <type 'str'>

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

# OUTPUT: <type 'bool'>