在有限的情况或情况下，您可以对正在处理的数据做出强有力的假设。然而，由于自定义对象可以覆盖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.

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

import pydantic

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

.blink { color: yellow; animation: blink-animation 0.5s infinite; } @keyframes blink-animation { 25% { background-color: black; color: cyan; } 50% { background-color: black; color: red; } 75% { background-color: black; color: lime; } } <h1 class="blink">WARNING: Do not use the following code unless you actually know what you are doing with it. Please read the attached disclaimers and make sure you trust your inputs as using this on untrusted inputs could destroy your data and/or cost you your job.</h1>

如果你知道字符串将是“True”或“False”，你可以使用eval(s)。

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

不过，只有在确定字符串的内容时才使用此方法，因为如果字符串不包含有效的Python，它将抛出异常，并且还将执行字符串中包含的代码。

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

boolean = bool(int(response))

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

2021年更新:“which are always string”——这是一个幼稚的观察。它取决于库使用的序列化协议。高级库(大多数web开发人员使用的库)的默认序列化通常是在序列化为字节之前转换为字符串。然后在另一边，它从字节反序列化为字符串，所以你丢失了任何类型信息。

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

我通常不建议这样做，但它是完全内置的，可以根据您的需求来选择。

JSON解析器在将字符串转换为合理的python类型时也很有用。

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