true - ¿Convertir de una cadena a boolean en Python?

python boolean values (26)

¿Alguien sabe cómo convertir una cadena a un booleano en Python? He encontrado este enlace . Pero no parece una forma adecuada de hacerlo. Es decir, utilizando una funcionalidad incorporada, etc.

EDITAR:

La razón por la que pregunté esto es porque aprendí int("string") , desde aquí. Intenté bool("string") pero siempre obtuve True .

>>> bool("False") True

A partir de Python 2.6, ahora hay 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.

Lo que parece funcionar, siempre y cuando estés seguro de que tus cadenas serán "True" o "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''

Normalmente no recomendaría esto, pero está completamente integrado y podría ser lo correcto dependiendo de sus necesidades.

Al utilizar la función eval() incorporada de Python y el método .capitalize() , puede convertir cualquier cadena "verdadera" / "falsa" (independientemente del uso de mayúsculas inicial) en un booleano de Python verdadero.

Por ejemplo:

true_false = "trUE" type(true_false) # OUTPUT: <type ''str''> true_false = eval(true_false.capitalize()) type(true_false) # OUTPUT: <type ''bool''>

Aquí está mi versión. Comprueba las listas de valores positivos y negativos, generando una excepción para valores desconocidos. Y no recibe una cadena, pero cualquier tipo debe hacer.

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

Ejecuciones de muestra:

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

Aquí hay algo que junté para evaluar la veracidad de una cuerda:

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)

más o menos los mismos resultados que usando eval pero más seguro.

Aquí hay una forma de peluda, construida para obtener muchas de las mismas respuestas. Tenga en cuenta que aunque Python considera que "" es falso y que todas las demás cadenas son verdaderas, TCL tiene una idea muy diferente acerca de las cosas.

>>> 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 /'']" >>>

Lo bueno de esto es que es bastante indulgente con los valores que puede usar. Es perezoso hacer que las cadenas se conviertan en valores, y es higiénico en cuanto a lo que acepta y rechaza (observe que si la declaración anterior se diera en un aviso tcl, borraría el disco duro de los usuarios).

lo malo es que requiere que Tkinter esté disponible, lo cual es generalmente, pero no universalmente cierto, y lo que es más importante, requiere que se cree una instancia de Tk, que es comparativamente pesada.

Lo que se considera verdadero o falso depende del comportamiento del Tcl_GetBoolean , que considera 0 , false , no y off como falso y 1 , true , yes y yes , true , yes distingue entre mayúsculas y minúsculas. Cualquier otra cadena, incluida la cadena vacía, provoca una excepción.

El analizador JSON también es útil para, en general, convertir cadenas a tipos de python razonables.

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

En realidad, simplemente compara la cadena con lo que espera aceptar como que representa la verdadera, por lo que puede hacer esto:

s == ''True''

O a los controles contra un montón de valores:

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

Tenga cuidado al usar lo siguiente:

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

Las cadenas vacías se evalúan como False , pero todo lo demás se evalúa como True . Por lo tanto, esto no debe utilizarse para ningún tipo de propósitos de análisis.

Esta es la versión que escribí. Combina varias de las otras soluciones en una sola.

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)

Si obtiene una cadena espera valores específicos, de lo contrario genera una excepción. Si no obtiene una cadena, simplemente deja que el constructor bool lo descubra. Probado estos casos:

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

Esta versión mantiene la semántica de constructores como int (valor) y proporciona una manera fácil de definir valores de cadena aceptables.

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

La regla habitual para lanzar a un bool es que algunos literales especiales ( False , 0 , 0.0 , () , [] , {} ) son falsos y todo lo demás es verdadero, por lo que recomiendo lo siguiente:

def boolify(val): if (isinstance(val, basestring) and bool(val)): return not val in (''False'', ''0'', ''0.0'') else: return bool(val)

Me doy cuenta de que este es un post antiguo, pero algunas de las soluciones requieren bastante código, esto es lo que terminé usando:

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

Me gusta usar el operador ternario para esto, ya que es un poco más conciso para algo que parece que no debería ser más de 1 línea.

True if myString=="True" else False

No estoy de acuerdo con ninguna solución aquí, ya que son demasiado permisivas. Esto normalmente no es lo que quiere cuando analiza una cadena.

Así que aquí la solución que estoy usando:

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)

Y los resultados:

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

Solo para ser claro porque parece que mi respuesta ofendió a alguien de alguna manera:

El punto es que no desea probar solo un valor y asumir el otro. No creo que siempre quieras asignar Absolutamente todo al valor no analizado. Eso produce código propenso a errores.

Así que, si sabes en qué quieres codificarlo.

Otra opcion

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

Probablemente ya tenga una solución, pero para otros que buscan un método para convertir un valor en un valor booleano usando valores falsos "estándar", incluidos Ninguno, [], {} y "" además de falso, no y 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

Si sabe que la cadena será "True" o "False" , simplemente puede usar eval(s) .

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

Use esto solo si está seguro del contenido de la cadena, ya que lanzará una excepción si la cadena no contiene Python válido y también ejecutará el código contenido en la cadena.

Si sabe que su entrada será "Verdadero" o "Falso", entonces ¿por qué no usar:

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

Si tiene control sobre la entidad que está devolviendo true / false , una opción es que devuelva 0 lugar de true / false , entonces:

boolean_response = bool(int(response))

La conversión adicional a int controla las respuestas de una red, que siempre son cadenas.

Simplemente puede usar la función incorporada 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)

y la salida:

a isn''t True, a type is <type ''str''> b is True, b type is <type ''bool''>

Solo tuve que hacer esto ... así que tal vez tarde a la fiesta, pero a alguien le puede resultar útil

Solo usa:

distutils.util.strtobool(some_string)

http://docs.python.org/2/distutils/apiref.html?highlight=distutils.util#distutils.util.strtobool

Los valores reales son y, yes, t, true, on y 1; los valores falsos son n, no, f, falso, apagado y 0. Aumenta ValueError si val es otra cosa.

Un dict (realmente, un defaultdict) te da una manera bastante fácil de hacer este truco:

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

Es realmente fácil adaptar este método al comportamiento de conversión exacto que desea; puede rellenarlo con los valores permitidos de Verdad y Falsía y dejar que genere una excepción (o devolver Ninguno) cuando no se encuentre un valor, o que se establezca de manera predeterminada en Verdadero. o por defecto a Falso, o lo que quieras.

Un truco genial y simple (basado en lo que @Alan Marchiori publicó), pero usando yaml:

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

Si es demasiado amplio, se puede refinar probando el resultado del tipo. Si el tipo yaml-return es una cadena, entonces no se puede convertir a ningún otro tipo (en el que pueda pensar de todos modos), así que podrías manejarlo por separado, o simplemente dejar que sea verdad.

No voy a adivinar la velocidad, pero como de todos modos estoy trabajando con datos yaml bajo Qt gui, esto tiene una simetría agradable.

siempre podrias hacer algo como

myString = "false" val = (myString == "true")

el bit en parens evaluaría a falso. Esta es solo otra forma de hacerlo sin tener que hacer una llamada de función real.

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

idea: compruebe si desea que la cadena se evalúe como False; de lo contrario, bool () devuelve True para cualquier cadena no vacía.

def str2bool(v): return v.lower() in ("yes", "true", "t", "1")

Entonces llámalo así:

str2bool("yes")

> True

str2bool("no")

> False

str2bool("stuff")

> False

str2bool("1")

> True

str2bool("0")

> False

Manejando verdadero y falso explícitamente:

También puede hacer que su función compruebe explícitamente una lista de palabras Verdadera y una lista de palabras Falsa. Entonces, si no está en ninguna lista, podría lanzar una excepción.