Mengubah dari string menjadi boolean dengan Python?

Adakah yang tahu cara melakukan konversi dari string ke boolean dengan Python? Saya menemukan tautan ini . Tapi itu tidak terlihat seperti cara yang tepat untuk melakukannya. Yaitu menggunakan fungsionalitas bawaan, dll.

Alasan saya menanyakan hal ini adalah karena saya belajar int("string")dari sini. Tetapi ketika mencobanya bool("string")selalu kembali True:

>>> bool("False")
True

Sungguh, Anda hanya membandingkan string dengan apa pun yang Anda harapkan diterima mewakili benar, sehingga Anda dapat melakukan ini:

s == 'True'

Atau untuk memeriksa sejumlah nilai:

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

Berhati-hatilah saat menggunakan yang berikut ini:

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

String kosong dievaluasi untuk False, tetapi semua yang lain dievaluasi True. Jadi ini tidak boleh digunakan untuk keperluan parsing apa pun.

Menggunakan:

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

Nilai sebenarnya adalah y, ya, t, benar, dan 1; nilai false adalah n, no, f, false, off dan 0. Meningkatkan ValueError jika val adalah hal lain.

Sadarilah bahwa distutils.util.strtobool()mengembalikan representasi integer dan karenanya perlu dibungkus dengan bool()untuk mendapatkan nilai Boolean.

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

Kemudian menyebutnya seperti ini:

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

Menangani benar dan salah secara eksplisit:

Anda juga dapat membuat fungsi Anda secara eksplisit memeriksa daftar kata yang benar dan daftar kata yang salah. Maka jika itu tidak ada dalam daftar, Anda bisa melempar pengecualian.

Parser JSON juga berguna untuk mengkonversi string secara umum menjadi tipe python yang masuk akal.

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

Dimulai dengan Python 2.6, sekarang ada ast.literal_eval:

>>> impor ast
>>> bantuan (ast.literal_eval)
Bantuan pada fungsi literal_eval di modul ast:

literal_eval (node_or_string)
    Mengevaluasi simpul ekspresi atau string yang mengandung Python dengan aman
    ekspresi. String atau simpul yang disediakan mungkin hanya terdiri dari yang berikut ini
    Struktur literal Python: string, angka, tupel, daftar, dicts, boolean,
    dan Tidak ada.

Yang tampaknya berhasil, selama Anda yakin string Anda akan berupa "True"atau "False":

>>> ast.literal_eval ("Benar")
Benar
>>> ast.literal_eval ("False")
Salah
>>> ast.literal_eval ("F")
Traceback (panggilan terakhir terakhir):
  File "", baris 1, dalam 
  File "/opt/Python-2.6.1/lib/python2.6/ast.py", baris 68, dalam literal_eval
    return _convert (node_or_string)
  File "/opt/Python-2.6.1/lib/python2.6/ast.py", baris 67, di _convert
    meningkatkan ValueError ('string cacat')
ValueError: string salah bentuk
>>> ast.literal_eval ("'False'")
'Salah'

Saya biasanya tidak merekomendasikan ini, tetapi ini sepenuhnya built-in dan bisa menjadi hal yang tepat tergantung pada kebutuhan Anda.

Jika Anda tahu string akan berupa "True"atau "False", Anda bisa menggunakannya eval(s).

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

Gunakan ini hanya jika Anda yakin akan isi string, karena akan mengeluarkan pengecualian jika string tidak mengandung Python yang valid, dan juga akan mengeksekusi kode yang terkandung dalam string.

Versi ini menjaga semantik konstruktor seperti int (nilai) dan menyediakan cara mudah untuk mendefinisikan nilai string yang dapat diterima.

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

Ini versi saya. Ini memeriksa daftar nilai positif dan negatif, meningkatkan pengecualian untuk nilai yang tidak diketahui. Dan itu tidak menerima string, tetapi semua jenis harus dilakukan.

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

Sampel berjalan:

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

Anda selalu bisa melakukan sesuatu seperti

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

bit pada parens akan dievaluasi menjadi False. Ini hanyalah cara lain untuk melakukannya tanpa harus melakukan pemanggilan fungsi yang sebenarnya.

Trik yang keren dan sederhana (berdasarkan apa yang diposting @Alan Marchiori), tetapi menggunakan yaml:

import yaml

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

Jika ini terlalu lebar, dapat disempurnakan dengan menguji hasil tipe. Jika jenis yaml-dikembalikan adalah str, maka itu tidak dapat dilemparkan ke jenis lain (yang dapat saya pikirkan), sehingga Anda dapat mengatasinya secara terpisah, atau membiarkannya benar.

Saya tidak akan menebak dengan cepat, tetapi karena saya bekerja dengan data yaml di bawah Qt gui, ini memiliki simetri yang bagus.

Saya tidak setuju dengan solusi apa pun di sini, karena mereka terlalu permisif. Ini biasanya tidak seperti yang Anda inginkan saat mengurai string.

Jadi di sini solusinya saya gunakan:

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)

Dan hasilnya:

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

Untuk lebih jelas karena sepertinya jawaban saya menyinggung seseorang:

Intinya adalah bahwa Anda tidak ingin menguji hanya untuk satu nilai dan menganggap yang lainnya. Saya tidak berpikir Anda selalu ingin memetakan Benar-benar segalanya dengan nilai yang tidak diuraikan. Itu menghasilkan kode rawan kesalahan.

Jadi, jika Anda tahu kode apa yang Anda inginkan.

Dict (sungguh-sungguh, defaultdict) memberi Anda cara yang cukup mudah untuk melakukan trik ini:

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

Sangat mudah untuk menyesuaikan metode ini dengan perilaku konversi yang tepat yang Anda inginkan - Anda dapat mengisinya dengan nilai Truthy dan Falsy yang diizinkan dan membiarkannya meningkatkan pengecualian (atau mengembalikan Tidak Ada) ketika nilai tidak ditemukan, atau default ke True, atau default ke False, atau apa pun yang Anda inginkan.

Anda mungkin sudah memiliki solusi tetapi untuk orang lain yang mencari metode untuk mengonversi nilai menjadi nilai boolean menggunakan nilai palsu "standar" termasuk Tidak Ada, [], {}, dan "" selain false, tidak, dan 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

Anda cukup menggunakan fungsi built-in 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)

dan hasilnya:

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

Namun pilihan lain

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

Tetapi dalam produksi jika Anda tidak memerlukan yang mungkin dan semua dependensinya, ide yang baik adalah melihat kode sumbernya dan menyalin bagian dari logika yang Anda butuhkan.

Aturan biasa untuk casting untuk bool adalah bahwa beberapa literal khusus ( False, 0, 0.0, (), [], {}) adalah palsu dan kemudian segala sesuatu yang lain adalah benar, jadi saya sarankan berikut:

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

Ini adalah versi yang saya tulis. Menggabungkan beberapa solusi lain menjadi satu.

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)

Jika mendapat string, ia mengharapkan nilai tertentu, jika tidak, akan menimbulkan Pengecualian. Jika tidak mendapatkan string, cukup biarkan konstruktor bool mengetahuinya. Menguji kasus ini:

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

Jika Anda tahu bahwa input Anda adalah "Benar" atau "Salah" maka mengapa tidak menggunakan:

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

saya menggunakan

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

Saya suka menggunakan operator ternary untuk ini, karena ini sedikit lebih ringkas untuk sesuatu yang terasa seperti tidak boleh lebih dari 1 baris.

True if myString=="True" else False

Saya menyadari ini adalah posting lama, tetapi beberapa solusi memerlukan sedikit kode, inilah yang akhirnya saya gunakan:

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

Gunakan paket str2bool pip install str2bool

Jika Anda suka saya hanya perlu boolean dari variabel yang merupakan string. Anda dapat menggunakan distils seperti yang disebutkan sebelumnya oleh @jzwiener. Namun saya tidak dapat mengimpor dan menggunakan modul seperti yang disarankannya.

Sebaliknya saya akhirnya menggunakannya dengan cara ini di python3.7

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

distutils adalah bagian dari python std lib jadi tidak perlu instalasi. Bagus sekali! 👍

Saya ingin berbagi solusi sederhana saya: gunakan eval(). Ini akan mengkonversi string Truedan Falseuntuk tipe boolean yang tepat JIKA string tersebut persis dalam format judul Trueatau Falseselalu huruf kapital pertama atau fungsi akan menimbulkan kesalahan.

misalnya

>>> eval('False')
False

>>> eval('True')
True

Tentu saja untuk variabel dinamis, Anda dapat dengan mudah menggunakan .title()untuk memformat string boolean.

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

Ini akan menimbulkan kesalahan.

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

inilah yang berbulu, dibangun untuk mendapatkan banyak jawaban yang sama. Perhatikan bahwa meskipun python dianggap ""salah dan semua string lainnya benar, TCL memiliki gagasan yang sangat berbeda tentang berbagai hal.

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

Hal yang baik tentang hal ini adalah cukup memaafkan tentang nilai yang dapat Anda gunakan. Ini malas mengubah string menjadi nilai, dan itu hygenic tentang apa yang diterima dan ditolak (perhatikan bahwa jika pernyataan di atas diberikan pada prompt tcl, itu akan menghapus hard disk pengguna).

yang buruk adalah bahwa itu mengharuskan Tkinter tersedia, yang biasanya, tetapi tidak benar secara universal, dan lebih penting lagi, mengharuskan instance Tk dibuat, yang relatif berat.

Apa yang dianggap benar atau salah tergantung pada perilaku Tcl_GetBoolean, yang menganggap 0, false, nodan offmenjadi palsu dan 1, true, yesdan onuntuk menjadi kenyataan, kasus tidak sensitif. String lain, termasuk string kosong, menyebabkan pengecualian.

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

ide: periksa apakah Anda ingin string dievaluasi menjadi False; jika tidak bool () mengembalikan True untuk string yang tidak kosong.

Inilah sesuatu yang saya lempar bersama untuk mengevaluasi kebenaran string:

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)

hasil yang kurang lebih sama dengan menggunakan evaltetapi lebih aman.

Saya hanya perlu melakukan ini ... jadi mungkin terlambat ke pesta - tetapi seseorang mungkin merasa berguna

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

Jika Anda memiliki kendali atas entitas yang mengembalikan true/ false, satu opsi adalah mengembalikannya 1/ 0bukan true/ false, lalu:

boolean_response = bool(int(response))

Pemain tambahan untuk intmenangani respons dari jaringan, yang selalu berupa string.

Dengan menggunakan eval()fungsi dan .capitalize()metode bawaan Python , Anda dapat mengonversi string "benar" / "salah" (terlepas dari kapitalisasi awal) menjadi boolean Python sejati.

Sebagai contoh:

true_false = "trUE"
type(true_false)

# OUTPUT: <type 'str'>

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

# OUTPUT: <type 'bool'>