Konwertujesz ciąg znaków na wartość logiczną w Pythonie?

Czy ktoś wie, jak wykonać konwersję z ciągu znaków na wartość logiczną w Pythonie? Znalazłem ten link . Ale to nie wygląda na właściwy sposób. Tj. Przy użyciu wbudowanej funkcjonalności itp.

Pytam o to, ponieważ dowiedziałem się o tym int("string")stąd. Ale podczas próby bool("string")zawsze zwraca True:

>>> bool("False")
True

Naprawdę po prostu porównujesz ciąg znaków z tym, co spodziewasz się zaakceptować jako reprezentujące prawdę, więc możesz to zrobić:

s == 'True'

Lub w celu sprawdzenia całej gamy wartości:

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

Zachowaj ostrożność podczas korzystania z następujących opcji:

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

Puste ciągi wartości do False, ale wszystko inne do wartości True. Dlatego nie należy tego używać do jakichkolwiek celów analizy.

Posługiwać się:

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

Prawdziwe wartości to y, tak, t, prawda, on i 1; fałszywe wartości to n, no, f, false, off i 0. Podnosi wartośćError, jeśli val jest czymś innym.

Należy pamiętać, że distutils.util.strtobool()zwraca reprezentacje liczb całkowitych, dlatego należy je zapakować, bool()aby uzyskać wartości logiczne.

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

Nazwij to tak:

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

Obsługa prawdy i fałszu w sposób jawny:

Możesz także sprawić, aby funkcja jawnie sprawdzała z prawdziwą listą słów i fałszywą listą słów. Następnie, jeśli nie ma jej na żadnej liście, możesz zgłosić wyjątek.

Parser JSON jest również przydatny do ogólnej konwersji ciągów znaków na rozsądne typy python.

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

Począwszy od Python 2.6, teraz jest ast.literal_eval:

>>> import ast
>>> pomoc (ast.literal_eval)
Pomoc na temat funkcji literal_eval w module ast:

literal_eval (node_or_string)
    Bezpiecznie oceń węzeł wyrażenia lub ciąg znaków zawierający Python
    wyrażenie. Podany ciąg lub węzeł może składać się tylko z następujących elementów
    Struktury dosłowne w języku Python: ciągi, liczby, krotki, listy, dykta, booleany,
    i brak.

Który wydaje się działać tak długo, jak jesteś pewien struny zamiar być "True"albo "False":

>>> ast.literal_eval („True”)
Prawdziwe
>>> ast.literal_eval („False”)
Fałszywe
>>> ast.literal_eval („F”)
Traceback (ostatnie połączenie ostatnio):
  Plik „”, wiersz 1, w 
  Plik „/opt/Python-2.6.1/lib/python2.6/ast.py”, wiersz 68, w literale_eval
    return _convert (node_or_string)
  Plik „/opt/Python-2.6.1/lib/python2.6/ast.py”, wiersz 67, w _convert
    raise ValueError („źle sformułowany ciąg”)
ValueError: źle sformułowany ciąg
>>> ast.literal_eval („„ False ””)
'Fałszywe'

Zwykle nie polecałbym tego, ale jest on całkowicie wbudowany i może być właściwy w zależności od twoich wymagań.

Jeśli wiesz, że ciąg będzie albo "True"albo "False", możesz po prostu użyć eval(s).

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

Używaj tego tylko wtedy, gdy masz pewność co do zawartości łańcucha, ponieważ spowoduje to wyjątek, jeśli łańcuch nie zawiera prawidłowego języka Python, a także wykona kod zawarty w łańcuchu.

Ta wersja zachowuje semantykę konstruktorów, takich jak int (wartość) i zapewnia łatwy sposób definiowania akceptowalnych wartości ciągu.

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

Oto moja wersja. Sprawdza zarówno listy wartości dodatnich, jak i ujemnych, zgłaszając wyjątek dla nieznanych wartości. I nie otrzymuje ciągu, ale każdy typ powinien.

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

Przykładowe przebiegi:

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

zawsze możesz zrobić coś takiego

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

bit w parens miałby wartość False. To tylko kolejny sposób na zrobienie tego bez konieczności wykonywania rzeczywistego wywołania funkcji.

Fajna, prosta sztuczka (na podstawie tego, co napisał @Alan Marchiori), ale przy użyciu yaml:

import yaml

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

Jeśli jest zbyt szeroki, można go ulepszyć, testując wynik typu. Jeśli typ zwracany przez yaml jest str, to nie można go rzutować na żaden inny typ (który i tak mogę wymyślić), więc możesz sobie z tym poradzić osobno lub po prostu pozwolić, by to była prawda.

Nie będę zgadywał z dużą szybkością, ale ponieważ i tak pracuję z danymi yaml pod Qt gui, ma to niezłą symetrię.

Nie zgadzam się z żadnym rozwiązaniem tutaj, ponieważ są zbyt liberalne. Zwykle nie jest to pożądane podczas analizowania łańcucha.

Więc tutaj używam rozwiązania:

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)

A wyniki:

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

Żeby było jasne, bo wygląda na to, że moja odpowiedź jakoś uraziła kogoś:

Chodzi o to, że nie chcesz testować tylko jednej wartości i zakładać drugą. Nie sądzę, żebyś zawsze chciał mapować Absolutnie wszystko na nieparsowaną wartość. To powoduje powstanie kodu podatnego na błędy.

Więc jeśli wiesz, w co chcesz to zakodować.

Dict (tak naprawdę defaultdict) daje całkiem prosty sposób na wykonanie tej sztuczki:

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

Naprawdę łatwo jest dostosować tę metodę do konkretnego pożądanego zachowania konwersji - możesz wypełnić ją dozwolonymi wartościami Prawdy i Falsy i pozwolić na zgłoszenie wyjątku (lub zwrócenie Brak), gdy wartość nie zostanie znaleziona, lub domyślna wartość Prawda, lub domyślnie False lub cokolwiek chcesz.

Prawdopodobnie masz już rozwiązanie, ale dla innych, którzy szukają metody konwersji wartości na wartość logiczną przy użyciu „standardowych” wartości fałszywych, w tym None, [], {} i „” oprócz false, no i 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

Możesz po prostu użyć wbudowanej funkcji 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)

i wynik:

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

Jeszcze jedna opcja

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

Ale w produkcji, jeśli nie potrzebujesz ansibla i wszystkich jego zależności, dobrym pomysłem jest przyjrzenie się jego kodowi źródłowemu i skopiowanie potrzebnej logiki.

Zazwyczaj zasada oddawania do bool jest to, że kilka specjalnych literały ( False, 0, 0.0, (), [], {}) są fałszywe i wtedy wszystko jest prawdą, więc polecam, co następuje:

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

To jest wersja, którą napisałem. Łączy kilka innych rozwiązań w jedno.

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)

Jeśli otrzyma ciąg, oczekuje określonych wartości, w przeciwnym razie powstaje wyjątek. Jeśli nie otrzyma łańcucha, pozwól konstruktorowi bool go rozgryźć. Testowałem te przypadki:

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

Jeśli wiesz, że dane wejściowe będą „Prawda” lub „Fałsz”, dlaczego nie użyć:

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

używam

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

W tym celu lubię używać trójskładnikowego operatora, ponieważ jest on bardziej zwięzły w przypadku czegoś, co wydaje się nie powinno być dłuższe niż 1 linia.

True if myString=="True" else False

Zdaję sobie sprawę, że jest to stary post, ale niektóre rozwiązania wymagają sporo kodu, oto co wykorzystałem:

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

Użyj pakietu str2bool pip install str2bool

Jeśli mnie lubisz, po prostu potrzebujesz wartości logicznej ze zmiennej, która jest łańcuchem. Możesz używać destylów, jak wspomniano wcześniej przez @jzwiener. Nie mogłem jednak zaimportować i użyć modułu, jak zasugerował.

Zamiast tego używam go w ten sposób na python3.7

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

distutils jest częścią biblioteki Python std lib, więc nie ma potrzeby instalacji. Który jest świetny! 👍

Chciałbym podzielić się moim prostym rozwiązaniem: użyj eval(). Przekształci ciąg Truei Falsena odpowiedni typ boolowski, JEŻELI łańcuch będzie dokładnie w formacie tytułu Truelub Falsezawsze pierwsza litera, w przeciwnym razie funkcja zgłosi błąd.

na przykład

>>> eval('False')
False

>>> eval('True')
True

Oczywiście dla zmiennej dynamicznej możesz po prostu użyć .title()do sformatowania łańcucha boolowskiego.

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

Spowoduje to błąd.

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

tutaj jest włochaty, zbudowany w taki sposób, aby uzyskać wiele takich samych odpowiedzi. Zauważ, że chociaż python uważa ""się za fałszywy, a wszystkie inne ciągi za prawdziwe, TCL ma zupełnie inne zdanie na ten temat.

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

Dobrą rzeczą jest to, że dość wybacza wartości, których możesz użyć. Leniwy jest przekształcanie ciągów znaków w wartościowe i higieniczny w kwestii tego, co akceptuje i odrzuca (zauważ, że jeśli powyższe oświadczenie zostanie podane w monicie tcl, spowoduje to usunięcie dysku twardego użytkownika).

złą rzeczą jest to, że wymaga, aby Tkinter był dostępny, co jest zwykle, ale nie ogólnie prawdziwe, a co ważniejsze, wymaga utworzenia instancji Tk, która jest stosunkowo ciężka.

Co jest uważane za prawdziwe lub fałszywe zależy od zachowania Tcl_GetBoolean, która uważa 0, false, noi offbyć fałszywe i 1, true, yesi onaby mogło być prawdziwe, z uwzględnieniem wielkości liter. Każdy inny ciąg, w tym pusty ciąg, powoduje wyjątek.

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

pomysł: sprawdź, czy chcesz, aby ciąg był oceniany na False; w przeciwnym razie bool () zwraca True dla każdego niepustego ciągu.

Oto coś, co zebrałem, aby ocenić prawdziwość struny:

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)

mniej więcej takie same wyniki jak używanie, evalale bezpieczniejsze.

Musiałem to zrobić ... więc może późno na imprezę - ale ktoś może uznać to za przydatne

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

Jeśli masz kontrolę nad podmiotem, który zwraca true/ false, jedną z opcji jest zwrócenie go 1/ / 0zamiast true/ false, a następnie:

boolean_response = bool(int(response))

Dodatkowa obsada intobsługuje odpowiedzi z sieci, które zawsze są ciągami.

Za pomocą wbudowanej eval()funkcji Pythona i.capitalize() metody , możesz przekonwertować dowolny ciąg „prawda” / „fałsz” (niezależnie od początkowej wielkiej litery) na prawdziwą wartość logiczną języka Python.

Na przykład:

true_false = "trUE"
type(true_false)

# OUTPUT: <type 'str'>

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

# OUTPUT: <type 'bool'>