Converting from a string to boolean in Python?
PythonStringBooleanPython Problem Overview
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
Python Solutions
Solution 1 - Python
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.
Solution 2 - Python
Use:
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.util.strtobool
- Python >=3.12: No longer part of the standard library due to PEP 632
> 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.
Solution 3 - Python
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.
Solution 4 - Python
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
Solution 5 - Python
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.
Solution 6 - 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.
Solution 7 - Python
> UPDATE
>
> NOTE: DON'T EVER USE eval()
IF it takes an input directly from the user because it is highly subject to abuse:
>
> eval('os.system(‘rm -rf /’)')
>
> But cheers! Study finds also that eval()
is not evil and it is perfectly OK for TRUSTED CODE. You can use it to convert a boolean string such as "False"
and "True"
to a boolean type.
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
Solution 8 - Python
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
Solution 9 - Python
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
>>>
Solution 10 - Python
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.
Solution 11 - Python
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.
Solution 12 - Python
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.
Solution 13 - Python
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.
Solution 14 - Python
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]]
"""
Solution 15 - Python
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
Solution 16 - Python
Yet another option
from ansible.module_utils.parsing.convert_bool import boolean
boolean('no')
# False
boolean('yEs')
# True
boolean('true')
# True
Solution 17 - Python
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)
Solution 18 - Python
If you know that your input will be either "True" or "False" then why not use:
def bool_convert(s):
return s == "True"
Solution 19 - Python
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.
Update 2021: "which are always string" -- this is a naive observation. It depends on the serialization protocol used by the library. Default serialization of high-level libraries (the ones used by most web devs) is typically to convert to string before being serialized to bytes. And then on the other side, it's deserialized from bytes to string, so you've lost any type information.
Solution 20 - Python
By using below simple logic you can convert a string say a = 'true' or 'false', to boolean.
a = a.lower() == 'true'
if a == 'true' then this will set a=True and if a == 'false' then a=False.
Solution 21 - Python
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),
]
Solution 22 - Python
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!
Solution 23 - Python
You can also evaluate any string literal :
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'>
Solution 24 - Python
There is an elegant solution with pydantic:
import pydantic
>>> pydantic.parse_obj_as(bool, "true")
True
Solution 25 - Python
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)
Solution 26 - Python
I completely agree with the solution of @Jacob\ Gabrielson but the thing is ast.literal_eval
only work with string value of True
and False
not with true
or false
. So you just have to use .title()
for it to work
import ast
ast.literal_eval("false".title())
# or
ast.literal_eval("False".title())
Solution 27 - Python
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
Solution 28 - Python
Use package str2bool pip install str2bool
Solution 29 - Python
I was also required to change the input to bool
for a function and the main input was only True
or False
in string
. So, I just coded it like this:
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
You can also check it for more shortened for True
and False
like Y/N
or y/n
etc.
Solution 30 - Python
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.
Solution 31 - Python
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.
Solution 32 - Python
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.
Solution 33 - Python
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
Solution 34 - Python
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'>