파이썬에서 문자열을 부울로 변환 하시겠습니까?

파이썬에서 문자열을 부울로 변환하는 방법을 아는 사람이 있습니까? 이 링크를 찾았습니다 . 그러나 그것을하는 적절한 방법처럼 보이지는 않습니다. 즉 내장 기능 등을 사용하는 경우

내가 묻는 이유 int("string")는 여기에서 배웠기 때문 입니다. 그러나 시도 bool("string")하면 항상 다음을 반환합니다 True.

>>> bool("False")
True

실제로 문자열을 true를 나타내는 것으로 받아 들일 것으로 예상되는 것과 비교하면 다음과 같이 할 수 있습니다.

s == 'True'

또는 전체 값에 대해 확인하려면 다음을 수행하십시오.

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

다음을 사용할 때는주의하십시오.

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

빈 문자열은로 평가 False되지만 다른 모든 항목은로 평가됩니다 True. 따라서 이것은 어떤 종류의 파싱 목적으로도 사용해서는 안됩니다.

사용하다:

bool(distutils.util.strtobool(some_string))

• 파이썬 2 : http://docs.python.org/2/distutils/apiref.html?highlight=distutils.util#distutils.util.strtobool
• 파이썬 3 : https://docs.python.org/3/distutils/apiref.html#distutils.util.strtobool

참값은 y, yes, t, true, on 및 1입니다. false 값은 n, no, f, false, off 및 0입니다. val이 다른 경우 ValueError가 발생합니다.

distutils.util.strtobool()정수 표현 을 리턴하므로 bool()부울 값을 얻기 위해 랩핑되어야 합니다.

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

그런 다음 이렇게 호출하십시오.

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

참과 거짓을 명시 적으로 다루기 :

함수가 참 단어 목록과 거짓 단어 목록을 명시 적으로 검사하도록 할 수도 있습니다. 그런 다음 목록에 없으면 예외를 던질 수 있습니다.

JSON 파서는 또한 일반적으로 문자열을 합리적인 파이썬 유형으로 변환하는 데 유용합니다.

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

Python 2.6부터는 다음이 있습니다 ast.literal_eval.

>>> 수입 ast
>>> help (ast.literal_eval)
ast 모듈의 literal_eval 함수에 대한 도움말 :

literal_eval (노드 _ 또는 _ 문자열)
    표현식 노드 또는 파이썬을 포함하는 문자열을 안전하게 평가
    표현. 제공된 문자열 또는 노드는 다음으로 만 구성 될 수 있습니다
    파이썬 리터럴 구조 : 문자열, 숫자, 튜플,리스트, dicts, booleans,
    그리고 없음.

문자열이 또는 중 하나 일 것이라고 확신 하는 한 작동하는 것 같습니다 ."True""False"

>>> ast.literal_eval ( "참")
진실
>>> ast.literal_eval ( "거짓")
그릇된
>>> ast.literal_eval ( "F")
역 추적 (가장 최근 통화) :
  ""파일, 1 행 
  literal_eval의 "/opt/Python-2.6.1/lib/python2.6/ast.py", 68 행 파일
    리턴 _convert (node_or_string)
  _convert의 파일 "/opt/Python-2.6.1/lib/python2.6/ast.py", 67 행
    ValueError ( '잘못된 문자열')
ValueError : 잘못된 문자열
>>> ast.literal_eval ( " '거짓'")
'그릇된'

일반적으로 권장하지는 않지만 완전히 내장되어 있으며 요구 사항에 따라 올바른 것이 될 수 있습니다.

문자열이 "True"또는 중 하나 인 것을 알고 있으면 "False"사용할 수 있습니다 eval(s).

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

문자열에 유효한 Python이 포함되어 있지 않으면 예외가 발생하고 문자열에 포함 된 코드도 실행되므로 문자열의 내용이 확실하면 이것을 사용하십시오.

이 버전은 int (value)와 같은 생성자의 의미를 유지하고 허용 가능한 문자열 값을 쉽게 정의 할 수있는 방법을 제공합니다.

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

여기 내 버전이 있습니다. 양수 및 음수 목록을 모두 확인하여 알 수없는 값에 대한 예외를 발생시킵니다. 그리고 문자열을받지 않지만 모든 유형이 수행해야합니다.

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

샘플 실행 :

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

당신은 항상 같은 것을 할 수 있습니다

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

Parens의 비트는 False로 평가됩니다. 이것은 실제 함수 호출을 수행하지 않고 다른 방법입니다.

@Alan Marchiori가 게시 한 내용을 기반으로하는 멋진 간단한 트릭이지만 yaml을 사용합니다.

import yaml

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

이 값이 너무 넓은 경우 형식 결과를 테스트하여 다듬을 수 있습니다. yaml-returned 유형이 str이면 다른 유형으로 캐스팅 할 수 없으므로 (어쨌든 생각할 수 있음) 개별적으로 처리하거나 사실로 만들 수 있습니다.

나는 빠른 속도로 추측하지는 않지만 어쨌든 Qt gui에서 yaml 데이터로 작업하고 있기 때문에 이것은 훌륭한 대칭을 가지고 있습니다.

나는 너무 관대하기 때문에 여기의 해결책에 동의하지 않습니다. 이것은 일반적으로 문자열을 구문 분석 할 때 원하는 것이 아닙니다.

그래서 여기에 내가 사용하는 솔루션이 있습니다.

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)

그리고 결과 :

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

내 대답이 어떻게 든 누군가를 화나게 한 것처럼 보이기 때문에 분명히하십시오.

요점은 하나의 값만 테스트하고 다른 값은 가정하지 않는다는 것입니다. 나는 당신이 항상 구문 분석되지 않은 값에 모든 것을 매핑하고 싶지 않다고 생각합니다. 오류가 발생하기 쉬운 코드가 생성됩니다.

따라서 원하는 코드를 알고 있다면

dict (실제로 defaultdict) 은이 트릭을 수행하는 매우 쉬운 방법을 제공합니다.

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

이 방법을 원하는 정확한 변환 동작에 맞게 조정하는 것은 정말 쉽습니다. 허용 된 Truthy 및 Falsy 값으로 채우고 값을 찾을 수 없을 때 예외를 발생 시키거나 None을 반환 할 수 있습니다. 또는 기본값은 False 또는 원하는 것입니다.

이미 해결책이 있지만 false, no 및 0 외에도 None, [], {} 및 ""을 포함하는 "standard"false 값을 사용하여 값을 부울 값으로 변환하는 방법을 찾고있는 다른 사용자 .

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

내장 함수 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)

그리고 출력 :

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

또 다른 옵션

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

그러나 프로덕션 환경에서 모든 의존성과 의존성이 필요하지 않은 경우 소스 코드 를보고 필요한 로직의 일부를 복사 하는 것이 좋습니다 .

부울로 캐스팅에 대한 일반적인 규칙은 그 몇 가지 특별한 리터럴 ( False, 0, 0.0, (), [], {}) 거짓 내가 다음 사항을 권장하므로 다음 다른 모든 것이 사실입니다 :

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

이것은 내가 쓴 버전입니다. 다른 여러 솔루션을 하나로 결합합니다.

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)

문자열을 얻으면 특정 값을 기대하고 그렇지 않으면 예외가 발생합니다. 문자열을 얻지 못하면 bool 생성자가 알아 내도록하십시오. 이러한 경우를 테스트했습니다.

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

입력 내용이 "True"또는 "False"인 경우 다음을 사용하지 마십시오.

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

나는 사용한다

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

나는 이것을 위해 삼항 연산자를 사용하고 싶습니다. 왜냐하면 1 줄을 넘지 않아야한다고 느끼는 것에 대해 간결합니다.

True if myString=="True" else False

나는 이것이 오래된 게시물이라는 것을 알고 있지만 일부 솔루션에는 약간의 코드가 필요합니다. 내가 사용한 결과는 다음과 같습니다.

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

str2bool 패키지 사용 pip install str2bool

당신이 나를 좋아한다면 문자열 인 변수에서 부울이 필요합니다. @jzwiener가 앞서 언급 한 바와 같이 distils를 사용할 수 있습니다. 그러나 그가 제안한대로 모듈을 가져 와서 사용할 수 없었습니다.

대신 python3.7 에서이 방법으로 사용합니다.

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

distutils는 python std lib의 일부이므로 설치할 필요가 없습니다. 어느 것이 좋습니까! 👍

간단한 솔루션을 공유하고 싶습니다 eval(). 그것은 문자열로 변환합니다 True및 False문자열이 제목 형식으로 정확하게 경우 적절한 부울 종류를 True나False 오류를 올릴 것이다 항상 첫 글자 자본이나 다른 기능.

예 :

>>> eval('False')
False

>>> eval('True')
True

물론 동적 변수의 경우을 사용 .title()하여 부울 문자열의 형식을 간단하게 지정할 수 있습니다 .

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

오류가 발생합니다.

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

여기에 같은 대답을 많이 얻을 수있는 털이 있습니다. 파이썬은 ""거짓이고 다른 모든 문자열은 참 이라고 생각하지만 TCL은 사물에 대해 매우 다른 생각을 가지고 있습니다.

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

이것에 대한 좋은 점은 사용할 수있는 값을 상당히 용서한다는 것입니다. 문자열을 값으로 바꾸는 것이 게으르고, 받아들이고 거부하는 것에 대해 위생적입니다 (위의 진술이 tcl 프롬프트에서 주어지면 사용자 하드 디스크를 지우 게됩니다).

나쁜 점은 Tkinter를 사용할 수 있어야한다는 것인데, 일반적으로 사실은 아니지만 Tkinter를 사용할 수 있어야하며, 더 중요하게는 비교적 무거운 Tk 인스턴스를 만들어야합니다.

무엇 참 또는 거짓 고려하면의 행동에 따라 Tcl_GetBoolean고려, 0, false, no및 off허위로하고 1, true, yes및on 실제 사례를 구분합니다. 빈 문자열을 포함한 다른 문자열은 예외를 발생시킵니다.

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

아이디어 : 문자열을 False로 평가할지 확인하십시오. 그렇지 않으면 bool ()은 비어 있지 않은 문자열에 대해 True를 반환합니다.

다음은 문자열의 진실성을 평가하기 위해 함께 던진 것입니다.

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)

보다 eval안전하지만 사용하는 것과 거의 동일한 결과 .

방금이 작업을 수행해야 했으므로 파티에 늦었을 수도 있지만 누군가 유용 할 수 있습니다.

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/ false하나의 옵션은 반환하는 것입니다 1/ 0대신에 true/이 false다음 :

boolean_response = bool(int(response))

추가 캐스트 int는 항상 문자열 인 네트워크의 응답 을 처리합니다.

파이썬의 내장 eval()함수를 사용하여.capitalize() 메소드를 사용하면 "true"/ "false"문자열 (처음 대문자와 상관없이)을 실제 Python 부울로 변환 할 수 있습니다.

예를 들면 다음과 같습니다.

true_false = "trUE"
type(true_false)

# OUTPUT: <type 'str'>

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

# OUTPUT: <type 'bool'>