Convertendo de uma string para booleano em Python?

Alguém sabe como converter de uma string para um booleano em Python? Encontrei este link . Mas não parece uma maneira adequada de fazer isso. Ou seja, usando a funcionalidade incorporada, etc.

A razão pela qual estou perguntando isso é porque aprendi sobre int("string")aqui. Mas ao tentar, bool("string")ele sempre retorna True:

>>> bool("False")
True

Realmente, você apenas compara a string com o que espera aceitar como representando true, para fazer isso:

s == 'True'

Ou para verificar um monte de valores:

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

Seja cauteloso ao usar o seguinte:

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

Seqüências vazias são avaliadas como False, mas todo o resto é avaliado True. Portanto, isso não deve ser usado para nenhum tipo de finalidade de análise.

Usar:

bool(distutils.util.strtobool(some_string))

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

Os valores verdadeiros são y, sim, t, verdadeiro, ativado e 1; valores falsos são n, não, f, falso, desligado e 0. Gera ValueError se val for outra coisa.

Esteja ciente de que distutils.util.strtobool()retorna representações inteiras e, portanto, ele precisa ser agrupado bool()para obter valores booleanos.

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

Então chame assim:

>>> str2bool("yes")
True
>>> str2bool("no")
False
>>> str2bool("stuff")
False
>>> str2bool("1")
True
>>> str2bool("0")
False

Manipulando true e false explicitamente:

Você também pode fazer com que sua função verifique explicitamente uma lista de palavras Verdadeira e uma lista de palavras Falsas. Então, se não estiver em nenhuma das listas, você poderá lançar uma exceção.

O analisador JSON também é útil para a conversão geral de cadeias de caracteres em tipos de python razoáveis.

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

Começando com o Python 2.6, agora existe ast.literal_eval:

>>> import ast
>>> ajuda (ast.literal_eval)
Ajuda na função literal_eval no módulo ast:

literal_eval (node_or_string)
    Avalie com segurança um nó de expressão ou uma sequência que contém um Python
    expressão. A cadeia ou nó fornecido pode consistir apenas nos seguintes
    Estruturas literais em Python: strings, números, tuplas, listas, dictes, booleanos,
    e nenhum.

O que parece funcionar, desde que você tenha certeza de que suas strings serão "True"ou "False":

>>> ast.literal_eval ("True")
Verdade
>>> ast.literal_eval ("False")
Falso
>>> ast.literal_eval ("F")
Traceback (última chamada mais recente):
  Arquivo "", linha 1, em 
  Arquivo "/opt/Python-2.6.1/lib/python2.6/ast.py", linha 68, em literal_eval
    retornar _convert (node_or_string)
  Arquivo "/opt/Python-2.6.1/lib/python2.6/ast.py", linha 67, em _convert
    raise ValueError ('string malformada')
ValueError: string malformada
>>> ast.literal_eval ("'False'")
'Falso'

Normalmente, eu não recomendaria isso, mas é completamente integrado e pode ser a coisa certa, dependendo de seus requisitos.

Se você souber que a string será um "True"ou "False", você pode simplesmente usar eval(s).

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

Apenas use isso se tiver certeza do conteúdo da string, pois isso gerará uma exceção se a string não contiver Python válido e também executará o código contido na string.

Esta versão mantém a semântica de construtores como int (value) e fornece uma maneira fácil de definir valores aceitáveis ​​de string.

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

Aqui está a minha versão. Ele verifica as listas de valores positivos e negativos, gerando uma exceção para valores desconhecidos. E ele não recebe uma string, mas qualquer tipo deve receber.

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

Amostras de execuções:

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

você sempre pode fazer algo como

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

o bit em parens seria avaliado como False. Esta é apenas outra maneira de fazer isso sem precisar fazer uma chamada de função real.

Um truque legal e simples (baseado no que Alan Marchiori postou), mas usando o yaml:

import yaml

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

Se for muito amplo, poderá ser refinado testando o resultado do tipo. Se o tipo retornado pelo yaml for um str, ele não poderá ser convertido para outro tipo (que eu possa pensar de qualquer maneira), para que você possa lidar com isso separadamente ou apenas permitir que seja verdade.

Eu não vou fazer nenhuma suposição em alta velocidade, mas como eu estou trabalhando com dados yaml no Qt gui de qualquer maneira, isso tem uma simetria agradável.

Não concordo com nenhuma solução aqui, pois elas são permissivas demais. Normalmente, isso não é o que você deseja ao analisar uma string.

Então, aqui a solução que estou 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)

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

Só para ficar claro, porque parece que minha resposta ofendeu alguém de alguma forma:

O ponto é que você não deseja testar apenas um valor e assumir o outro. Eu não acho que você sempre queira mapear Absolutamente tudo para o valor não analisado. Isso produz código propenso a erros.

Portanto, se você souber o que deseja codificar.

Um ditado (realmente, um padrão) fornece uma maneira bastante fácil de fazer esse truque:

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

É realmente fácil adaptar esse método ao comportamento exato de conversão desejado - você pode preenchê-lo com os valores permitidos de Truthy e Falsy e gerar uma exceção (ou retornar None) quando um valor não for encontrado ou o padrão é True, ou o padrão é False, ou o que você quiser.

Você provavelmente já possui uma solução, mas para outras pessoas que procuram um método para converter um valor em um valor booleano usando valores falsos "padrão", incluindo Nenhum, [], {} e "", além de falso, não e 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

Você pode simplesmente usar a função interna 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)

e a saída:

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

Mais uma opção

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

Mas, na produção, se você não precisar do ansible e de todas as suas dependências, uma boa idéia é examinar o código-fonte e copiar parte da lógica necessária.

A regra habitual para lançar a um bool é que algumas literais especiais ( False, 0, 0.0, (), [], {}) são falsas e, em seguida, tudo o resto é verdadeiro, então eu recomendo o seguinte:

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

Esta é a versão que escrevi. Combina várias das outras soluções em uma.

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)

Se obtiver uma string, espera valores específicos, caso contrário, gera uma exceção. Se ele não receber uma string, deixe o construtor bool descobrir isso. Testou estes 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),
    ]

Se você sabe que sua entrada será "True" ou "False", por que não usar:

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

eu uso

# 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]]
"""

Eu gosto de usar o operador ternário para isso, pois é um pouco mais sucinto para algo que parece que não deve ter mais do que 1 linha.

True if myString=="True" else False

Sei que este é um post antigo, mas algumas das soluções exigem bastante código, eis o que acabei usando:

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

Use o pacote str2bool pip install str2bool

Se você gosta de mim só precisa booleano da variável que é string. Você pode usar destiladores conforme mencionado anteriormente por @jzwiener. No entanto, não consegui importar e usar o módulo como ele sugeriu.

Em vez disso, acabo usando dessa maneira no python3.7

from distutils import util # to handle str to bool conversion
enable_deletion = 'False'
enable_deletion = bool(util.strtobool(enable_deletion))

O distutils faz parte da python std lib, portanto não há necessidade de instalação. O que é ótimo! 👍

Gostaria de compartilhar minha solução simples: use o eval(). Ele converterá a string Truee Falsepara o tipo booleano apropriado, se a string estiver exatamente no formato de título TrueouFalse sempre em maiúscula na primeira letra, ou a função gerará um erro.

por exemplo

>>> eval('False')
False

>>> eval('True')
True

Obviamente, para variável dinâmica, você pode simplesmente usar o .title()para formatar a string booleana.

>>> x = 'true'
>>> eval(x.title())
True

Isso gerará um erro.

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

aqui está um cabeludo, construído de maneira a obter muitas das mesmas respostas. Observe que, embora o python considere ""falso e todas as outras strings verdadeiras, o TCL tem uma idéia muito diferente sobre as coisas.

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

Uma coisa boa disso é que ele perdoa razoavelmente os valores que você pode usar. É preguiçoso em transformar strings em valores e é higiênico em relação ao que aceita e rejeita (observe que, se a declaração acima fosse dada em um prompt de tcl, isso apagaria o disco rígido do usuário).

o ruim é que exige que o Tkinter esteja disponível, o que geralmente é, mas não universalmente verdadeiro, e mais significativamente, exige a criação de uma instância do Tk, que é comparativamente pesada.

O que é considerado verdadeiro ou falso depende do comportamento do Tcl_GetBooleanque considera 0, false, noe offpara ser falso e 1, true, yese onpara ser verdade, insensível caso. Qualquer outra sequência, incluindo a sequência vazia, causa uma exceção.

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

idéia: verifique se deseja que a string seja avaliada como False; caso contrário, bool () retorna True para qualquer string não vazia.

Aqui está uma coisa que juntei para avaliar a veracidade de uma 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)

mais ou menos os mesmos resultados que o uso, evalmas mais seguros.

Eu só tinha que fazer isso ... então talvez esteja atrasado para a festa - mas alguém pode achar útil

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

Se você tiver controle sobre a entidade que está retornando true/ false, uma opção é fazer com que ela retorne 1/ em 0vez de true/ false, então:

boolean_response = bool(int(response))

A conversão extra para intlidar com respostas de uma rede, que são sempre string.

Usando a função interna do Python eval()e o .capitalize()método, você pode converter qualquer string "true" / "false" (independentemente da capitalização inicial) em um verdadeiro booleano do Python.

Por exemplo:

true_false = "trUE"
type(true_false)

# OUTPUT: <type 'str'>

true_false = eval(true_false.capitalize())
type(true_false)

# OUTPUT: <type 'bool'>