Conversione da una stringa a booleana in Python?

Qualcuno sa come convertire da una stringa in un valore booleano in Python? Ho trovato questo link . Ma non sembra un modo corretto per farlo. Vale a dire utilizzando la funzionalità integrata, ecc.

Il motivo per cui lo sto chiedendo è perché ho imparato int("string")da qui. Ma quando lo prova bool("string")ritorna sempre True:

>>> bool("False")
True

Davvero, devi solo confrontare la stringa con qualsiasi cosa ti aspetti di accettare come rappresentante true, quindi puoi farlo:

s == 'True'

O per verificare un intero gruppo di valori:

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

Prestare attenzione quando si utilizza quanto segue:

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

Le stringhe vuote valutano False, ma tutto il resto lo valuta True. Quindi questo non dovrebbe essere usato per nessun tipo di analisi.

Uso:

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

I valori reali sono y, yes, t, true, on e 1; i valori falsi sono n, no, f, false, off e 0. Aumenta ValueError se val è qualcos'altro.

Fai attenzione a distutils.util.strtobool() restituisce rappresentazioni intere e quindi deve essere racchiuso bool()per ottenere valori booleani.

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

Quindi chiamalo così:

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

Gestire esplicitamente vero e falso:

Puoi anche fare in modo che la tua funzione controlli esplicitamente un vero elenco di parole e un falso elenco di parole. Quindi se non si trova in nessuno dei due elenchi, è possibile generare un'eccezione.

Il parser JSON è utile anche per convertire in generale stringhe in tipi di pitone ragionevoli.

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

A partire da Python 2.6, ora c'è ast.literal_eval :

>>> import ast
>>> aiuto (ast.literal_eval)
Aiuto sulla funzione literal_eval nel modulo ast:

literal_eval (node_or_string)
    Valuta in modo sicuro un nodo di espressione o una stringa contenente un Python
    espressione. La stringa o il nodo forniti possono consistere solo in quanto segue
    Strutture letterali di Python: stringhe, numeri, tuple, liste, dadi, booleani,
    e nessuno.

Il che sembra funzionare, purché tu sia sicuro che le tue stringhe saranno o "True"o "False":

>>> ast.literal_eval ("True")
Vero
>>> ast.literal_eval ("False")
falso
>>> ast.literal_eval ("F")
Traceback (ultima chiamata più recente):
  File "", riga 1, in 
  File "/opt/Python-2.6.1/lib/python2.6/ast.py", riga 68, in valore letterale
    return _convert (node_or_string)
  File "/opt/Python-2.6.1/lib/python2.6/ast.py", riga 67, in _convert
    raise ValueError ('stringa non valida')
ValueError: stringa non valida
>>> ast.literal_eval ("'False'")
'False'

Normalmente non lo consiglierei, ma è completamente integrato e potrebbe essere la cosa giusta a seconda delle tue esigenze.

Se sai che la stringa sarà "True"o "False", potresti semplicemente usare eval(s).

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

Utilizzalo solo se sei sicuro del contenuto della stringa, poiché genererà un'eccezione se la stringa non contiene Python valido e eseguirà anche il codice contenuto nella stringa.

Questa versione mantiene la semantica dei costruttori come int (valore) e fornisce un modo semplice per definire valori stringa accettabili.

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

Ecco la mia versione. Controlla gli elenchi di valori positivi e negativi, sollevando un'eccezione per i valori sconosciuti. E non riceve una stringa, ma qualsiasi tipo dovrebbe fare.

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

Esecuzioni campione:

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

potresti sempre fare qualcosa del genere

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

il bit in parens sarebbe valutato su False. Questo è solo un altro modo per farlo senza dover effettuare una vera chiamata di funzione.

Un trucco semplice e interessante (basato su ciò che ha pubblicato @Alan Marchiori), ma usando yaml:

import yaml

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

Se è troppo ampio, può essere perfezionato testando il risultato del tipo. Se il tipo restituito da yaml è uno str, allora non può essere trasmesso a nessun altro tipo (che mi viene in mente in ogni caso), quindi puoi gestirlo separatamente o lasciare che sia vero.

Non farò ipotesi alla velocità, ma dal momento che sto lavorando con i dati yaml sotto Qt gui, questa ha una bella simmetria.

Non sono d'accordo con nessuna soluzione qui, in quanto sono troppo permissivi. Questo non è normalmente quello che vuoi quando analizzi una stringa.

Quindi qui la soluzione che sto 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 i risultati:

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

Giusto per essere chiari perché sembra che la mia risposta abbia offeso qualcuno in qualche modo:

Il punto è che non vuoi testare solo un valore e assumere l'altro. Non penso che tu voglia sempre mappare Assolutamente tutto sul valore non analizzato. Ciò produce un codice soggetto a errori.

Quindi, se sai in cosa vuoi codificarlo.

Un dict (davvero, un defaultdict) ti dà un modo abbastanza semplice per fare questo trucco:

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

È davvero facile personalizzare questo metodo in base all'esatto comportamento di conversione desiderato: puoi riempirlo con i valori di Verità e Falsi consentiti e lasciarlo sollevare un'eccezione (o restituire Nessuno) quando non viene trovato un valore o, per impostazione predefinita, True, o il valore predefinito è False o quello che vuoi.

Probabilmente hai già una soluzione, ma per gli altri che sono alla ricerca di un metodo per convertire un valore in un valore booleano utilizzando valori falsi "standard" tra cui None, [], {} e "" oltre a false, no 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

Puoi semplicemente usare la funzione integrata 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 l'output:

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

Ancora un'altra opzione

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

Ma in produzione se non hai bisogno di rispondere e di tutte le sue dipendenze, una buona idea è quella di guardare il suo codice sorgente e copiare parte della logica di cui hai bisogno.

La regola di consueto per la fusione a un bool è che pochi letterali speciali ( False, 0, 0.0, (), [], {}) sono false e poi tutto il resto è vero, quindi vi consiglio il seguente:

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

Questa è la versione che ho scritto. Combina diverse altre soluzioni in una.

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 ottiene una stringa si aspetta valori specifici, altrimenti genera un'eccezione. Se non ottiene una stringa, lascia che il costruttore bool lo capisca. Testato questi casi:

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 sai che il tuo input sarà "Vero" o "Falso", allora perché non usare:

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

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

Mi piace usare l'operatore ternario per questo, dal momento che è un po 'più sintetico per qualcosa che sembra non dovrebbe essere più di 1 riga.

True if myString=="True" else False

Mi rendo conto che questo è un vecchio post, ma alcune delle soluzioni richiedono un bel po 'di codice, ecco cosa ho finito per usare:

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

Usa il pacchetto str2bool pip install str2bool

Se ti piaccio ho solo bisogno di un valore booleano dalla variabile che è stringa. Puoi usare i distillati come menzionato in precedenza da @jzwiener. Tuttavia, non ho potuto importare e utilizzare il modulo come ha suggerito.

Invece finisco per usarlo in questo modo su python3.7

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

distutils fa parte della libreria std lib di Python, quindi non necessita di installazione. Che è grandioso! 👍

Vorrei condividere la mia semplice soluzione: utilizzare il eval(). Converte la stringa Truee Falsenel corretto tipo booleano SE la stringa è esattamente nel formato del titolo TrueoFalse sempre in maiuscolo o altrimenti la funzione genererà un errore.

per esempio

>>> eval('False')
False

>>> eval('True')
True

Naturalmente per la variabile dinamica puoi semplicemente usare il .title()per formattare la stringa booleana.

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

Questo genererà un errore.

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

ecco un peloso, costruito in modo da ottenere molte delle stesse risposte. Nota che sebbene Python consideri ""falso e tutte le altre stringhe vere, TCL ha un'idea molto diversa sulle cose.

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

Un aspetto positivo è che perdona abbastanza i valori che puoi usare. È pigro nel trasformare le stringhe in valori, ed è igienico riguardo a ciò che accetta e rifiuta (nota che se l'istruzione precedente fosse data al prompt di tcl, cancellerebbe il disco fisso dell'utente).

la cosa brutta è che richiede che Tkinter sia disponibile, che di solito, ma non è universalmente vero, e più significativamente, richiede che venga creata un'istanza Tk, che è relativamente pesante.

Ciò che è considerato vero o falso dipende dal comportamento del Tcl_GetBoolean, che considera 0, false, noed offè falso e 1, true, yese onper essere vero, case insensitive. Qualsiasi altra stringa, inclusa la stringa vuota, provoca un'eccezione.

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

idea: controlla se vuoi che la stringa sia valutata su False; altrimenti bool () restituisce True per qualsiasi stringa non vuota.

Ecco qualcosa che ho messo insieme per valutare la veridicità di una stringa:

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)

più o meno gli stessi risultati dell'utilizzo evalma più sicuri.

Ho dovuto farlo ... quindi forse in ritardo alla festa - ma qualcuno potrebbe trovarlo utile

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 hai il controllo sull'entità che sta restituendo true/ false, un'opzione è di restituirla 1/ 0invece di true/ false, quindi:

boolean_response = bool(int(response))

Il cast extra per intgestire le risposte da una rete, che sono sempre stringhe.

Usando la funzione integrata di Python eval()e il.capitalize() metodo, è possibile convertire qualsiasi stringa "true" / "false" (indipendentemente dalla maiuscola iniziale) in un vero valore booleano Python.

Per esempio:

true_false = "trUE"
type(true_false)

# OUTPUT: <type 'str'>

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

# OUTPUT: <type 'bool'>