问题：在Python中从字符串转换为布尔值？
有谁知道如何在Python中从字符串转换为布尔值？我找到了这个链接。但这似乎不是正确的方法。即使用内置功能等
我之所以这样问，是因为我int("string")从这里学到了。但是当尝试bool("string")它总是返回True：
>>> bool("False")
True
Does anyone know how to do convert from a string to a boolean in Python? I found this link. But it doesn’t look like a proper way to do it. I.e. using built-in functionality, etc.
The reason I’m asking this is because I learned about int("string") from here. But when trying bool("string") it always returns True:
>>> bool("False")
True
回答 0
实际上，您只需将字符串与希望接受的代表true的字符串进行比较，就可以做到这一点：
s == 'True'
或检查一堆值：
s.lower() in ['true', '1', 't', 'y', 'yes', 'yeah', 'yup', 'certainly', 'uh-huh']
使用以下内容时请小心：
>>> bool("foo")
True
>>> bool("")
False
空字符串的计算结果为False，但其他所有结果的计算结果为True。因此，不应将其用于任何类型的解析目的。
Really, you just compare the string to whatever you expect to accept as representing true, so you can do this:
s == 'True'
Or to checks against a whole bunch of values:
s.lower() in ['true', '1', 't', 'y', 'yes', 'yeah', 'yup', 'certainly', 'uh-huh']
Be cautious when using the following:
>>> bool("foo")
True
>>> bool("")
False
Empty strings evaluate to False, but everything else evaluates to True. So this should not be used for any kind of parsing purposes.
回答 1
采用：
bool(distutils.util.strtobool(some_string))
真实值为y，y，t，true，on和1；false值是n，no，f，false，off和0。如果val是其他值，则引发ValueError。
请注意，它distutils.util.strtobool()返回整数表示形式，因此需要将其包装bool()以获取布尔值。
Use:
bool(distutils.util.strtobool(some_string))
True values are y, yes, t, true, on and 1; false values are n, no, f, false, off and 0. Raises ValueError if val is anything else.
Be aware that distutils.util.strtobool() returns integer representations and thus it needs to be wrapped with bool() to get Boolean values.
回答 2
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单词列表。然后，如果它不在两个列表中，则可能引发异常。
def str2bool(v):
return v.lower() in ("yes", "true", "t", "1")
Then call it like so:
>>> str2bool("yes")
True
>>> str2bool("no")
False
>>> str2bool("stuff")
False
>>> str2bool("1")
True
>>> str2bool("0")
False
Handling true and false explicitly:
You could also make your function explicitly check against a True list of words and a False list of words. Then if it is in neither list, you could throw an exception.
回答 3
JSON解析器通常也可用于将字符串转换为合理的python类型。
>>> import json
>>> json.loads("false".lower())
False
>>> json.loads("True".lower())
True
The JSON parser is also useful for in general converting strings to reasonable python types.
>>> import json
>>> json.loads("false".lower())
False
>>> json.loads("True".lower())
True
回答 4
从Python 2.6开始，现在有ast.literal_eval：
>>>导入AST
>>>帮助（ast.literal_eval）
帮助ast模块中的literal_eval函数：
literal_eval（node_or_string）
安全地评估表达式节点或包含Python的字符串
表达。提供的字符串或节点只能由以下内容组成
Python文字结构：字符串，数字，元组，列表，字典，布尔值，
和没有。
因为你这似乎工作，只要确保你的字符串将是两种"True"或"False"：
>>> ast.literal_eval（“ True”）
真正
>>> ast.literal_eval（“ False”）
假
>>> ast.literal_eval（“ F”）
追溯（最近一次通话）：
文件“”，第1行，位于
文件“ /opt/Python-2.6.1/lib/python2.6/ast.py”，第68行，位于literal_eval中
返回_convert（node_or_string）
_convert中的文件“ /opt/Python-2.6.1/lib/python2.6/ast.py”，第67行
引发ValueError（'格式错误的字符串'）
ValueError：格式错误的字符串
>>> ast.literal_eval（“'False'”）
'假'
我通常不建议这样做，但是它是完全内置的，根据您的要求可能是正确的选择。
Starting with Python 2.6, there is now 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.
Which seems to work, as long as you’re sure your strings are going to be either "True" or "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'
I wouldn’t normally recommend this, but it is completely built-in and could be the right thing depending on your requirements.
回答 5
如果您知道字符串为"True"or "False"，则可以使用eval(s)。
>>> eval("True")
True
>>> eval("False")
False
不过，仅在确定字符串的内容时才使用它，因为如果字符串不包含有效的Python，它将引发异常，并且还将执行字符串中包含的代码。
If you know the string will be either "True" or "False", you could just use eval(s).
>>> eval("True")
True
>>> eval("False")
False
Only use this if you are sure of the contents of the string though, as it will throw an exception if the string does not contain valid Python, and will also execute code contained in the string.
回答 6
此版本保留了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
This version keeps the semantics of constructors like int(value) and provides an easy way to define acceptable string values.
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
回答 7
这是我的版本。它同时检查正值和负值列表，从而引发未知值的异常。而且它不接收字符串，但是任何类型都可以。
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
>>>
Here’s is my version. It checks against both positive and negative values lists, raising an exception for unknown values. And it does not receive a string, but any type should do.
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))
Sample runs:
>>> 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
>>>
回答 8
你总是可以做这样的事情
myString = "false"
val = (myString == "true")
括号中的位将评估为False。这是无需执行实际函数调用的另一种方法。
you could always do something like
myString = "false"
val = (myString == "true")
the bit in parens would evaluate to False. This is just another way to do it without having to do an actual function call.
回答 9
一个很酷的简单技巧（基于@Alan Marchiori发布的内容），但是使用了yaml：
import yaml
parsed = yaml.load("true")
print bool(parsed)
如果宽度太大，可以通过测试类型结果来完善它。如果yaml返回的类型是str，则不能将其强制转换为任何其他类型（无论如何我都可以想到），因此您可以单独处理它，也可以使其为true。
我不会对速度做出任何猜测，但是由于无论如何我都在Qt gui下使用yaml数据，所以这具有很好的对称性。
A cool, simple trick (based on what @Alan Marchiori posted), but using yaml:
import yaml
parsed = yaml.load("true")
print bool(parsed)
If this is too wide, it can be refined by testing the type result. If the yaml-returned type is a str, then it can’t be cast to any other type (that I can think of anyway), so you could handle that separately, or just let it be true.
I won’t make any guesses at speed, but since I am working with yaml data under Qt gui anyway, this has a nice symmetry.
回答 10
我不同意这里的任何解决方案，因为它们太宽容了。这通常不是解析字符串时想要的。
所以这是我正在使用的解决方案：
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
只是要清楚一点，因为它看起来好像我的回答以某种方式冒犯了别人：
关键是您不想只测试一个值并假设另一个值。我不认为您总是想将所有内容绝对映射到未解析的值。产生易于出错的代码。
因此，如果您知道要编码的内容。
I don’t agree with any solution here, as they are too permissive. This is not normally what you want when parsing a string.
So here the solution I’m using:
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)
And the results:
>>> [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
Just to be clear because it looks as if my answer offended somebody somehow:
The point is that you don’t want to test for only one value and assume the other. I don’t think you always want to map Absolutely everything to the non parsed value. That produces error prone code.
So, if you know what you want code it in.
回答 11
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或您想要的任何值。
A dict (really, a defaultdict) gives you a pretty easy way to do this trick:
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
It’s really easy to tailor this method to the exact conversion behavior you want — you can fill it with allowed Truthy and Falsy values and let it raise an exception (or return None) when a value isn’t found, or default to True, or default to False, or whatever you want.
回答 12
您可能已经有了解决方案，但对于其他人，他们正在寻找一种方法，使用除false，no和0之外的“ Non”，[]，{}和“”等“标准” false值将值转换为布尔值。
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
You probably already have a solution but for others who are looking for a method to convert a value to a boolean value using “standard” false values including None, [], {}, and “” in addition to false, no , and 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
回答 13
您可以简单地使用内置函数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'>
You can simply use the built-in function 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)
and the output:
a isn't True, a type is <type 'str'>
b is True, b type is <type 'bool'>
回答 14
另一个选择
from ansible.module_utils.parsing.convert_bool import boolean
boolean('no')
# False
boolean('yEs')
# True
boolean('true')
# True
但是在生产中，如果不需要ansible及其所有依赖关系，一个好主意是查看其源代码并复制所需逻辑的一部分。
Yet another option
from ansible.module_utils.parsing.convert_bool import boolean
boolean('no')
# False
boolean('yEs')
# True
boolean('true')
# True
But in production if you don’t need ansible and all its dependencies, a good idea is to look at its source code and copy part of the logic that you need.
回答 15
进行浇铸，一个布尔值，通常的规则是，一些特殊的文字（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)
The usual rule for casting to a bool is that a few special literals (False, 0, 0.0, (), [], {}) are false and then everything else is true, so I recommend the following:
def boolify(val):
if (isinstance(val, basestring) and bool(val)):
return not val in ('False', '0', '0.0')
else:
return bool(val)
回答 16
这是我写的版本。将其他几种解决方案合并为一个。
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)
如果它得到一个字符串，则它期望特定的值，否则引发Exception。如果没有得到字符串，只需让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),
]
This is the version I wrote. Combines several of the other solutions into one.
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)
If it gets a string it expects specific values, otherwise raises an Exception. If it doesn’t get a string, just lets the bool constructor figure it out. Tested these cases:
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),
]
回答 17
如果您知道您的输入将为“ True”或“ False”，那么为什么不使用：
def bool_convert(s):
return s == "True"
If you know that your input will be either “True” or “False” then why not use:
def bool_convert(s):
return s == "True"
回答 18
我用
# 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]]
"""
I use
# 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]]
"""
回答 19
我喜欢使用三元运算符，因为对于某些东西来说，它不应该超过1行，因此更加简洁。
True if myString=="True" else False
I like to use the ternary operator for this, since it’s a bit more succinct for something that feels like it shouldn’t be more than 1 line.
True if myString=="True" else False
回答 20
我意识到这是一篇旧文章，但是某些解决方案需要大量代码，这就是我最终使用的内容：
def str2bool(value):
return {"True": True, "true": True}.get(value, False)
I realize this is an old post, but some of the solutions require quite a bit of code, here’s what I ended up using:
def str2bool(value):
return {"True": True, "true": True}.get(value, False)
回答 21
Use package str2bool pip install str2bool
回答 22
如果您喜欢我，只需要来自字符串的变量中的布尔值即可。您可以使用@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 std lib的一部分，因此无需安装。太好了！👍
If you like me just need boolean from variable which is string. You can use distils as mentioned earlier by @jzwiener. However I could not import and use the module as he suggested.
Instead I end up using it this way on python3.7
from distutils import util # to handle str to bool conversion
enable_deletion = 'False'
enable_deletion = bool(util.strtobool(enable_deletion))
distutils is part of the python std lib so no need of installation. Which is great!👍
回答 23
我想分享我的简单解决方案：使用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
I would like to share my simple solution: use the eval(). It will convert the string True and False to proper boolean type IF the string is exactly in title format True or False always first letter capital or else the function will raise an error.
e.g.
>>> eval('False')
False
>>> eval('True')
True
Of course for dynamic variable you can simple use the .title() to format the boolean string.
>>> x = 'true'
>>> eval(x.title())
True
This will throw an error.
>>> 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
回答 24
这是一个毛茸茸的方法，旨在获得许多相同的答案。请注意，尽管python认为""是false，而所有其他字符串都为true，但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是真实的，不区分大小写。任何其他字符串（包括空字符串）都会导致异常。
here’s a hairy, built in way to get many of the same answers. Note that although python considers "" to be false and all other strings to be true, TCL has a very different idea about things.
>>> 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 /']"
>>>
A good thing about this is that it is fairly forgiving about the values you can use. It’s lazy about turning strings into values, and it’s hygenic about what it accepts and rejects(notice that if the above statement were given at a tcl prompt, it would erase the users hard disk).
the bad thing is that it requires that Tkinter be available, which is usually, but not universally true, and more significantly, requires that a Tk instance be created, which is comparatively heavy.
What is considered true or false depends on the behavior of the Tcl_GetBoolean, which considers 0, false, no and off to be false and 1, true, yes and on to be true, case insensitive. Any other string, including the empty string, cause an exception.
回答 25
def str2bool(str):
if isinstance(str, basestring) and str.lower() in ['0','false','no']:
return False
else:
return bool(str)
想法：检查您是否希望将字符串评估为False；否则，bool（）对于任何非空字符串都返回True。
def str2bool(str):
if isinstance(str, basestring) and str.lower() in ['0','false','no']:
return False
else:
return bool(str)
idea: check if you want the string to be evaluated to False; otherwise bool() returns True for any non-empty string.
回答 26
我汇总了以下内容以评估字符串的真实性：
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但更安全。
Here’s something I threw together to evaluate the truthiness of a string:
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)
more-or-less same results as using eval but safer.
回答 27
我只需要这样做…所以聚会晚了-但有人可能会觉得有用
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
I just had to do this… so maybe late to the party – but someone may find it useful
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
回答 28
如果您可以控制返回true/ 的实体，false则可以选择使它返回1/ 0而不是true/ false，然后：
boolean_response = bool(int(response))
用于int处理来自网络的响应（通常是字符串）的额外转换。
If you have control over the entity that’s returning true/false, one option is to have it return 1/0 instead of true/false, then:
boolean_response = bool(int(response))
The extra cast to int handles responses from a network, which are always string.
回答 29
通过使用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'>
By using Python’s built-in eval() function and the .capitalize() method, you can convert any “true” / “false” string (regardless of initial capitalization) to a true Python boolean.
For example:
true_false = "trUE"
type(true_false)
# OUTPUT: <type 'str'>
true_false = eval(true_false.capitalize())
type(true_false)
# OUTPUT: <type 'bool'>
