문자열을 float 또는 int로 구문 분석하는 방법은 무엇입니까?

질문자 :Tristan Havelick

"545.2222" 와 같은 숫자 문자열을 해당 부동 소수점 값인 545.2222 어떻게 해야 합니까? 또는 문자열 구문 분석 "31" 정수에 31 ?

난 그냥 플로트 구문 분석하는 방법을 알고 싶어요 str A와 float 및 (별도)있는 int str 에 int .

>>> a = "545.2222" >>> float(a) 545.22220000000004 >>> int(float(a)) 545

Harley Holcombe

def num(s): try: return int(s) except ValueError: return float(s)

Javier

문자열이 float인지 확인하는 Python 방법:

 def is_float(value): try: float(value) return True except: return False

이 함수의 더 길고 정확한 이름은 다음과 같습니다. is_convertible_to_float(value)

Python 에서 float is 및 is not is 놀라게 할 수 있습니다.

 val is_float(val) Note -------------------- ---------- -------------------------------- "" False Blank string "127" True Passed string True True Pure sweet Truth "True" False Vile contemptible lie False True So false it becomes true "123.456" True Decimal " -127 " True Spaces trimmed "\t\n12\r\n" True whitespace ignored "NaN" True Not a number "NaNanananaBATMAN" False I am Batman "-iNF" True Negative infinity "123.E4" True Exponential notation ".1" True mantissa only "1,234" False Commas gtfo u'\x30' True Unicode is fine. "NULL" False Null is not special 0x3fade True Hexadecimal "6e7777777777777" True Shrunk to infinity "1.797693e+308" True This is max value "infinity" True Same as inf "infinityandBEYOND" False Extra characters wreck it "12.34.56" False Only one dot allowed u'四' False Japanese '4' is not a float. "#56" False Pound sign "56%" False Percent of what? "0E0" True Exponential, move dot 0 places 0**0 True 0___0 Exponentiation "-5e-5" True Raise to a negative number "+1e1" True Plus is OK with exponent "+1e1^5" False Fancy exponent not interpreted "+1e1.3" False No decimals in exponent "-+1" False Make up your mind "(1)" False Parenthesis is bad

숫자가 무엇인지 알 것 같습니까? 당신은 당신이 생각하는 것만큼 좋지 않습니다! 큰 놀라움은 아닙니다.

생명에 중요한 소프트웨어에는 이 코드를 사용하지 마십시오!

이런 식으로 광범위한 예외를 잡아내고, 카나리아를 죽이고 예외를 무시하면 유효한 float as string이 false를 반환할 작은 기회가 생깁니다. float(...) 코드 줄은 문자열의 내용과 아무 관련이 없는 수천 가지 이유로 실패할 수 있습니다. 그러나 Python과 같은 오리 타이핑 프로토타입 언어로 생명에 중요한 소프트웨어를 작성하는 경우 훨씬 더 큰 문제가 발생합니다.

Eric Leschinski

이것은 ast.literal_eval에서 언급할 가치가 있는 또 다른 방법입니다.

이것은 값을 직접 구문 분석할 필요 없이 신뢰할 수 없는 소스의 Python 표현식을 포함하는 문자열을 안전하게 평가하는 데 사용할 수 있습니다.

즉, 안전한 '평가'

 >>> import ast >>> ast.literal_eval("545.2222") 545.2222 >>> ast.literal_eval("31") 31

wim

float(x) if '.' in x else int(x)

Dino Viehland

현지화 및 쉼표

예외를 throw하는 float("545,545.2222") 와 같은 경우 숫자의 문자열 표현에서 쉼표의 가능성을 고려해야 합니다. locale 메서드를 사용하여 문자열을 숫자로 변환하고 쉼표를 올바르게 해석합니다. locale.atof 메서드는 원하는 숫자 규칙에 맞게 로캘이 설정되면 한 번에 부동 소수점으로 변환합니다.

예 1 -- 미국 숫자 규칙

미국과 영국에서는 쉼표를 천 단위 구분 기호로 사용할 수 있습니다. 미국 로케일이 있는 이 예에서 쉼표는 구분 기호로 올바르게 처리됩니다.

 >>> import locale >>> a = u'545,545.2222' >>> locale.setlocale(locale.LC_ALL, 'en_US.UTF-8') 'en_US.UTF-8' >>> locale.atof(a) 545545.2222 >>> int(locale.atof(a)) 545545 >>>

예 2 -- 유럽 숫자 규칙

세계 대부분의 국가 에서는 마침표 대신 쉼표를 소수점으로 사용합니다. 프랑스어 로케일이 있는 이 예에서 쉼표는 소수점으로 올바르게 처리됩니다.

 >>> import locale >>> b = u'545,2222' >>> locale.setlocale(locale.LC_ALL, 'fr_FR') 'fr_FR' >>> locale.atof(b) 545.2222

locale.atoi 메서드도 사용할 수 있지만 인수는 정수여야 합니다.

Mark Chackerian

타사 모듈을 싫어하지 않는 경우 fastnumbers 모듈을 확인할 수 있습니다. 이 질문이 요구하는 것을 정확히 수행하고 순수한 Python 구현보다 빠르게 수행하는 fast_real 이라는 함수를 제공합니다.

 >>> from fastnumbers import fast_real >>> fast_real("545.2222") 545.2222 >>> type(fast_real("545.2222")) float >>> fast_real("31") 31 >>> type(fast_real("31")) int

SethMMorton

사용자 codelogic 및 harley 는 정확하지만 문자열이 정수(예: 545)임을 알고 있으면 먼저 float로 캐스팅하지 않고 int("545")를 호출할 수 있음을 명심하십시오.

문자열이 목록에 있으면 map 함수도 사용할 수 있습니다.

 >>> x = ["545.0", "545.6", "999.2"] >>> map(float, x) [545.0, 545.60000000000002, 999.20000000000005] >>>

모두 같은 유형인 경우에만 좋습니다.

user44484

Python에서 "545.2222"와 같은 숫자 문자열을 해당 부동 소수점 값인 542.2222로 구문 분석하려면 어떻게 해야 합니까? 또는 문자열 "31"을 정수 31로 구문 분석하시겠습니까? float 문자열을 float로 구문 분석하고 int 문자열을 int로 (별도로) 구문 분석하는 방법을 알고 싶습니다.

따로 요청하시는게 좋습니다. 그것들을 섞는다면 나중에 문제가 생길 수 있습니다. 간단한 대답은 다음과 같습니다.

부동 "545.2222"

 >>> float("545.2222") 545.2222

"31" 을 정수로:

 >>> int("31") 31

기타 변환, 문자열 및 리터럴 간의 int:

다양한 베이스로부터의 변환, 그리고 당신은 미리 베이스를 알고 있어야 합니다(기본값은 10). 파이썬이 리터럴에 대해 기대하는 것을 접두사로 붙이거나(아래 참조) 접두사를 제거할 수 있습니다.

 >>> int("0b11111", 2) 31 >>> int("11111", 2) 31 >>> int('0o37', 8) 31 >>> int('37', 8) 31 >>> int('0x1f', 16) 31 >>> int('1f', 16) 31

사전에 기본을 알지 못하지만 올바른 접두사가 있다는 것을 알고 있는 경우, 0 을 기본으로 전달하면 Python이 이를 유추할 수 있습니다.

 >>> int("0b11111", 0) 31 >>> int('0o37', 0) 31 >>> int('0x1f', 0) 31

다른 기수의 10진수가 아닌(즉, 정수) 리터럴

그러나 동기가 자신의 코드가 하드 코딩된 특정 값을 명확하게 나타내도록 하는 것이라면 기본에서 변환할 필요가 없을 수도 있습니다. Python이 올바른 구문을 사용하여 자동으로 변환하도록 할 수 있습니다.

apropos 접두사를 사용하여 다음 리터럴을 사용하여 정수로 자동 변환할 수 있습니다. 다음은 Python 2 및 3에 유효합니다.

바이너리, 접두사 0b

 >>> 0b11111 31

8진수, 접두사 0o

 >>> 0o37 31

16진수, 접두사 0x

 >>> 0x1f 31

이것은 바이너리 플래그, 코드의 파일 권한 또는 색상에 대한 16진수 값을 설명할 때 유용할 수 있습니다. 예를 들어 따옴표는 사용하지 마십시오.

 >>> 0b10101 # binary flags 21 >>> 0o755 # read, write, execute perms for owner, read & ex for group & others 493 >>> 0xffffff # the color, white, max values for red, green, and blue 16777215

모호한 Python 2 8진수를 Python 3과 호환 가능하게 만들기

Python 2에서 0으로 시작하는 정수가 보이면 이것은 (더 이상 사용되지 않는) 8진수 구문입니다.

 >>> 037 31

37 이어야 하는 것처럼 보이기 때문에 좋지 않습니다. 따라서 Python 3에서는 이제 SyntaxError .

 >>> 037 File "<stdin>", line 1 037 ^ SyntaxError: invalid token

Python 2 8진수를 접두사 0o 2와 3 모두에서 작동하는 8진수로 변환합니다.

 >>> 0o37 31

Aaron Hall

질문이 조금 오래된 것 같습니다. 하지만 parseStr이라는 함수를 제안하겠습니다. 이 함수는 비슷한 것을 만들어 줍니다. 즉, 정수 또는 부동 소수점을 반환하고 주어진 ASCII 문자열을 어느 것으로도 변환할 수 없으면 그대로 반환합니다. 물론 코드는 원하는 작업만 수행하도록 조정될 수 있습니다.

 >>> import string >>> parseStr = lambda x: x.isalpha() and x or x.isdigit() and \ ... int(x) or x.isalnum() and x or \ ... len(set(string.punctuation).intersection(x)) == 1 and \ ... x.count('.') == 1 and float(x) or x >>> parseStr('123') 123 >>> parseStr('123.3') 123.3 >>> parseStr('3HC1') '3HC1' >>> parseStr('12.e5') 1200000.0 >>> parseStr('12$5') '12$5' >>> parseStr('12.2.2') '12.2.2'

krzym

float("545.2222") 및 int(float("545.2222"))

codelogic

YAML 파서는 문자열이 어떤 데이터 유형인지 알아내는 데 도움이 될 수 있습니다. yaml.load() 를 사용한 다음 type(result) 를 사용하여 유형을 테스트할 수 있습니다.

 >>> import yaml >>> a = "545.2222" >>> result = yaml.load(a) >>> result 545.22220000000004 >>> type(result) <type 'float'> >>> b = "31" >>> result = yaml.load(b) >>> result 31 >>> type(result) <type 'int'> >>> c = "HI" >>> result = yaml.load(c) >>> result 'HI' >>> type(result) <type 'str'>

Rafe

나는 그것을 위해 이 기능을 사용한다

 import ast def parse_str(s): try: return ast.literal_eval(str(s)) except: return

문자열을 해당 유형으로 변환합니다.

 value = parse_str('1') # Returns Integer value = parse_str('1.5') # Returns Float

Shameem

def get_int_or_float(v): number_as_float = float(v) number_as_int = int(number_as_float) return number_as_int if number_as_float == number_as_int else number_as_float

Totoro

def num(s): """num(s) num(3),num(3.7)-->3 num('3')-->3, num('3.7')-->3.7 num('3,700')-->ValueError num('3a'),num('a3'),-->ValueError num('3e4') --> 30000.0 """ try: return int(s) except ValueError: try: return float(s) except ValueError: raise ValueError('argument is not a string of number')

Jerry T

이를 제대로 수행하려면 반올림을 고려해야 합니다.

즉, int(5.1) => 5 int(5.6) => 5 -- 잘못된, 6이어야 하므로 int(5.6 + 0.5) => 6

 def convert(n): try: return int(n) except ValueError: return float(n + 0.5)

Nick

때때로 문자열을 숫자로 캐스팅하기 전에 준비하고 정규화해야 하기 때문에 아무도 정규식을 언급하지 않은 것에 놀랐습니다.

 import re def parseNumber(value, as_int=False): try: number = float(re.sub('[^.\-\d]', '', value)) if as_int: return int(number + 0.5) else: return number except ValueError: return float('nan') # or None if you wish

용법:

 parseNumber('13,345') > 13345.0 parseNumber('- 123 000') > -123000.0 parseNumber('99999\n') > 99999.0

그건 그렇고, 당신이 번호를 가지고 있는지 확인하기 위해 뭔가 :

 import numbers def is_number(value): return isinstance(value, numbers.Number) # will work with int, float, long, Decimal

Sławomir Lenart

이 함수에 문자열을 전달합니다.

 def string_to_number(str): if("." in str): try: res = float(str) except: res = str elif(str.isdigit()): res = int(str) else: res = str return(res)

전달된 내용에 따라 int, float 또는 string을 반환합니다.

int인 문자열

 print(type(string_to_number("124"))) <class 'int'>

부동 소수점 문자열

 print(type(string_to_number("12.4"))) <class 'float'>

문자열인 문자열

 print(type(string_to_number("hello"))) <class 'str'>

부동 소수점처럼 보이는 문자열

 print(type(string_to_number("hel.lo"))) <class 'str'>

Cybernetic

파이썬에서 유형 변환하려면 유형의 생성자 함수를 사용하여 문자열(또는 변환하려는 값)을 매개변수로 전달합니다.

예를 들어:

 >>>float("23.333") 23.333

배후에서 파이썬은 매개변수의 float 표현을 반환해야 __float__ 이것은 float(myobject)를 사용하여 float로 캐스팅될 수 있도록 __float__ 메서드로 자신의 유형(클래스 사용)을 정의할 수 있기 때문에 특히 강력합니다.

kCODINGeroo

16진수, 8진수, 2진수, 10진수 및 부동 소수점 처리

이 솔루션은 숫자에 대한 모든 문자열 규칙(내가 알고 있는 모든 것)을 처리합니다.

 def to_number(n): ''' Convert any number representation to a number This covers: float, decimal, hex, and octal numbers. ''' try: return int(str(n), 0) except: try: # python 3 doesn't accept "010" as a valid octal. You must use the # '0o' prefix return int('0o' + n, 0) except: return float(n)

이 테스트 케이스 출력은 내가 말하는 내용을 보여줍니다.

 ======================== CAPTURED OUTPUT ========================= to_number(3735928559) = 3735928559 == 3735928559 to_number("0xFEEDFACE") = 4277009102 == 4277009102 to_number("0x0") = 0 == 0 to_number(100) = 100 == 100 to_number("42") = 42 == 42 to_number(8) = 8 == 8 to_number("0o20") = 16 == 16 to_number("020") = 16 == 16 to_number(3.14) = 3.14 == 3.14 to_number("2.72") = 2.72 == 2.72 to_number("1e3") = 1000.0 == 1000 to_number(0.001) = 0.001 == 0.001 to_number("0xA") = 10 == 10 to_number("012") = 10 == 10 to_number("0o12") = 10 == 10 to_number("0b01010") = 10 == 10 to_number("10") = 10 == 10 to_number("10.0") = 10.0 == 10 to_number("1e1") = 10.0 == 10

테스트는 다음과 같습니다.

 class test_to_number(unittest.TestCase): def test_hex(self): # All of the following should be converted to an integer # values = [ # HEX # ---------------------- # Input | Expected # ---------------------- (0xDEADBEEF , 3735928559), # Hex ("0xFEEDFACE", 4277009102), # Hex ("0x0" , 0), # Hex # Decimals # ---------------------- # Input | Expected # ---------------------- (100 , 100), # Decimal ("42" , 42), # Decimal ] values += [ # Octals # ---------------------- # Input | Expected # ---------------------- (0o10 , 8), # Octal ("0o20" , 16), # Octal ("020" , 16), # Octal ] values += [ # Floats # ---------------------- # Input | Expected # ---------------------- (3.14 , 3.14), # Float ("2.72" , 2.72), # Float ("1e3" , 1000), # Float (1e-3 , 0.001), # Float ] values += [ # All ints # ---------------------- # Input | Expected # ---------------------- ("0xA" , 10), ("012" , 10), ("0o12" , 10), ("0b01010" , 10), ("10" , 10), ("10.0" , 10), ("1e1" , 10), ] for _input, expected in values: value = to_number(_input) if isinstance(_input, str): cmd = 'to_number("{}")'.format(_input) else: cmd = 'to_number({})'.format(_input) print("{:23} = {:10} == {:10}".format(cmd, value, expected)) self.assertEqual(value, expected)

shrewmouse

이것은 https://stackoverflow.com/a/33017514/5973334 의 수정된 버전 입니다.

이것은 문자열을 구문 분석하고 문자열이 나타내는 것에 따라 int 또는 float 구문 분석 예외가 발생하거나 예기치 않은 동작이 발생할 수 있습니다 .

 def get_int_or_float(v): number_as_float = float(v) number_as_int = int(number_as_float) return number_as_int if number_as_float == number_as_int else number_as_float

Kuzeko

a = int(float(a)) if int(float(a)) == float(a) else float(a)

bougui

사용하다:

 def num(s): try: for each in s: yield int(each) except ValueError: yield float(each) a = num(["123.55","345","44"]) print a.next() print a.next()

이것은 내가 생각해낼 수 있는 가장 Pythonic한 방법입니다.

SeasonalShot

사용하다:

 >>> str_float = "545.2222" >>> float(str_float) 545.2222 >>> type(_) # Check its type <type 'float'> >>> str_int = "31" >>> int(str_int) 31 >>> type(_) # Check its type <type 'int'>

user4813927

이것은 제공된 실제 문자열 int 또는 float 처럼 보이는지 object str 뿐만 아니라)를 int 또는 float 로 변환하는 함수입니다. __float 및 __int__ 메서드가 모두 있는 객체인 경우 기본적으로 __float__

 def conv_to_num(x, num_type='asis'): '''Converts an object to a number if possible. num_type: int, float, 'asis' Defaults to floating point in case of ambiguity. ''' import numbers is_num, is_str, is_other = [False]*3 if isinstance(x, numbers.Number): is_num = True elif isinstance(x, str): is_str = True is_other = not any([is_num, is_str]) if is_num: res = x elif is_str: is_float, is_int, is_char = [False]*3 try: res = float(x) if '.' in x: is_float = True else: is_int = True except ValueError: res = x is_char = True else: if num_type == 'asis': funcs = [int, float] else: funcs = [num_type] for func in funcs: try: res = func(x) break except TypeError: continue else: res = x

Abhishek Bhatia

숫자와 char 함께 :

 string_for_int = "498 results should get" string_for_float = "498.45645765 results should get"

첫 번째 가져오기:

 import re #for get integer part: print(int(re.search(r'\d+', string_for_int).group())) #498 #for get float part: print(float(re.search(r'\d+\.\d+', string_for_float).group())) #498.45645765

쉬운 모델:

 value1 = "10" value2 = "10.2" print(int(value1)) #10 print(float(value2)) #10.2

mamal

이것은 오래된 질문이며 이미 많은 답변을 얻었습니다. 그러나 혼합 정수와 부동 소수점을 처리하고 혼합 데이터를 처리하는 일관된 방법을 원하는 경우 여기에 적절한 독스트링이 있는 솔루션이 있습니다.

 def parse_num(candidate): """parse string to number if possible work equally well with negative and positive numbers, integers and floats. Args: candidate (str): string to convert Returns: float | int | None: float or int if possible otherwise None """ try: float_value = float(candidate) except ValueError: return None # optional part if you prefer int to float when decimal part is 0 if float_value.is_integer(): return int(float_value) # end of the optional part return float_value # test candidates = ['34.77', '-13', 'jh', '8990', '76_3234_54'] res_list = list(map(parse_num, candidates)) print('Before:') print(candidates) print('After:') print(res_list)

산출:

 Before: ['34.77', '-13', 'jh', '8990', '76_3234_54'] After: [34.77, -13, None, 8990, 76323454]

Sameh Farouk

json.loads 사용할 수 있습니다.

 >>> import json >>> json.loads('123.456') 123.456 >>> type(_) <class 'float'> >>>

보시다시피 float 유형이 됩니다.

U12-Forward

int 및 float 메서드를 사용하여 문자열을 정수 및 부동 소수점으로 변환할 수 있습니다.

 s="45.8" print(float(s)) y='67' print(int(y))

Shekku Joseph

귀하의 질문에 대한 또 다른 해석이 있습니다(힌트: 모호합니다). 다음과 같은 것을 찾고 있을 가능성이 있습니다.

 def parseIntOrFloat( aString ): return eval( aString )

이렇게 작동합니다...

 >>> parseIntOrFloat("545.2222") 545.22220000000004 >>> parseIntOrFloat("545") 545

---

이론적으로 주입 취약점이 있습니다. 문자열은 예를 들어 "import os; os.abort()" 있습니다. 그러나 문자열이 어디에서 왔는지에 대한 배경 지식이 없으면 가능성은 이론적 추측입니다. 질문이 모호하기 때문에 이 취약점이 실제로 존재하는지 여부는 전혀 명확하지 않습니다.

S.Lott

출처 : http:www.stackoverflow.com/questions/379906/how-do-i-parse-a-string-to-a-float-or-int