Python'da bir dizeden boole'ye dönüştürme?

Herkes nasıl bir dize Python boole dönüştürmek biliyor mu? Bu bağlantıyı buldum . Ama bunu yapmak için uygun bir yol gibi görünmüyor. Yani yerleşik işlevsellik vb. Kullanmak

Bunu sormamın nedeni int("string"), buradan öğrendim . Ancak denerken bool("string")her zaman geri döner True:

>>> bool("False")
True

Gerçekten, dizeyi doğru olarak temsil etmeyi kabul ettiğiniz her şeyle karşılaştırırsınız, böylece bunu yapabilirsiniz:

s == 'True'

Veya bir grup değeri karşılaştırmak için:

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

Aşağıdakileri kullanırken dikkatli olun:

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

Boş dizeler olarak değerlendirilir False, ancak diğer her şey değerlendirilir True. Bu nedenle bu, herhangi bir ayrıştırma amacıyla kullanılmamalıdır.

kullanın:

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

Gerçek değerler y, evet, t, doğru, açık ve 1'dir; false değerleri n, no, f, false, off ve 0'dır. val başka bir şeyse ValueError değerini yükseltir.

Unutmayın distutils.util.strtobool()döner temsillerini tamsayı ve böylece birlikte sarılmış gerekmektedir bool()almak için Boolean değerler.

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

Sonra şöyle deyin:

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

Doğru ve yanlışın açıkça işlenmesi:

Ayrıca, işlevinizin Açık bir kelime listesi ve Yanlış bir kelime listesi ile açıkça kontrol edilmesini de sağlayabilirsiniz. Sonra her iki listede de yoksa, bir istisna atabilirsiniz.

JSON ayrıştırıcı, genel olarak dizeleri makul python türlerine dönüştürmek için de yararlıdır.

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

Python 2.6'dan başlayarak, şimdi var ast.literal_eval:

>>> ithalat ast
>>> yardım (ast.literal_eval)
Ast modülünde literal_eval işlevi hakkında yardım:

literal_eval (node_or_string)
    Bir ifade düğümünü veya Python içeren bir dizeyi güvenle değerlendirin
    ifadesi. Sağlanan dize veya düğüm yalnızca aşağıdakilerden oluşabilir
    Python değişmez yapıları: stringler, sayılar, tuples, listeler, dikte, boolean,
    ve Yok.

Sen olarak hangisi sürece, iş gibi görünüyor emin Dizeleriniz ya olacak "True"ya "False":

>>> ast.literal_eval ("Doğru")
Doğru
>>> ast.literal_eval ("Yanlış")
Yanlış
>>> ast.literal_eval ("F")
Geri izleme (en son yapılan son arama):
  Dosya "", satır 1, içinde 
  Literal_eval içindeki "/opt/Python-2.6.1/lib/python2.6/ast.py" dosyası, satır 68,
    return _convert (düğüm_veya_dizgi)
  _Convert dosyasında "/opt/Python-2.6.1/lib/python2.6/ast.py" dosyası, 67 numaralı dosya
    Yükselt ValueError ('hatalı biçimlendirilmiş dize')
ValueError: hatalı biçimlendirilmiş dize
>>> ast.literal_eval ("'False'")
'Yanlış'

Normalde bunu tavsiye etmem, ancak tamamen yerleşiktir ve gereksinimlerinize bağlı olarak doğru şey olabilir.

Ya dize olacaktır biliyorsanız "True"ya "False", sadece kullanabilirsiniz eval(s).

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

Bunu yalnızca dizenin içeriğinden eminseniz kullanın, çünkü dize geçerli Python içermiyorsa bir istisna atar ve dizede bulunan kodu da yürütür.

Bu sürüm int (value) gibi kurucuların anlambilimini korur ve kabul edilebilir dize değerlerini tanımlamak için kolay bir yol sağlar.

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

İşte benim versiyonum. Hem pozitif hem de negatif değerler listelerini kontrol eder ve bilinmeyen değerler için bir istisna oluşturur. Ve bir dize almaz, ancak herhangi bir tür yapmalıdır.

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

Örnek çalışmalar:

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

her zaman böyle bir şey yapabilirdin

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

parens içindeki bit False olarak değerlendirilir. Bu, gerçek bir işlev çağrısı yapmak zorunda kalmadan bunu yapmanın başka bir yoludur.

Serin, basit bir numara (@Alan Marchiori'nin yayınladıklarına dayanarak), ancak yaml kullanarak:

import yaml

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

Bu çok genişse, tür sonucu test edilerek rafine edilebilir. Yaml döndürülen tür bir str ise, başka bir türe (yine de düşünebileceğim) atılamaz, bu yüzden ayrı ayrı ele alabilir veya sadece doğru olmasına izin verebilirsiniz.

Hızla tahmin yapmayacağım, ama yine de Qt gui altında yaml verileriyle çalıştığım için, bu güzel bir simetriye sahip.

Çok izin verdikleri için burada herhangi bir çözüme katılmıyorum. Bir dizeyi ayrıştırırken normalde istediğiniz bu değildir.

İşte burada kullandığım çözüm:

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)

Ve sonuçlar:

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

Açık olmak gerekirse, cevabım bir şekilde bir şekilde rahatsız olmuş gibi görünüyor:

Mesele şu ki, sadece bir değeri test etmek ve diğerini varsaymak istemezsiniz. Her zaman kesinlikle her şeyi ayrıştırılmamış değere eşlemek istediğinizi sanmıyorum. Bu hataya eğilimli kod üretir.

Yani, ne kodlamak istediğinizi biliyorsanız.

Bir diksiyon (gerçekten, varsayılan bir karar) size bu hile yapmanın oldukça kolay bir yolunu sunar:

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

Bu yöntemi istediğiniz tam dönüşüm davranışına uyarlamak gerçekten kolaydır - bunu izin verilen Doğruluk ve Falsy değerleriyle doldurabilir ve bir değer bulunmadığında veya varsayılan olarak True olarak bir istisna (veya Hiçbiri döndürmeme) sağlayabilirsiniz. veya varsayılan değeri False (Yanlış) seçeneğine ayarlayın.

Muhtemelen zaten bir çözümünüz var, ancak false, no ve 0'a ek olarak None, [], {} ve "" dahil olmak üzere "standard" false değerlerini kullanarak bir değeri boolean değerine dönüştürmek için bir yöntem arayan diğerleri için .

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

Yalnızca yerleşik eval () işlevini kullanabilirsiniz :

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)

ve çıktı:

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

Yine başka bir seçenek

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

Ancak üretimde ansible ve tüm bağımlılıklarına ihtiyacınız yoksa, kaynak koduna bakmak ve mantığın ihtiyacınız olan kısmını kopyalamak iyi bir fikirdir .

Bir bool için döküm için olağan bir kural olduğu bir kaç özel değişmezleri ( False, 0, 0.0, (), [], {}) yanlış ve ben öneririm böylece daha sonra her şey doğrudur, şunlardır:

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

Bu yazdığım sürüm. Diğer çözümlerin birçoğunu bir araya getirir.

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)

Bir dize alırsa belirli değerler bekler, aksi takdirde bir İstisna oluşturur. Bir dize almazsa, bool yapıcısının onu bulmasına izin verin. Bu vakaları test etti:

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

Girişinizin "Doğru" veya "Yanlış" olacağını biliyorsanız, neden kullanmıyorsunuz:

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

kullanırım

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

Üçlü operatörü kullanmayı seviyorum, çünkü 1 satırdan fazla olmamalı gibi hissettiren bir şey için biraz daha özlü.

True if myString=="True" else False

Bunun eski bir yazı olduğunu anlıyorum, ancak bazı çözümler biraz kod gerektiriyor, işte şunu kullanıyorum:

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

Str2bool paketini kullan pip install str2bool

Eğer benim gibi sadece dize olan değişken boolean gerekir. @Jzwiener tarafından daha önce bahsedildiği gibi distileleri kullanabilirsiniz. Ancak önerdiği gibi modülü içe aktaramadım ve kullanamadım.

Bunun yerine python3.7'de bu şekilde kullanıyorum

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

distutils python std lib'in bir parçasıdır, bu yüzden kuruluma gerek yoktur. Hangisi harika! 👍

Basit çözümümü paylaşmak istiyorum: kullanın eval(). Bu dizeyi dönüştürmek Trueve Falsedize başlık biçiminde tam olarak EĞER uygun boolean türüne TrueveyaFalse her zaman ilk harf büyükse veya işlev bir hata oluşturacaksa .

Örneğin

>>> eval('False')
False

>>> eval('True')
True

Tabii ki dinamik değişken .title()için boole dizesini biçimlendirmek için kullanabilirsiniz .

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

Bu bir hata verecektir.

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

İşte aynı cevapların çoğunu almak için inşa edilmiş bir tüylü. Python'un ""yanlış olduğunu ve diğer tüm dizelerin doğru olduğunu düşünmesine rağmen , TCL'nin şeyler hakkında çok farklı bir fikri vardır.

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

Bu konuda iyi bir şey, kullanabileceğiniz değerler için oldukça affedicidir. Dizeleri değerlere dönüştürme konusunda tembeldir ve neleri kabul ettiği ve reddettiği konusunda hijyeniktir (yukarıdaki ifade bir tcl isteminde verilirse, kullanıcıların sabit diskini sileceğini unutmayın).

kötü olan şey, genellikle evrensel fakat gerçek olmayan Tkinter'in kullanılabilir olmasını ve daha da önemlisi, nispeten ağır bir Tk örneğinin oluşturulmasını gerektirmesidir.

Ne doğru veya yanlış olarak kabul edilir davranışına bağlıdır Tcl_GetBooleandikkate alır 0, false, nove offyanlış olduğu ve 1, true, yesve ongerçek, vaka duyarsız olması. Boş dize dahil olmak üzere diğer tüm dize istisna oluşturur.

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

fikir: dizenin False olarak değerlendirilmesini isteyip istemediğinizi kontrol edin; aksi halde bool (), boş olmayan herhangi bir dize için True değerini döndürür.

İşte bir ipin gerçekliğini değerlendirmek için birlikte attığım bir şey:

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)

kullanmakla daha fazla veya daha az aynı sonuç verir, evalancak daha güvenlidir.

Sadece bunu yapmak zorundaydım ... belki partiye geç kaldım - ama birisi faydalı bulabilir

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

true/ Döndüren varlık üzerinde kontrolünüz varsa false, seçeneklerden biri 1/ 0yerine true/ döndürmesini sağlamaktır false:

boolean_response = bool(int(response))

Eklenen yayın int, her zaman dize olan bir ağdan gelen yanıtları işler.

Python'un yerleşik eval()işlevini ve .capitalize()yöntemini kullanarak, herhangi bir "true" / "false" dizesini (başlangıçtaki büyük harf kullanımına bakılmaksızın) gerçek bir Python boole'sine dönüştürebilirsiniz.

Örneğin:

true_false = "trUE"
type(true_false)

# OUTPUT: <type 'str'>

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

# OUTPUT: <type 'bool'>