Konvertieren von einem String in einen Booleschen Wert in Python?

Weiß jemand, wie man in Python von einem String in einen Booleschen Wert konvertiert? Ich habe diesen Link gefunden . Aber es sieht nicht nach einem richtigen Weg aus. Dh mit eingebauter Funktionalität usw.

Der Grund, warum ich das frage, ist, dass ich int("string")von hier erfahren habe. Aber wenn man bool("string")es versucht , kehrt es immer zurück True:

>>> bool("False")
True

Wirklich, Sie vergleichen die Zeichenfolge einfach mit dem, was Sie als wahr ansehen möchten, damit Sie Folgendes tun können:

s == 'True'

Oder um eine ganze Reihe von Werten zu überprüfen:

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

Seien Sie vorsichtig, wenn Sie Folgendes verwenden:

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

Leere Zeichenfolgen werden ausgewertet False, aber alles andere wird ausgewertet True. Dies sollte also nicht für Parsingzwecke verwendet werden.

Verwenden:

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

Wahre Werte sind y, yes, t, true, on und 1; falsche Werte sind n, no, f, false, off und 0. Löst ValueError aus, wenn val etwas anderes ist.

Beachten Sie, dass distutils.util.strtobool()ganzzahlige Darstellungen zurückgegeben werden und daher umbrochen werden müssen bool(), um boolesche Werte zu erhalten.

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

Dann nenne es so:

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

Explizite Behandlung von wahr und falsch:

Sie können Ihre Funktion auch explizit mit einer wahren Wortliste und einer falschen Wortliste vergleichen lassen. Wenn es dann in keiner Liste enthalten ist, können Sie eine Ausnahme auslösen.

Der JSON-Parser ist auch nützlich, um Zeichenfolgen im Allgemeinen in sinnvolle Python-Typen zu konvertieren.

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

Ab Python 2.6 gibt es jetzt ast.literal_eval:

>>> import ast
>>> Hilfe (ast.literal_eval)
Hilfe zur Funktion literal_eval im Modul ast:

literal_eval (node_or_string)
    Bewerten Sie sicher einen Ausdrucksknoten oder eine Zeichenfolge, die einen Python enthält
    Ausdruck. Die angegebene Zeichenfolge oder der angegebene Knoten darf nur aus den folgenden Elementen bestehen
    Python-Literalstrukturen: Zeichenfolgen, Zahlen, Tupel, Listen, Diktate, Boolesche Werte,
    und keine.

Was zu funktionieren scheint, solange Sie sicher sind, dass Ihre Saiten entweder "True"oder sein werden "False":

>>> ast.literal_eval ("True")
Wahr
>>> ast.literal_eval ("False")
Falsch
>>> ast.literal_eval ("F")
Traceback (letzter Anruf zuletzt):
  Datei "", Zeile 1, in 
  Datei "/opt/Python-2.6.1/lib/python2.6/ast.py", Zeile 68, in literal_eval
    return _convert (node_or_string)
  Datei "/opt/Python-2.6.1/lib/python2.6/ast.py", Zeile 67, in _convert
    Erhöhen Sie ValueError ('fehlerhafter String')
ValueError: fehlerhafte Zeichenfolge
>>> ast.literal_eval ("'False'")
'Falsch'

Normalerweise würde ich das nicht empfehlen, aber es ist komplett eingebaut und könnte je nach Ihren Anforderungen das Richtige sein.

Wenn Sie wissen, dass die Zeichenfolge entweder "True"oder ist "False", können Sie sie einfach verwenden eval(s).

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

Verwenden Sie diese Option nur, wenn Sie sich über den Inhalt der Zeichenfolge sicher sind, da sie eine Ausnahme auslöst, wenn die Zeichenfolge kein gültiges Python enthält, und auch den in der Zeichenfolge enthaltenen Code ausführt.

Diese Version behält die Semantik von Konstruktoren wie int (Wert) bei und bietet eine einfache Möglichkeit, akzeptable Zeichenfolgenwerte zu definieren.

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

Hier ist meine Version. Es prüft sowohl positive als auch negative Wertelisten und löst eine Ausnahme für unbekannte Werte aus. Und es erhält keine Zeichenfolge, aber jeder Typ sollte dies tun.

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

Probeläufe:

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

man könnte immer so etwas machen

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

Das Bit in Parens würde als falsch ausgewertet. Dies ist nur eine andere Möglichkeit, ohne einen tatsächlichen Funktionsaufruf ausführen zu müssen.

Ein cooler, einfacher Trick (basierend auf dem, was @Alan Marchiori gepostet hat), aber mit yaml:

import yaml

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

Wenn dies zu breit ist, kann es durch Testen des Typergebnisses verfeinert werden. Wenn der von yaml zurückgegebene Typ ein str ist, kann er nicht in einen anderen Typ umgewandelt werden (an den ich sowieso denken kann), sodass Sie dies separat behandeln oder einfach wahr werden lassen können.

Ich werde keine Vermutungen über die Geschwindigkeit anstellen, aber da ich ohnehin mit Yaml-Daten unter Qt-GUI arbeite, hat dies eine schöne Symmetrie.

Ich bin mit keiner Lösung hier einverstanden, da sie zu freizügig sind. Dies ist normalerweise nicht das, was Sie beim Parsen einer Zeichenfolge möchten.

Also hier die Lösung, die ich benutze:

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)

Und die Ergebnisse:

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

Nur um klar zu sein, denn es sieht so aus, als ob meine Antwort jemanden irgendwie beleidigt hätte:

Der Punkt ist, dass Sie nicht nur auf einen Wert testen und den anderen annehmen möchten. Ich glaube nicht, dass Sie immer absolut alles dem nicht analysierten Wert zuordnen möchten. Das erzeugt fehleranfälligen Code.

Also, wenn Sie wissen, was Sie wollen, codieren Sie es.

Ein Diktat (wirklich ein Standarddiktat) bietet Ihnen eine ziemlich einfache Möglichkeit, diesen Trick auszuführen:

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 ist wirklich einfach, diese Methode an das gewünschte Konvertierungsverhalten anzupassen. Sie können sie mit zulässigen Werten für "Wahr" und "Falsch" füllen und eine Ausnahme auslösen (oder "Keine" zurückgeben), wenn ein Wert nicht gefunden wird, oder standardmäßig "Wahr". oder standardmäßig False oder was auch immer Sie wollen.

Sie haben wahrscheinlich bereits eine Lösung, aber für andere, die nach einer Methode suchen, um einen Wert in einen booleschen Wert zu konvertieren, wobei "falsche" Standardwerte verwendet werden, einschließlich None, [], {} und "" zusätzlich zu false, no und 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

Sie können einfach die integrierte Funktion eval () verwenden :

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)

und die Ausgabe:

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

Noch eine Option

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

Aber in der Produktion , wenn Sie brauchen nicht ansible und alle seine Abhängigkeiten, eine gute Idee ist , an seinem suchen Quellcode und kopieren Sie Teil der Logik , die Sie benötigen.

Die übliche Regel auf einen Bool zum Gießen ist , dass einige spezielle Literale ( False, 0, 0.0, (), [], {}) sind falsch und dann alles andere stimmt, so dass ich die folgende Empfehlung:

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

Dies ist die Version, die ich geschrieben habe. Kombiniert mehrere der anderen Lösungen zu einer.

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)

Wenn eine Zeichenfolge abgerufen wird, werden bestimmte Werte erwartet, andernfalls wird eine Ausnahme ausgelöst. Wenn es keine Zeichenfolge erhält, lässt es der Bool-Konstruktor einfach herausfinden. Getestet diese Fälle:

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

Wenn Sie wissen, dass Ihre Eingabe entweder "Wahr" oder "Falsch" ist, warum nicht:

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

ich benutze

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

Ich verwende dafür gerne den ternären Operator, da er für etwas, das sich so anfühlt, als ob es nicht mehr als eine Zeile sein sollte, etwas prägnanter ist.

True if myString=="True" else False

Mir ist klar, dass dies ein alter Beitrag ist, aber einige der Lösungen erfordern ziemlich viel Code. Folgendes habe ich letztendlich verwendet:

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

Verwenden Sie das Paket str2bool pip install str2bool

Wenn du mich magst, brauchst du nur einen Booleschen Wert aus einer Variablen, die ein String ist. Sie können Destillate verwenden, wie bereits von @jzwiener erwähnt. Ich konnte das Modul jedoch nicht wie vorgeschlagen importieren und verwenden.

Stattdessen verwende ich es auf Python3.7 auf diese Weise

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

distutils ist Teil der Python-Standardbibliothek, sodass keine Installation erforderlich ist. Was toll ist! 👍

Ich möchte meine einfache Lösung teilen: Verwenden Sie die eval(). Es konvertiert die Zeichenfolge Trueund Falsein den richtigen booleschen Typ, wenn die Zeichenfolge genau im Titelformat Trueoder Falseimmer in Großbuchstaben geschrieben ist oder die Funktion einen Fehler auslöst.

z.B

>>> eval('False')
False

>>> eval('True')
True

Natürlich können Sie für dynamische Variablen einfach die verwenden, .title()um die boolesche Zeichenfolge zu formatieren.

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

Dies wird einen Fehler auslösen.

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

Hier ist eine haarige, eingebaute Methode, um viele der gleichen Antworten zu erhalten. Beachten Sie, dass ""TCL , obwohl Python als falsch und alle anderen Zeichenfolgen als wahr betrachtet, eine ganz andere Vorstellung von Dingen hat.

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

Eine gute Sache dabei ist, dass es ziemlich verzeihend ist, welche Werte Sie verwenden können. Es ist faul, Strings in Werte umzuwandeln, und es ist hygienisch, was es akzeptiert und ablehnt (beachten Sie, dass die obige Anweisung bei einer tcl-Eingabeaufforderung die Festplatte des Benutzers löschen würde).

Das Schlimme ist, dass Tkinter verfügbar sein muss, was normalerweise, aber nicht allgemein gültig ist, und vor allem, dass eine Tk-Instanz erstellt werden muss, die vergleichsweise schwer ist.

Was ist wahr oder falsch betrachtet , hängt von dem Verhalten der Tcl_GetBoolean, die der Auffassung ist 0, false, nound offfalsch zu sein und 1, true, yesund onwahr, Groß- und Kleinschreibung zu sein. Jede andere Zeichenfolge, einschließlich der leeren Zeichenfolge, verursacht eine Ausnahme.

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

Idee: Überprüfen Sie, ob die Zeichenfolge auf False ausgewertet werden soll. Andernfalls gibt bool () True für jede nicht leere Zeichenfolge zurück.

Hier ist etwas, das ich zusammengeschmissen habe, um die Wahrhaftigkeit einer Zeichenfolge zu bewerten:

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)

mehr oder weniger die gleichen Ergebnisse wie bei der Verwendung, evalaber sicherer.

Ich musste das nur tun ... also vielleicht zu spät zur Party - aber jemand findet es vielleicht nützlich

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

Wenn Sie die Kontrolle über die Entität haben, die true/ zurückgibt false, besteht eine Option darin, sie 1/ 0anstelle von true/ zurückzugeben false, dann:

boolean_response = bool(int(response))

Die zusätzliche Besetzung für die intVerarbeitung von Antworten aus einem Netzwerk, die immer Zeichenfolgen sind.

Durch die Verwendung der in Python integrierten eval()Funktion und der.capitalize() Methode können Sie eine beliebige Zeichenfolge "true" / "false" (unabhängig von der Anfangsbuchstaben) in einen echten Python-Booleschen Wert konvertieren.

Zum Beispiel:

true_false = "trUE"
type(true_false)

# OUTPUT: <type 'str'>

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

# OUTPUT: <type 'bool'>