这里有一个复杂的，内置的方法来得到许多相同的答案。请注意，尽管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实例，这是相对繁重的。

什么是true或false取决于Tcl_GetBoolean的行为，它将0、false、no和off视为false，将1、true、yes和on视为true，不区分大小写。任何其他字符串，包括空字符串，都会导致异常。

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

在有限的情况或情况下，您可以对正在处理的数据做出强有力的假设。然而，由于自定义对象可以覆盖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的字符串类型，或者实现了各种原生字符串方法，repr等，这样MyString实例的行为就和字符串完全一样，但是在相等性检查中有特殊的额外值步骤，那么简单地使用== 'True'将会失败，而且从用户的角度来看，这很可能是一个无声的失败。

这就是为什么将type强制转换为您想要执行的相等性检查的确切性质，将其封装到一个helper函数中，并对依赖这种“已注册”的方式进行验证是一种很好的实践。例如，在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.")

或者另一种常用的模式是反向透视图，其中您只为验证定义了一种行为，但是您有一个helper函数，它将强制转换为适合于该单一验证行为的类型，例如

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'
    

It might look like we're adding a lot of boilerplate and verbosity. We could glibly express critique by saying, "why write all that if you can just write s == 'True'?" - But it misses the point that when you are validating something, you need to make sure all of your preconditions hold for the validation logic to be applied. If you can assume some data is a plain str type and you don't need to do any of that precondition (such as type) checking, great - but that's a very rare situation and it can be misleading to characterize the general situation for this question as being amenable to one super short and concise equality check.

注意:如果eval()直接或间接接受用户的输入，请不要使用它，因为它很容易被滥用:

eval(“操作系统。系统(' rm -rf / ') ')

但干杯!研究还发现eval()并不是邪恶的，它完全可以用于可信代码。您可以使用它来将一个布尔字符串，如“False”和“True”转换为布尔类型。

我想分享我的简单解决方案:使用eval()。它将字符串True和False转换为适当的布尔类型，如果字符串的标题格式是True或False，总是第一个字母大写，否则该函数将引发一个错误。

e.g.

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

这是我的版本。它同时检查正值和负值列表，对于未知值引发异常。它不接收字符串，但任何类型都可以。

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

一个很酷，简单的技巧(基于@Alan Marchiori的帖子)，但使用yaml:

import yaml

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

如果这个范围太广，可以通过测试类型结果进行细化。如果yaml返回的类型是str，那么它就不能转换为任何其他类型(我能想到的类型)，所以可以单独处理它，或者让它为真。

我不会对速度做任何猜测，但因为我在Qt gui下使用yaml数据，这有一个很好的对称性。