Conversion d'une chaîne en booléen en Python?

Quelqu'un sait-il comment convertir une chaîne en un booléen en Python? J'ai trouvé ce lien . Mais cela ne semble pas être une bonne façon de procéder. C'est-à-dire en utilisant des fonctionnalités intégrées, etc.

La raison pour laquelle je pose cette question, c'est parce que j'ai appris int("string")d'ici. Mais en essayant, bool("string")il revient toujours True:

>>> bool("False")
True

Vraiment, vous comparez simplement la chaîne à tout ce que vous pensez accepter comme représentant vrai, vous pouvez donc faire ceci:

s == 'True'

Ou pour vérifier par rapport à tout un tas de valeurs:

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

Soyez prudent lorsque vous utilisez les éléments suivants:

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

Les chaînes vides sont évaluées à False, mais tout le reste est évalué à True. Donc, cela ne doit pas être utilisé à des fins d'analyse.

Utilisation:

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

Les vraies valeurs sont y, oui, t, true, on et 1; les fausses valeurs sont n, non, f, faux, désactivé et 0. Déclenche ValueError si val est autre chose.

Sachez que distutils.util.strtobool()renvoie des représentations entières et qu'il doit donc être encapsulé bool()pour obtenir des valeurs booléennes.

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

Appelez-le ainsi:

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

Gérer explicitement le vrai et le faux:

Vous pouvez également faire en sorte que votre fonction vérifie explicitement une vraie liste de mots et une fausse liste de mots. Si elle ne figure dans aucune des deux listes, vous pouvez lever une exception.

L'analyseur JSON est également utile pour en général convertir des chaînes en types python raisonnables.

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

Depuis Python 2.6, il y a maintenant ast.literal_eval:

>>> importer ast
>>> aide (ast.literal_eval)
Aide sur la fonction literal_eval dans le module ast:

literal_eval (node_or_string)
    Évaluez en toute sécurité un nœud d'expression ou une chaîne contenant un Python
    expression. La chaîne ou le nœud fourni ne peut comprendre que les éléments suivants
    Structures littérales Python: chaînes, nombres, tuples, listes, dict, booléens,
    et aucun.

Ce qui semble fonctionner, tant que vous êtes sûr que vos cordes seront soit "True"ou "False":

>>> ast.literal_eval ("True")
Vrai
>>> ast.literal_eval ("False")
Faux
>>> ast.literal_eval ("F")
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
  Fichier "/opt/Python-2.6.1/lib/python2.6/ast.py", ligne 68, dans literal_eval
    return _convert (node_or_string)
  Fichier "/opt/Python-2.6.1/lib/python2.6/ast.py", ligne 67, dans _convert
    augmenter ValueError ('chaîne mal formée')
ValueError: chaîne mal formée
>>> ast.literal_eval ("'False'")
'Faux'

Je ne recommanderais normalement pas cela, mais il est entièrement intégré et pourrait être la bonne chose en fonction de vos besoins.

Si vous savez que la chaîne sera soit "True"ou "False", vous pouvez simplement utiliser eval(s).

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

N'utilisez cela que si vous êtes sûr du contenu de la chaîne, car il lèvera une exception si la chaîne ne contient pas de Python valide et exécutera également le code contenu dans la chaîne.

Cette version conserve la sémantique des constructeurs comme int (valeur) et fournit un moyen simple de définir des valeurs de chaîne acceptables.

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

Voici ma version. Il vérifie les listes de valeurs positives et négatives, levant une exception pour les valeurs inconnues. Et il ne reçoit pas de chaîne, mais tout type devrait le faire.

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

Exemples de cycles:

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

vous pourriez toujours faire quelque chose comme

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

le bit en parens serait évalué à faux. C'est juste une autre façon de le faire sans avoir à faire un véritable appel de fonction.

Un truc cool et simple (basé sur ce que @Alan Marchiori a publié), mais en utilisant yaml:

import yaml

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

S'il est trop large, il peut être affiné en testant le résultat du type. Si le type renvoyé par yaml est une chaîne, il ne peut pas être converti en un autre type (auquel je peux penser de toute façon), vous pouvez donc le gérer séparément, ou simplement le laisser être vrai.

Je ne ferai aucune supposition à la vitesse, mais puisque je travaille avec des données yaml sous Qt gui de toute façon, cela a une symétrie sympa.

Je ne suis d'accord avec aucune solution ici, car elles sont trop permissives. Ce n'est normalement pas ce que vous voulez lors de l'analyse d'une chaîne.

Voici donc la solution que j'utilise:

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)

Et les résultats:

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

Juste pour être clair, car il semble que ma réponse ait offensé quelqu'un:

Le fait est que vous ne voulez pas tester une seule valeur et supposer l'autre. Je ne pense pas que vous souhaitiez toujours mapper absolument tout à la valeur non analysée. Cela produit un code sujet aux erreurs.

Donc, si vous savez dans quoi vous voulez le coder.

Un dict (vraiment, un defaultdict) vous donne un moyen assez simple de faire cette astuce:

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

Il est très facile d'adapter cette méthode au comportement de conversion exact que vous souhaitez - vous pouvez la remplir avec les valeurs Truthy et Falsy autorisées et la laisser lever une exception (ou renvoyer None) lorsqu'une valeur n'est pas trouvée, ou par défaut True, ou par défaut False, ou tout ce que vous voulez.

Vous avez probablement déjà une solution, mais pour ceux qui recherchent une méthode pour convertir une valeur en valeur booléenne à l'aide de fausses valeurs "standard", notamment None, [], {} et "" en plus de false, no et 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

Vous pouvez simplement utiliser la fonction intégrée 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)

et la sortie:

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

Encore une autre option

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

Mais en production, si vous n'avez pas besoin de ansible et de toutes ses dépendances, une bonne idée est de regarder son code source et de copier une partie de la logique dont vous avez besoin.

La règle habituelle pour la coulée à un bool est que quelques littéraux spéciaux ( False, 0, 0.0, (), [], {}) sont faux et tout le reste est vrai, donc je recommande ce qui suit:

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

Ceci est la version que j'ai écrite. Combine plusieurs des autres solutions en une seule.

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)

S'il obtient une chaîne, il attend des valeurs spécifiques, sinon déclenche une exception. S'il n'obtient pas de chaîne, laisse simplement le constructeur bool le comprendre. Testé ces cas:

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

Si vous savez que votre entrée sera "vraie" ou "fausse", alors pourquoi ne pas utiliser:

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

j'utilise

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

J'aime utiliser l'opérateur ternaire pour cela, car c'est un peu plus succinct pour quelque chose qui semble ne pas dépasser 1 ligne.

True if myString=="True" else False

Je me rends compte que c'est un vieux post, mais certaines des solutions nécessitent pas mal de code, voici ce que j'ai fini par utiliser:

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

Utiliser le package str2bool pip install str2bool

Si vous m'aimez juste besoin d'un booléen à partir d'une variable qui est une chaîne. Vous pouvez utiliser des distils comme mentionné précédemment par @jzwiener. Cependant, je n'ai pas pu importer et utiliser le module comme il l'a suggéré.

Au lieu de cela, je finis par l'utiliser de cette façon sur python3.7

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

distutils fait partie de la bibliothèque python std donc pas besoin d'installation. Qui est super! 👍

Je voudrais partager ma solution simple: utilisez le eval(). Il convertira la chaîne Trueet Falsele type booléen approprié SI la chaîne est exactement au format du titre Trueou Falsetoujours en majuscule, sinon la fonction déclenchera une erreur.

par exemple

>>> eval('False')
False

>>> eval('True')
True

Bien sûr, pour la variable dynamique, vous pouvez simplement utiliser le .title()pour formater la chaîne booléenne.

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

Cela générera une erreur.

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

voici un moyen poilu, construit pour obtenir plusieurs des mêmes réponses. Notez que bien que python considère ""comme faux et que toutes les autres chaînes soient vraies, TCL a une idée très différente des choses.

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

Une bonne chose à ce sujet est qu'il pardonne assez les valeurs que vous pouvez utiliser. Il est paresseux de transformer des chaînes en valeurs, et il est hygiénique de ce qu'il accepte et rejette (notez que si l'instruction ci-dessus était donnée à l'invite tcl, cela effacerait le disque dur de l'utilisateur).

la mauvaise chose est qu'elle nécessite que Tkinter soit disponible, ce qui est généralement, mais pas universellement vrai, et plus important encore, nécessite la création d'une instance Tk, ce qui est relativement lourd.

Ce qui est considéré comme vrai ou faux dépend du comportement du Tcl_GetBoolean, qui considère 0, false, noet offd'être faux et 1, true, yeset onpour être vrai, insensible à la casse. Toute autre chaîne, y compris la chaîne vide, provoque une exception.

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

idée: vérifiez si vous voulez que la chaîne soit évaluée à False; sinon bool () renvoie True pour toute chaîne non vide.

Voici quelque chose que j'ai jeté ensemble pour évaluer la véracité d'une chaîne:

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)

plus ou moins les mêmes résultats que l'utilisation, evalmais plus sûr.

Je devais juste faire ça ... alors peut-être en retard à la fête - mais quelqu'un peut le trouver 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

Si vous avez le contrôle sur l'entité qui retourne true/ false, une option est de la faire retourner 1/ 0au lieu de true/ false, alors:

boolean_response = bool(int(response))

Le cast supplémentaire intgère les réponses d'un réseau, qui sont toujours des chaînes.

En utilisant la fonction intégrée de Python eval()et le.capitalize() méthode de , vous pouvez convertir n'importe quelle chaîne "vraie" / "fausse" (quelle que soit la capitalisation initiale) en un vrai booléen Python.

Par exemple:

true_false = "trUE"
type(true_false)

# OUTPUT: <type 'str'>

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

# OUTPUT: <type 'bool'>