Converteren van een string naar boolean in Python?

Weet iemand hoe je een string naar een boolean converteert in Python? Ik vond deze link . Maar het lijkt niet de juiste manier om het te doen. D.w.z. met behulp van ingebouwde functionaliteit, enz.

De reden dat ik dit vraag is omdat ik van hier heb geleerd over int("string"). Maar als je bool("string")probeert, wordt altijd Truegeretourneerd:

>>> bool("False")
True

Antwoord 1, autoriteit 100%

Echt, je vergelijkt de tekenreeks gewoon met wat je verwacht te accepteren als waar, dus je kunt dit doen:

s == 'True'

Of om te controleren op een hele reeks waarden:

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

Wees voorzichtig bij het gebruik van het volgende:

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

Lege tekenreeksen worden geëvalueerd als False, maar al het andere wordt geëvalueerd als True. Dit mag dus niet worden gebruikt voor enige vorm van parseerdoeleinden.

Antwoord 2, autoriteit 43%

Gebruik:

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

Echte waarden zijn y, yes, t, true, on en 1; false waarden zijn n, no, f, false, off en 0. Verhoogt ValueError als val iets anders is.

Houd er rekening mee dat distutils.util.strtobool()integer-representaties retourneert en dat het daarom moet worden omwikkeld met bool()om Booleaanse waarden te krijgen.

Antwoord 3, autoriteit 29%

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

Noem het dan zo:

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

Waar en onwaar expliciet verwerken:

U kunt uw functie ook expliciet laten controleren op een True-lijst met woorden en een False-lijst met woorden. Als het dan in geen van beide lijsten staat, kun je een uitzondering maken.

Antwoord 4, autoriteit 14%

De JSON-parser is ook handig voor het in het algemeen converteren van strings naar redelijke python-types.

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

Antwoord 5, Autoriteit 12%

Beginnen met Python 2.6 is er nu ast.literal_eval:

& GT; & GT; & GT; importeer AST
& GT; & GT; & GT; Help (AST.LITERALAL_EVAL)
Help op functie Literal_Eval in Module AST:
Literal_Eval (Node_OR_String)
  Veilig evalueren van een expressieknooppunt of een tekenreeks met een python
  uitdrukking. De verstrekte tekenreeks of knooppunt kan alleen uit het volgende bestaan
  Python letterlijke structuren: snaren, cijfers, tuples, lijsten, dicts, booleinden,
  en geen.

die lijkt te werken, zolang je zeker bent je snaren zijn "True"of "False":

& GT; & GT; & GT; ast.literal_eval ("True")
Waar
& GT; & GT; & GT; ast.literal_eval ("false")
Vals
& GT; & GT; & GT; AST.LITERAL_EVAL ("F")
Hertraceren (meest recente oproep als laatste)
 Bestand "", regel 1, in
 Bestand "/opt/python-2.6.1/lib/python2.6/ast.py", lijn 68, in Literal_Eval
  RETURN _CONVERT (NODE_OR_STRING)
 Bestand "/opt/python-2.6.1/lib/python2.6/ast.py", lijn 67, in _convert
  verhogen waardeerror ('misvormde string')
ValueError: misvormde string
& GT; & GT; & GT; ast.literal_eval ("'false'")
'FALSE'

Ik zou dit normaal niet aanbevelen, maar het is volledig ingebouwd en kan het juiste zijn, afhankelijk van uw vereisten.

Antwoord 6, Autoriteit 6%

Als u weet dat de tekenreeks "True"of "False"is, kunt u gewoon eval(s)gebruiken.

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

Gebruik dit alleen als u echter zeker bent van de inhoud van de snaar, omdat deze een uitzondering zal gooien als de tekenreeks geen geldige Python bevat en de code ook in de tekenreeks bevat.

Antwoord 7, Autoriteit 2%

Deze versie behoudt de semantiek van constructors zoals int(value) en biedt een gemakkelijke manier om acceptabele tekenreekswaarden te definiëren.

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

Antwoord 8, autoriteit 2%

UPDATE

OPMERKING:GEBRUIK NOOIT eval()ALS het een invoer rechtstreeks van de gebruiker vraagt, omdat het zeer onderhevig is aan misbruik:

eval('os.system(‘rm -rf /’)')

Maar hoera! Onderzoek vindt ook dat eval()niet slecht is en dat het perfect is voor VERTROUWDE CODE. Je kunt het gebruiken om een booleaanse tekenreeks zoals "False"en "True"om te zetten naar een booleaans type.

Ik wil graag mijn eenvoudige oplossing delen: gebruik de eval(). Het zal de tekenreeksen Trueen Falsenaar het juiste booleaanse type converteren ALS de tekenreeks exact de titelindeling Trueof Falsealtijd een hoofdletter, anders geeft de functie een fout.

bijv.

>>> eval('False')
False
>>> eval('True')
True

Natuurlijk kun je voor dynamische variabelen eenvoudig de .title()gebruiken om de booleaanse tekenreeks op te maken.

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

Dit geeft een foutmelding.

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

Antwoord 9

Hier is mijn versie. Het controleert op zowel positieve als negatieve waardenlijsten, het verhogen van een uitzondering voor onbekende waarden. En het ontvangt geen tekenreeks, maar elk type zou moeten doen.

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

Sample-runs:

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

Antwoord 10

U kunt altijd iets doen als

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

Het bit in Parens zou evalueren naar False. Dit is gewoon een andere manier om het te doen zonder een echte functie-oproep te hoeven doen.

Antwoord 11

Een koele, eenvoudige truc (gebaseerd op wat @Alan Marchiori is geplaatst), maar met behulp van YAML:

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

Als dit te breed is, kan het worden verfijnd door het type resultaat te testen. Als het YAML-geretourneerde type een str is, kan het dan niet naar een ander type worden gegoten (dat ik toch kan bedenken), zodat u dat afzonderlijk aankan, of laat het gewoon waar zijn.

Ik zal geen gissingen op snelheid maken, maar omdat ik toch met YAML-gegevens onder QT GUI werk, heeft dit een leuke symmetrie.

Antwoord 12

Ik ben het hier niet eens met een oplossing, zoals ze te toegestaan ​​zijn. Dit is normaal niet wat u wilt bij het parseren van een string.

Dus hier de oplossing die ik gebruik:

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)

en de resultaten:

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

Voor alle duidelijkheid, want het lijkt alsof mijn antwoord iemand op de een of andere manier heeft beledigd:

Het punt is dat je niet op slechts één waarde wilt testen en de andere wilt aannemen. Ik denk niet dat je absoluut alles altijd wilt toewijzen aan de niet-geparseerde waarde. Dat levert foutgevoelige code op.

Dus, als je weet waarin je het wilt coderen.

Antwoord 13

Een dictaat (eigenlijk een standaarddictaat) geeft je een vrij gemakkelijke manier om deze truc uit te voeren:

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

Het is heel eenvoudig om deze methode aan te passen aan het exacte conversiegedrag dat je wilt — je kunt het vullen met toegestane Waarheids- en Valswaarden en het een uitzondering laten maken (of Geen teruggeven) wanneer een waarde niet wordt gevonden, of standaard op True, of standaard op False, of wat u maar wilt.

Antwoord 14

Ik gebruik

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

Antwoord 15

U heeft waarschijnlijk al een oplossing, maar voor anderen die op zoek zijn naar een methode om een waarde om te zetten in een booleaanse waarde met behulp van “standaard” valse waarden, waaronder Geen, [], {} en “” naast onwaar, nee , en 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

Antwoord 16

Nog een andere optie

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

Antwoord 17

De gebruikelijke regel voor het gieten naar een bool is dat een paar speciale literaten (False, 0, 0.0, (), [], {}) zijn onwaar en dan is al het andere waar, dus ik raad het volgende aan:

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

Antwoord 18

Dit is de versie die ik heb geschreven. Combineert verschillende van de andere oplossingen in één.

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)

Als het een string krijgt, verwacht het specifieke waarden, anders wordt er een Exception gegenereerd. Als het geen string krijgt, laat de bool-constructor het dan uitzoeken. Deze gevallen getest:

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

Antwoord 19

Als u weet dat uw invoer “True” of “False” zal zijn, waarom gebruikt u dan niet:

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

Antwoord 20

Ik gebruik hiervoor graag de ternaire operator, omdat het een beetje beknopter is voor iets dat aanvoelt alsof het niet meer dan 1 regel zou moeten zijn.

True if myString=="True" else False

Antwoord 21

Ik realiseer me dat dit een oud bericht is, maar voor sommige oplossingen is nogal wat code nodig, dit is wat ik uiteindelijk heb gebruikt:

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

Antwoord 22

Als je me leuk vindt, heb je alleen een boolean nodig van de variabele die string is. Je kunt distillaten gebruiken zoals eerder vermeld door @jzwiener. Ik kon de module echter niet importeren en gebruiken zoals hij voorstelde.

In plaats daarvan gebruik ik het op deze manier op python3.7

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

distutils maakt deel uit van de python std lib, dus installatie is niet nodig. Wat geweldig is!👍

Antwoord 23

Als je controle hebt over de entiteit die True/Falseretourneert, is een optie om deze 1/0in plaats van True/False, dan:

boolean_response = bool(int(response))

De extra cast naar intverwerkt reacties van een netwerk, die altijd strings zijn.

Update 2021: “die altijd een string zijn” — dit is een naïeve observatie. Dit hangt af van het serialisatieprotocol dat door de bibliotheek wordt gebruikt. Standaardserialisatie van bibliotheken op hoog niveau (die door de meeste webontwikkelaars worden gebruikt) is meestal om te converteren naar string voordat ze worden geserialiseerd naar bytes. En aan de andere kant is het gedeserialiseerd van bytes naar string, dus je bent alle type-informatie kwijt.

Antwoord 24

Gebruik pakket str2boolpip install str2bool

Antwoord 25

Hier is een harige, gebouwd als een manier om veel van dezelfde antwoorden te krijgen. Merk op dat hoewel Python ""onjuist acht en alle andere snaren waar is, TCL heeft een heel ander idee over dingen.

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

Een goede zaak hierover is dat het redelijk vergevingsgezind is over de waarden die u kunt gebruiken. Het is lui over het draaien van snaren in waarden, en het is hygenisch over wat het accepteert en verwerpt (merk op dat als de bovenstaande verklaring op een TCL-vraag werd gegeven, het de harde schijf van de gebruiker zou wissen).

Het slechte is dat het vereist dat TKIER beschikbaar is, wat meestal is, maar niet universeel waar, en meer aanzienlijk, vereist dat een TK-instantie wordt gemaakt, wat relatief zwaar is.

Wat als waar of onwaar wordt beschouwd, hangt af van het gedrag van de Tcl_GetBoolean, die 0, False, noen offom onwaar te zijn en 1, True, yesen onom waar te zijn, niet hoofdlettergevoelig. Elke andere string, inclusief de lege string, veroorzaakt een uitzondering.

Antwoord 26

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

idee: controleer of je wilt dat de string wordt geëvalueerd als False; anders geeft bool() True terug voor elke niet-lege tekenreeks.

Antwoord 27

Hier is iets wat ik bij elkaar heb gegooid om de waarheid van een string te evalueren:

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)

min of meer dezelfde resultaten als het gebruik van evalmaar veiliger.

Antwoord 28

Ik moest dit gewoon doen… dus misschien te laat op het feest, maar misschien vindt iemand het nuttig

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

Antwoord 29

Ik moest ook de invoer wijzigen in boolvoor een functie en de hoofdinvoer was alleen Trueof Falsein string. Dus ik heb het zo gecodeerd:

def string_to_bool(s):
    bool_flag = True
    if s == "False":
        bool_flag = False
    elif s == "True":
        bool_flag = True
    else:
        print("Invalid Input")
    return bool_flag

Je kunt het ook controleren op meer afgekort voor Trueen Falsezoals y/nof y/nenz.

Antwoord 30

U kunt ook elke letterlijke tekenreeks evalueren:

import ast
ast.literal_eval('True')  # True
type(ast.literal_eval('True'))  # <class 'bool'>
ls = '[1, 2, 3]'
ast.literal_eval(ls)  # [1, 2, 3]
type(ast.literal_eval(ls))  # <class 'list'>