it-swarm.com.de

In Python von einem String in einen Boolean konvertieren?

Weiß jemand, wie man einen String in einen Boolean in Python konvertiert? Ich habe diesen Link gefunden. Aber es sieht nicht nach einem geeigneten Weg aus. Das heißt Verwenden einer integrierten Funktionalität usw.

BEARBEITEN:

Der Grund, warum ich das gefragt habe, ist, weil ich int("string") von hier gelernt habe. Ich habe bool("string") probiert, habe aber immer True bekommen.

>>> bool("False")
True
545
Joan Venge

Sie vergleichen die Zeichenfolge wirklich mit dem, was Sie als wahr akzeptieren möchten, damit Sie dies tun können:

s == 'True'

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

s 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 als False ausgewertet, alles andere jedoch als True. Daher sollte dies nicht für irgendwelche Parsing-Zwecke verwendet werden.

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

Dann nennen Sie es so:

str2bool("yes")

> True

str2bool("no")

> False

str2bool("stuff")

> False

str2bool("1")

> True

str2bool("0")

> False


explizit mit wahr und falsch umgehen:

Sie können Ihre Funktion auch explizit gegen eine True-Liste von Wörtern und eine False-Liste von Wörtern prüfen. Wenn es sich in keiner der Listen befindet, können Sie eine Ausnahme auslösen. 

221
Brian R. Bondy

Benutz einfach:

distutils.util.strtobool(some_string)

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

Richtige Werte sind y, ja, t, wahr, ein und 1; false-Werte sind n, no, f, false, off und 0. Löst ValueError aus, wenn val etwas anderes ist.

200
jzwiener

Ab Python 2.6 gibt es jetzt ast.literal_eval:

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

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

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

 >>> ast.literal_eval ("True") 
 True 
 >>> ast.literal_eval ("False") 
 False 
 >>> 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 
 Rückgabe _convert (node_or_string) 
 Datei "/opt/Python-2.6.1/lib/python2.6/ast.py", Zeile 67, in _convert 
 raise ValueError ('fehlerhafter String') 
 ValueError: fehlerhafter String 
 >>> ast.literal_eval ('' False '') 
 'False' 

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

101

Der JSON-Parser ist auch nützlich, um Strings generell in sinnvolle Python-Typen zu konvertieren.

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

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
14

Hier ist meine Version. Es prüft sowohl nach positiven als auch nach negativen Wertelisten, wodurch eine Ausnahme für unbekannte Werte ausgelöst wird. 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
>>>
12
Petrucio

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

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

Verwenden Sie dies nur, wenn Sie sich des Inhalts der Zeichenfolge sicher sind, da dies eine Ausnahme auslöst, wenn die Zeichenfolge kein gültiges Python enthält und auch in der Zeichenfolge enthaltenen Code ausführt.

10
Joel Croteau

sie könnten immer etwas tun 

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

das Bit in Parens würde zu False ausgewertet. Dies ist nur eine andere Möglichkeit, dies zu tun, ohne einen eigentlichen Funktionsaufruf durchführen zu müssen.

9
helloandre

Sie können einfach die eingebaute 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'>
8
lumartor

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

Also hier die Lösung, die ich verwende:

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, weil es so aussieht, als würde meine Antwort jemanden irgendwie beleidigen:

Der Punkt ist, dass Sie nicht nur für einen Wert testen und den anderen annehmen wollen. Ich denke nicht, dass Sie immer alles absolut auf den nicht geparsten Wert abbilden wollen. Dies führt zu fehleranfälligem Code.

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

7
estani

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 dieser Wert zu groß ist, kann er 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 (den ich mir ohnehin vorstellen kann), sodass Sie das separat behandeln können oder es einfach wahr lassen können.

Ich schätze nicht schnell, aber da ich sowieso mit Qt-gui mit yaml-Daten arbeite, hat dies eine Nizza-Symmetrie.

6
Rafe

Ein Diktat (wirklich ein Standarddikt) bietet Ihnen eine recht 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 sehr einfach, diese Methode an das genaue Konvertierungsverhalten anzupassen, das Sie möchten. Sie können sie mit zulässigen Werten für Truthy und Falsy füllen und eine Ausnahme auslösen (oder None zurückgeben), wenn ein Wert nicht gefunden wird, oder standardmäßig auf True oder standardmäßig auf False oder was immer Sie möchten.

5
Nate

Sie haben wahrscheinlich bereits eine Lösung, aber für andere, die nach einer Methode suchen, um einen Wert in einen booleschen Wert umzuwandeln, indem Sie "Standardwerte" verwenden, einschließlich falscher Werte wie 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
5
Chris McMillan

Mir ist klar, dass dies ein alter Beitrag ist, aber für einige Lösungen ist ziemlich viel Code erforderlich.

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

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 es einen String erhält, erwartet es bestimmte Werte, ansonsten wird eine Exception ausgelöst. Wenn es keine Zeichenfolge erhält, lässt es den bool-Konstruktor nur 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),
    ]
3
Tom Ekberg

Die übliche Regel für das Umwandeln in einen Bool ist, dass einige spezielle Literale (False, 0, 0.0, (), [], {}) falsch sind und dann alles andere wahr ist. Daher empfehle ich Folgendes:

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

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

True if myString=="True" else False
2
Clayton Rabenda

Wenn Sie wissen, dass Ihre Eingabe entweder "True" oder "False" ist, dann verwenden Sie nicht

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

Noch eine Option

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

Wenn Sie in der Produktion jedoch nicht ansible und all seine Abhängigkeiten benötigen, ist es eine gute Idee, sich den Quellcode anzusehen und einen Teil der erforderlichen Logik zu kopieren: https://github.com/ansible/ansible/blob/2bd6b1415b9131c3a7cb13724f5d31bb0d33846b /lib/ansible/module_utils/parsing/convert_bool.py

1
Maciej Kucia

Ich musste das einfach tun ... also vielleicht zu spät zur Party - aber jemand findet es 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
0
Rcynic

Wenn du mich magst, brauchst du nur einen Booleschen Wert aus der Variable string. Sie können Destillate verwenden, wie bereits von @jzwiener erwähnt. Ich konnte das Modul jedoch nicht wie vorgeschlagen importieren und verwenden.

Stattdessen benutze ich es unter python3.7 auf diese Weise

distutils string to bool in python

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 std lib, daher ist keine Installation erforderlich. Welches ist toll! ????

0
Gunay Anach

hier ist ein haariger, eingebauter Weg, um viele der gleichen Antworten zu erhalten. Beachten Sie, dass, obwohl Python "" für falsch und alle anderen Strings für wahr hält, TCL eine ganz andere Vorstellung davon 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 /']"
>>> 

Das Gute daran ist, dass die Werte, die Sie verwenden können, ziemlich nachsichtig sind. Es ist faul, Strings in Werte umzuwandeln, und es ist hygienisch, was sie akzeptiert und ablehnt (beachten Sie, dass die Festplatte des Benutzers gelöscht würde, wenn die obige Anweisung an einem tcl-Prompt abgegeben würde). 

das Schlechte ist, dass Tkinter verfügbar sein muss, was normalerweise, aber nicht allgemein zutreffend ist, und, was noch wichtiger ist, die Erstellung einer Tk-Instanz, die vergleichsweise schwer ist. 

Was als wahr oder falsch angesehen wird, hängt vom Verhalten des Tcl_GetBoolean ab, der 0, false, no und off für falsch und 1, true, yes und on ist wahr, unabhängig von der Groß- und Kleinschreibung. 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: Prüfen Sie, ob die Zeichenfolge als False ausgewertet werden soll. Andernfalls gibt bool () für jeden nicht leeren String True zurück.

0
xvga

Verwenden Sie das Paket str2boolpip install str2bool

0
Headmaster

Hier ist etwas, was ich zusammengeworfen habe, um die Wahrhaftigkeit einer Schnur 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 dieselben Ergebnisse wie bei der Verwendung von eval, aber sicherer.

0
tylerl

Wenn Sie die Kontrolle über die Entität haben, die true/false zurückgibt, besteht eine Möglichkeit darin, dass sie 1/0 Anstelle von true zurückgibt. ]/false, dann:

boolean_response = bool(int(response))

Die zusätzliche Umwandlung in int behandelt Antworten von einem Netzwerk, die immer Zeichenfolgen sind.

0
Sam Malayek

Ich habe gerade fand dies einfache Lösung bei der Suche nach dem ternären Operator in Python:

(False, True)[val == "true"]

Es funktioniert seit Python True = 1 und False = 0 und sobald der Vergleich ausgewertet ist, wird das Ergebnis verwendet, um das Element anhand seines Index 0 oder 1 vom Tupel abzurufen. Ein Nachteil ist, dass es False zurückgibt für alles andere als "true", aber es funktioniert gut für mein Umgebungsvariablen-Parsing-Szenario.

0
Péter Veres