파이썬에서 문자열을 숫자로 나타낼 수 있는지 확인하는 가장 좋은 방법은 무엇입니까?

현재 내가 가지고있는 기능은 다음과 같습니다.

def is_number(s):
    try:
        float(s)
        return True
    except ValueError:
        return False

추악하고 느릴뿐만 아니라 어색한 것 같습니다. 그러나 float주 함수를 호출하는 것이 더 나쁘기 때문에 더 좋은 방법을 찾지 못했습니다 .

추악하고 느릴뿐만 아니라

나는 둘 다 논쟁 할 것이다.

정규식이나 다른 문자열 구문 분석 방법은 더 느리고 느립니다.

위의 것보다 많은 것이 빠를 지 확실하지 않습니다. 함수를 호출하고 반환합니다. 스택 프레임을 광범위하게 검색하지 않고 가장 일반적인 예외가 발생하기 때문에 Try / Catch는 많은 오버 헤드를 발생시키지 않습니다.

문제는 모든 숫자 변환 함수에 두 가지 종류의 결과가 있다는 것입니다

• 숫자가 유효하면 숫자
• 유효한 번호를 구문 분석 할 수 없음을 표시하는 상태 코드 (예 : errno를 통한) 또는 예외입니다.

예를 들어 C는 여러 가지 방법으로 해킹합니다. 파이썬은 그것을 명확하고 명시 적으로 설명합니다.

이 작업을 수행하는 코드가 완벽하다고 생각합니다.

부동 소수점 대신 (양수, 부호없는) 정수를 파싱하려는 경우 isdigit()문자열 객체에 함수를 사용할 수 있습니다 .

>>> a = "03523"
>>> a.isdigit()
True
>>> b = "963spam"
>>> b.isdigit()
False

문자열 메소드- isdigit(): Python2 , Python3

유니 코드 문자열에는 유니 코드에 익숙하지 않은 것도 있습니다. 십진수 / 십진수입니다

TL; DR 가장 좋은 해결책은s.replace('.','',1).isdigit()

나는 어떤 한 벤치 마크 다른 접근 방법을 비교하는

def is_number_tryexcept(s):
    """ Returns True is string is a number. """
    try:
        float(s)
        return True
    except ValueError:
        return False

import re    
def is_number_regex(s):
    """ Returns True is string is a number. """
    if re.match("^\d+?\.\d+?$", s) is None:
        return s.isdigit()
    return True


def is_number_repl_isdigit(s):
    """ Returns True is string is a number. """
    return s.replace('.','',1).isdigit()

문자열이 숫자가 아닌 경우 except-block은 상당히 느립니다. 그러나 더 중요한 것은 try-except 방법이 과학적 표기법을 올바르게 처리하는 유일한 방법입니다.

funcs = [
          is_number_tryexcept, 
          is_number_regex,
          is_number_repl_isdigit
          ]

a_float = '.1234'

print('Float notation ".1234" is not supported by:')
for f in funcs:
    if not f(a_float):
        print('\t -', f.__name__)

플로트 표기법 ".1234"는 다음에서 지원되지 않습니다.
-is_number_regex

scientific1 = '1.000000e+50'
scientific2 = '1e50'


print('Scientific notation "1.000000e+50" is not supported by:')
for f in funcs:
    if not f(scientific1):
        print('\t -', f.__name__)




print('Scientific notation "1e50" is not supported by:')
for f in funcs:
    if not f(scientific2):
        print('\t -', f.__name__)

과학 표기법 "1.000000e + 50"은 다음에서 지원하지 않습니다.
-is_number_regex
-is_number_repl_isdigit
과학 표기법 "1e50"은 다음에서 지원하지 않습니다.
-is_number_regex
-is_number_repl_isdigit

편집 : 벤치 마크 결과

import timeit

test_cases = ['1.12345', '1.12.345', 'abc12345', '12345']
times_n = {f.__name__:[] for f in funcs}

for t in test_cases:
    for f in funcs:
        f = f.__name__
        times_n[f].append(min(timeit.Timer('%s(t)' %f, 
                      'from __main__ import %s, t' %f)
                              .repeat(repeat=3, number=1000000)))

다음 기능들이 테스트 된 곳

from re import match as re_match
from re import compile as re_compile

def is_number_tryexcept(s):
    """ Returns True is string is a number. """
    try:
        float(s)
        return True
    except ValueError:
        return False

def is_number_regex(s):
    """ Returns True is string is a number. """
    if re_match("^\d+?\.\d+?$", s) is None:
        return s.isdigit()
    return True


comp = re_compile("^\d+?\.\d+?$")    

def compiled_regex(s):
    """ Returns True is string is a number. """
    if comp.match(s) is None:
        return s.isdigit()
    return True


def is_number_repl_isdigit(s):
    """ Returns True is string is a number. """
    return s.replace('.','',1).isdigit()

고려해야 할 한 가지 예외가 있습니다 : 문자열 'NaN'

is_number가 'NaN'에 대해 FALSE를 반환하도록하려면 Python이 숫자가 아닌 숫자의 표현으로 변환 할 때이 코드가 작동하지 않습니다 (ID 문제에 대한 대화).

>>> float('NaN')
nan

그렇지 않으면 실제로 광범위하게 사용하는 코드에 대해 실제로 감사드립니다. :)

지.

이건 어때요:

'3.14'.replace('.','',1).isdigit()

'.'가 없거나없는 경우에만 true를 반환합니다. 자릿수로.

'3.14.5'.replace('.','',1).isdigit()

거짓을 반환합니다

편집 : 방금 다른 의견을 보았습니다 ... .replace(badstuff,'',maxnum_badstuff)다른 경우에 대해 추가 할 수 있습니다. 임의의 조미료가 아닌 소금을 통과하면 ( xkcd # 974 ) 이것이 잘됩니다. : P

추악하고 느릴뿐만 아니라 어색한 것 같습니다.

익숙해지는 데 다소 시간이 걸릴 수 있지만 이것은 파이썬을 사용하는 방법입니다. 이미 지적했듯이 대안은 더 나쁩니다. 그러나 이런 식으로 일을하는 것의 또 다른 장점은 다형성입니다.

오리 타이핑의 기본 개념은 "걸 으면서 오리처럼 말하면 오리입니다." 플로트로 변환 할 수 있는지 확인하는 방법을 변경할 수 있도록 문자열을 서브 클래스 화해야한다면 어떻게해야합니까? 아니면 다른 물체를 완전히 테스트하기로 결정한 경우 어떻게해야합니까? 위의 코드를 변경하지 않고도 이러한 작업을 수행 할 수 있습니다.

다른 언어는 인터페이스를 사용하여 이러한 문제를 해결합니다. 다른 스레드에 어떤 솔루션이 더 나은지 분석을 저장하겠습니다. 그러나 요점은 파이썬이 결정의 오리 타이핑 측면에 결정적이라는 것입니다. 파이썬에서 많은 프로그래밍을 할 계획이라면 아마도 이와 같은 구문에 익숙해 져야 할 것입니다 (그러나 이것이 의미는 아닙니다 물론 좋아해야합니다).

고려해야 할 또 다른 사항 : 파이썬은 다른 많은 언어 (예 : .Net보다 30 배 빠름)에 비해 예외를 던지고 잡는 데 매우 빠릅니다. 심지어 언어 자체는 예외가 아닌 예외적 인 정상적인 프로그램 조건을 전달하기 위해 예외를 발생시킵니다 (for 루프를 사용할 때마다). 따라서 중요한 문제가 발견 될 때 까지이 코드의 성능 측면에 대해 너무 걱정하지 않아도됩니다.

Alfe가 지적한 후에 업데이트되었으므로 복잡한 핸들로 플로트를 별도로 확인할 필요가 없습니다.

def is_number(s):
    try:
        complex(s) # for int, long, float and complex
    except ValueError:
        return False

    return True

이전에 말했다 : 드문 경우이지만 float로 표현 할 수없는 복잡한 숫자 (예 : 1 + 2i)를 확인해야 할 수도 있습니다.

def is_number(s):
    try:
        float(s) # for int, long and float
    except ValueError:
        try:
            complex(s) # for complex
        except ValueError:
            return False

    return True

위해 int이것을 사용 :

>>> "1221323".isdigit()
True

그러나 float우리에게는 약간의 트릭이 필요합니다. ;-). 모든 플로트 숫자에는 하나의 점이 있습니다 ...

>>> "12.34".isdigit()
False
>>> "12.34".replace('.','',1).isdigit()
True
>>> "12.3.4".replace('.','',1).isdigit()
False

또한 음수의 경우 다음을 추가하십시오 lstrip().

>>> '-12'.lstrip('-')
'12'

이제 우리는 보편적 인 방법을 얻습니다.

>>> '-12.34'.lstrip('-').replace('.','',1).isdigit()
True
>>> '.-234'.lstrip('-').replace('.','',1).isdigit()
False

그냥 모방 C #

C #에는 스칼라 값의 구문 분석을 처리하는 두 가지 함수가 있습니다.

• Float.Parse ()
• Float.TryParse ()

float.parse () :

def parse(string):
    try:
        return float(string)
    except Exception:
        throw TypeError

참고 : 예외를 TypeError로 변경 한 이유가 궁금하다면 문서를 참조하십시오 .

float.try_parse () :

def try_parse(string, fail=None):
    try:
        return float(string)
    except Exception:
        return fail;

참고 : 부울 'False'는 여전히 값 유형이므로 반환하지 않습니다. 실패를 나타내는 것이 더 좋습니다. 물론 다른 것을 원한다면 fail 매개 변수를 원하는대로 변경할 수 있습니다.

'parse ()'및 'try_parse ()'를 포함하도록 float를 확장하려면 이러한 메서드를 추가하려면 'float'클래스를 monkeypatch해야합니다.

기존 기능을 존중하려면 코드는 다음과 같아야합니다.

def monkey_patch():
    if(!hasattr(float, 'parse')):
        float.parse = parse
    if(!hasattr(float, 'try_parse')):
        float.try_parse = try_parse

SideNote : 개인적으로 YMMV 이외의 언어를 사용하는 것처럼 느끼기 때문에 Monkey Punching이라고합니다.

용법:

float.parse('giggity') // throws TypeException
float.parse('54.3') // returns the scalar value 54.3
float.tryParse('twank') // returns None
float.tryParse('32.2') // returns the scalar value 32.2

그리고 위대한 현자 Pythonas는 Holy See Sharpisus에게 "당신이 할 수있는 모든 것이 더 잘할 수 있습니다.

숫자가 아닌 문자열의 경우 try: except: 경우 실제로 정규식보다 느립니다. 유효한 숫자 문자열의 경우 정규식이 느립니다. 따라서 적절한 방법은 입력에 따라 다릅니다.

당신이 성능 바인드에 있다는 것을 발견하면, 당신은 새로운 서드 파티 모듈을 호출 사용할 수 있습니다 fastnumbers 라는 기능을 제공 isfloat을 . 전체 공개, 나는 저자입니다. 나는 그 결과를 아래의 타이밍에 포함시켰다.

from __future__ import print_function
import timeit

prep_base = '''\
x = 'invalid'
y = '5402'
z = '4.754e3'
'''

prep_try_method = '''\
def is_number_try(val):
    try:
        float(val)
        return True
    except ValueError:
        return False

'''

prep_re_method = '''\
import re
float_match = re.compile(r'[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$').match
def is_number_re(val):
    return bool(float_match(val))

'''

fn_method = '''\
from fastnumbers import isfloat

'''

print('Try with non-number strings', timeit.timeit('is_number_try(x)',
    prep_base + prep_try_method), 'seconds')
print('Try with integer strings', timeit.timeit('is_number_try(y)',
    prep_base + prep_try_method), 'seconds')
print('Try with float strings', timeit.timeit('is_number_try(z)',
    prep_base + prep_try_method), 'seconds')
print()
print('Regex with non-number strings', timeit.timeit('is_number_re(x)',
    prep_base + prep_re_method), 'seconds')
print('Regex with integer strings', timeit.timeit('is_number_re(y)',
    prep_base + prep_re_method), 'seconds')
print('Regex with float strings', timeit.timeit('is_number_re(z)',
    prep_base + prep_re_method), 'seconds')
print()
print('fastnumbers with non-number strings', timeit.timeit('isfloat(x)',
    prep_base + 'from fastnumbers import isfloat'), 'seconds')
print('fastnumbers with integer strings', timeit.timeit('isfloat(y)',
    prep_base + 'from fastnumbers import isfloat'), 'seconds')
print('fastnumbers with float strings', timeit.timeit('isfloat(z)',
    prep_base + 'from fastnumbers import isfloat'), 'seconds')
print()

Try with non-number strings 2.39108395576 seconds
Try with integer strings 0.375686168671 seconds
Try with float strings 0.369210958481 seconds

Regex with non-number strings 0.748660802841 seconds
Regex with integer strings 1.02021503448 seconds
Regex with float strings 1.08564686775 seconds

fastnumbers with non-number strings 0.174362897873 seconds
fastnumbers with integer strings 0.179651021957 seconds
fastnumbers with float strings 0.20222902298 seconds

보시다시피

• try: except: 숫자 입력의 경우 빠르지 만 유효하지 않은 입력의 경우 매우 느립니다.
• 정규식은 입력이 유효하지 않을 때 매우 효율적입니다
• fastnumbers 두 경우 모두에서 승리

나는 이것이 오래되었다는 것을 알고 있지만, 나는 이것을 찾는 사람에게 매우 가치가있을 수있는 가장 높은 투표 응답에서 누락 된 정보를 포함한다고 생각하는 답변을 추가 할 것입니다.

다음 각 방법에 대해 입력을 수락해야하는 경우 개수와 연결하십시오. (0-255가 아닌 정수의 음성 정의를 사용한다고 가정합니다.)

x.isdigit() x가 정수인지 확인하는 데 효과적입니다.

x.replace('-','').isdigit() x가 음수인지 확인하는 데 효과적입니다. (체크-첫 번째 위치)

x.replace('.','').isdigit() x가 10 진수인지 확인하는 데 효과적입니다.

x.replace(':','').isdigit() x가 비율인지 확인하는 데 효과적입니다.

x.replace('/','',1).isdigit() x가 분수인지 확인하는 데 효과적입니다.

이 대답은 문자열을 찾는 예제와 함께 기능을 갖는 단계별 가이드를 제공합니다.

• 양의 정수
• 양수 / 음수-정수 / 부동
• 숫자를 확인하는 동안 "NaN"(숫자가 아님) 문자열을 버리는 방법은 무엇입니까?

문자열이 양의 정수 인지 확인

str.isdigit()주어진 문자열이 양의 정수 인지 확인 하는 데 사용할 수 있습니다 .

샘플 결과 :

# For digit
>>> '1'.isdigit()
True
>>> '1'.isalpha()
False

문자열을 양수 / 음수로 검사-정수 / 부동

str.isdigit()False문자열이 음수 또는 부동 수이면를 반환 합니다 . 예를 들면 다음과 같습니다.

# returns `False` for float
>>> '123.3'.isdigit()
False
# returns `False` for negative number
>>> '-123'.isdigit()
False

당신이 원하는 경우 도 확인 부정의 와 정수float , 당신은 그것을 확인하기 위해 사용자 정의 함수를 작성할 수 있습니다 :

def is_number(n):
    try:
        float(n)   # Type-casting the string to `float`.
                   # If string is not a valid `float`, 
                   # it'll raise `ValueError` exception
    except ValueError:
        return False
    return True

샘플 실행 :

>>> is_number('123')    # positive integer number
True

>>> is_number('123.4')  # positive float number
True

>>> is_number('-123')   # negative integer number
True

>>> is_number('-123.4') # negative `float` number
True

>>> is_number('abc')    # `False` for "some random" string
False

숫자를 확인하는 동안 "NaN"(숫자가 아님) 문자열을 버리십시오

위 함수는 True파이썬이 숫자가 아닌 유효한 float이므로 "NAN"(숫자가 아님) 문자열 을 반환 합니다. 예를 들면 다음과 같습니다.

>>> is_number('NaN')
True

숫자가 "NaN"인지 확인하기 위해 math.isnan()다음과 같이 사용할 수 있습니다 .

>>> import math
>>> nan_num = float('nan')

>>> math.isnan(nan_num)
True

또는 추가 라이브러리를 가져 와서 확인하지 않으려면을 사용하여 라이브러리와 비교하여 간단히 확인할 수 있습니다 ==. float이 자신과 비교 False되면 Python이 반환 됩니다 nan. 예를 들면 다음과 같습니다.

# `nan_num` variable is taken from above example
>>> nan_num == nan_num
False

따라서, 상기 함수는 is_number반환하도록 업데이트 될 수 False위해"NaN" 로서 :

def is_number(n):
    is_number = True
    try:
        num = float(n)
        # check for "nan" floats
        is_number = num == num   # or use `math.isnan(num)`
    except ValueError:
        is_number = False
    return is_number

샘플 실행 :

>>> is_number('Nan')   # not a number "Nan" string
False

>>> is_number('nan')   # not a number string "nan" with all lower cased
False

>>> is_number('123')   # positive integer
True

>>> is_number('-123')  # negative integer
True

>>> is_number('-1.12') # negative `float`
True

>>> is_number('abc')   # "some random" string
False

PS : 숫자 유형에 따라 각 검사에 대한 각 작업에는 추가 오버 헤드가 있습니다. is_number요구 사항에 맞는 기능 버전을 선택하십시오 .

float ()이 특별히 그 용도로 사용되므로 float로 캐스팅하고 ValueError를 잡는 것이 가장 빠른 방법 일 것입니다. 문자열 구문 분석 (정규식 등)이 필요한 다른 것은이 작업에 맞게 조정되지 않았기 때문에 느려질 수 있습니다. 내 $ 0.02.

유니 코드 문자열을 사용할 수 있으며 원하는 것을 수행하는 방법이 있습니다.

>>> s = u"345"
>>> s.isnumeric()
True

또는:

>>> s = "345"
>>> u = unicode(s)
>>> u.isnumeric()
True

http://www.tutorialspoint.com/python/string_isnumeric.htm

http://docs.python.org/2/howto/unicode.html

어떤 방법이 가장 빠른지 알고 싶었습니다. 전체적으로 가장 우수하고 일관된 결과가 check_replace기능에 의해 제공되었습니다 . check_exception함수에서 가장 빠른 결과를 얻었 지만 예외가 발생하지 않은 경우에만 해당됩니다. 즉, 코드가 가장 효율적이지만 예외를 발생시키는 오버 헤드는 상당히 큽니다.

성공적인 캐스트를 확인하는 것이 정확한 유일한 방법입니다. 예를 들어,이 방법은 작동 check_exception하지만 다른 두 테스트 함수는 유효한 float에 대해 False를 반환합니다.

huge_number = float('1e+100')

벤치 마크 코드는 다음과 같습니다.

import time, re, random, string

ITERATIONS = 10000000

class Timer:    
    def __enter__(self):
        self.start = time.clock()
        return self
    def __exit__(self, *args):
        self.end = time.clock()
        self.interval = self.end - self.start

def check_regexp(x):
    return re.compile("^\d*\.?\d*$").match(x) is not None

def check_replace(x):
    return x.replace('.','',1).isdigit()

def check_exception(s):
    try:
        float(s)
        return True
    except ValueError:
        return False

to_check = [check_regexp, check_replace, check_exception]

print('preparing data...')
good_numbers = [
    str(random.random() / random.random()) 
    for x in range(ITERATIONS)]

bad_numbers = ['.' + x for x in good_numbers]

strings = [
    ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(random.randint(1,10)))
    for x in range(ITERATIONS)]

print('running test...')
for func in to_check:
    with Timer() as t:
        for x in good_numbers:
            res = func(x)
    print('%s with good floats: %s' % (func.__name__, t.interval))
    with Timer() as t:
        for x in bad_numbers:
            res = func(x)
    print('%s with bad floats: %s' % (func.__name__, t.interval))
    with Timer() as t:
        for x in strings:
            res = func(x)
    print('%s with strings: %s' % (func.__name__, t.interval))

2017 MacBook Pro 13의 Python 2.7.10 결과는 다음과 같습니다.

check_regexp with good floats: 12.688639
check_regexp with bad floats: 11.624862
check_regexp with strings: 11.349414
check_replace with good floats: 4.419841
check_replace with bad floats: 4.294909
check_replace with strings: 4.086358
check_exception with good floats: 3.276668
check_exception with bad floats: 13.843092
check_exception with strings: 15.786169

2017 MacBook Pro 13의 Python 3.6.5 결과는 다음과 같습니다.

check_regexp with good floats: 13.472906000000009
check_regexp with bad floats: 12.977665000000016
check_regexp with strings: 12.417542999999995
check_replace with good floats: 6.011045999999993
check_replace with bad floats: 4.849356
check_replace with strings: 4.282754000000011
check_exception with good floats: 6.039081999999979
check_exception with bad floats: 9.322753000000006
check_exception with strings: 9.952595000000002

2017 MacBook Pro 13에서 PyPy 2.7.13의 결과는 다음과 같습니다.

check_regexp with good floats: 2.693217
check_regexp with bad floats: 2.744819
check_regexp with strings: 2.532414
check_replace with good floats: 0.604367
check_replace with bad floats: 0.538169
check_replace with strings: 0.598664
check_exception with good floats: 1.944103
check_exception with bad floats: 2.449182
check_exception with strings: 2.200056

따라서 모든 것을 종합하여 Nan, 무한대 및 복소수를 확인하려면 (i가 아닌 j로 지정 된 것처럼 보입니다 (예 : 1 + 2j)) 결과는 다음과 같습니다.

def is_number(s):
    try:
        n=str(float(s))
        if n == "nan" or n=="inf" or n=="-inf" : return False
    except ValueError:
        try:
            complex(s) # for complex
        except ValueError:
            return False
    return True

입력은 다음과 같습니다.

a="50" b=50 c=50.1 d="50.1"

1 일반 입력 :

이 기능의 입력은 모든 것이 될 수 있습니다!

주어진 변수가 숫자인지 확인합니다. 숫자 문자열은 선택적 부호, 자릿수, 선택적 10 진수 부분 및 선택적 지수 부분으로 구성됩니다. 따라서 + 0123.45e6은 유효한 숫자 값입니다. 16 진법 (예 : 0xf4c3b00c) 및 이진법 (예 : 0b10100111001) 표기법은 허용되지 않습니다.

is_numeric 함수

import ast
import numbers              
def is_numeric(obj):
    if isinstance(obj, numbers.Number):
        return True
    elif isinstance(obj, str):
        nodes = list(ast.walk(ast.parse(obj)))[1:]
        if not isinstance(nodes[0], ast.Expr):
            return False
        if not isinstance(nodes[-1], ast.Num):
            return False
        nodes = nodes[1:-1]
        for i in range(len(nodes)):
            #if used + or - in digit :
            if i % 2 == 0:
                if not isinstance(nodes[i], ast.UnaryOp):
                    return False
            else:
                if not isinstance(nodes[i], (ast.USub, ast.UAdd)):
                    return False
        return True
    else:
        return False

테스트:

>>> is_numeric("54")
True
>>> is_numeric("54.545")
True
>>> is_numeric("0x45")
True

is_float 함수

주어진 변수가 실수인지 확인합니다. 부동 문자열은 선택적 부호, 자릿수, ...로 구성됩니다.

import ast

def is_float(obj):
    if isinstance(obj, float):
        return True
    if isinstance(obj, int):
        return False
    elif isinstance(obj, str):
        nodes = list(ast.walk(ast.parse(obj)))[1:]
        if not isinstance(nodes[0], ast.Expr):
            return False
        if not isinstance(nodes[-1], ast.Num):
            return False
        if not isinstance(nodes[-1].n, float):
            return False
        nodes = nodes[1:-1]
        for i in range(len(nodes)):
            if i % 2 == 0:
                if not isinstance(nodes[i], ast.UnaryOp):
                    return False
            else:
                if not isinstance(nodes[i], (ast.USub, ast.UAdd)):
                    return False
        return True
    else:
        return False

테스트:

>>> is_float("5.4")
True
>>> is_float("5")
False
>>> is_float(5)
False
>>> is_float("5")
False
>>> is_float("+5.4")
True

뭐가 ast 입니까?

2- 가변 콘텐츠가 문자열 :

사용 str.isdigit () 메소드

>>> a=454
>>> a.isdigit()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'isdigit'
>>> a="454"
>>> a.isdigit()
True

3- 숫자 입력 :

int 값을 감지하십시오.

>>> isinstance("54", int)
False
>>> isinstance(54, int)
True
>>> 

플로트 감지 :

>>> isinstance("45.1", float)
False
>>> isinstance(45.1, float)
True

나는 약간의 속도 테스트를했다. 문자열 인 경우라고하자 가능성이 번호로 제외 / 시도 전략은 문자열이 가장 빠른 possible.If입니다 가능성이없는 숫자로 하고 관심있는 정수 점검, 그것은 몇 가지 테스트 (isdigit에 플러스 제목을 할 worths '-'). 플로트 번호를 확인하려면 try / except 코드 whitout 이스케이프 를 사용해야합니다 .

문자열이 기본 유형 (float, int, str, bool)으로 캐스팅되었는지 확인해야했습니다. 인터넷에서 아무것도 찾지 못하면 이것을 만들었습니다.

def str_to_type (s):
    """ Get possible cast type for a string

    Parameters
    ----------
    s : string

    Returns
    -------
    float,int,str,bool : type
        Depending on what it can be cast to

    """    
    try:                
        f = float(s)        
        if "." not in s:
            return int
        return float
    except ValueError:
        value = s.upper()
        if value == "TRUE" or value == "FALSE":
            return bool
        return type(s)

예

str_to_type("true") # bool
str_to_type("6.0") # float
str_to_type("6") # int
str_to_type("6abc") # str
str_to_type(u"6abc") # unicode       

유형을 캡처하여 사용할 수 있습니다

s = "6.0"
type_ = str_to_type(s) # float
f = type_(s) 

RyanN은 제안합니다

NaN 및 Inf에 대해 False를 반환하려면 line을 x = float (s)로 변경하십시오. (x == x) 및 (x-1! = x)를 반환합니다. Inf와 NaN을 제외한 모든 float에 대해 True를 반환해야합니다.

그러나 충분히 큰 플로트의 경우 x-1 == xtrue를 반환 하기 때문에 이것은 작동하지 않습니다 . 예를 들어2.0**54 - 1 == 2.0**54

난 당신의 솔루션을 잘 생각하지만 거기에 있다 올바른 정규 표현식 구현.

정당하지 않다고 생각되는 이러한 답변에 대한 많은 정규 표현식이 싫어 보입니다. 정규 표현식은 합리적으로 깨끗하고 정확하며 빠릅니다. 그것은 당신이하려는 일에 달려 있습니다. 원래 질문은 "문자열에 따라 문자열을 숫자 (부동)로 표시 할 수 있는지 확인"하는 방법이었습니다. 아마도 유효한지 확인한 후에 숫자 / 부동 값을 사용하려고 할 것입니다.이 경우 시도 / 제외가 의미가 있습니다. 그러나 어떤 이유로 든 문자열 을 확인하려는 경우 이 숫자 인지 경우그런 다음 정규 표현식도 제대로 작동하지만 올바르게 이해하기는 어렵습니다. 예를 들어, 지금까지 대부분의 정규식 답변이 파이썬과 관련하여 부동 소수점 인 정수 부분 (예 : ".7")이없는 문자열을 올바르게 구문 분석하지 않는다고 생각합니다. 그리고 분수 부분이 필요하지 않은 단일 정규식에서 확인하는 것은 약간 까다 롭습니다. 이것을 보여주기 위해 두 개의 정규 표현식을 포함 시켰습니다.

"숫자"가 무엇인지에 대한 흥미로운 질문을 제기합니다. 파이썬에서 float로 유효한 "inf"를 포함합니까? 또는 "숫자"이지만 파이썬으로 표현할 수없는 숫자 (예 : 부동 최대 값보다 큰 숫자)를 포함합니까?

숫자를 구문 분석하는 방법에 대한 모호성도 있습니다. 예를 들어 "--20"은 어떻습니까? 이것이 "숫자"입니까? 이것이 "20"을 나타내는 합법적 인 방법입니까? 파이썬은 "var = --20"을하도록하고 20으로 설정합니다 (실제로 표현식으로 취급하기 때문이지만) float ( "-20")는 작동하지 않습니다.

어쨌든, 더 많은 정보없이 여기에 파이썬이 파싱 할 때 모든 정수와 수레 를 다루는 정규식이 있습니다 .

# Doesn't properly handle floats missing the integer part, such as ".7"
SIMPLE_FLOAT_REGEXP = re.compile(r'^[-+]?[0-9]+\.?[0-9]+([eE][-+]?[0-9]+)?$')
# Example "-12.34E+56"      # sign (-)
                            #     integer (12)
                            #           mantissa (34)
                            #                    exponent (E+56)

# Should handle all floats
FLOAT_REGEXP = re.compile(r'^[-+]?([0-9]+|[0-9]*\.[0-9]+)([eE][-+]?[0-9]+)?$')
# Example "-12.34E+56"      # sign (-)
                            #     integer (12)
                            #           OR
                            #             int/mantissa (12.34)
                            #                            exponent (E+56)

def is_float(str):
  return True if FLOAT_REGEXP.match(str) else False

몇 가지 예제 테스트 값 :

True  <- +42
True  <- +42.42
False <- +42.42.22
True  <- +42.42e22
True  <- +42.42E-22
False <- +42.42e-22.8
True  <- .42
False <- 42nope

@ ron-reiter의 답변 에서 벤치마킹 코드를 실행하면 이 정규식이 실제로 일반 정규식보다 빠르며 예외보다 잘못된 값을 처리하는 데 훨씬 빠릅니다. 결과 :

check_regexp with good floats: 18.001921
check_regexp with bad floats: 17.861423
check_regexp with strings: 17.558862
check_correct_regexp with good floats: 11.04428
check_correct_regexp with bad floats: 8.71211
check_correct_regexp with strings: 8.144161
check_replace with good floats: 6.020597
check_replace with bad floats: 5.343049
check_replace with strings: 5.091642
check_exception with good floats: 5.201605
check_exception with bad floats: 23.921864
check_exception with strings: 23.755481

import re
def is_number(num):
    pattern = re.compile(r'^[-+]?[-0-9]\d*\.\d*|[-+]?\.?[0-9]\d*$')
    result = pattern.match(num)
    if result:
        return True
    else:
        return False


​>>>: is_number('1')
True

>>>: is_number('111')
True

>>>: is_number('11.1')
True

>>>: is_number('-11.1')
True

>>>: is_number('inf')
False

>>>: is_number('-inf')
False

여기 내 간단한 방법이 있습니다. 일부 문자열을 반복하고 숫자로 판명되면 배열에 추가하고 싶다고 가정 해 봅시다.

try:
    myvar.append( float(string_to_check) )
except:
    continue

myvar.apppend를 숫자로 밝혀지면 문자열로 수행하려는 작업으로 바꾸십시오. 아이디어는 float () 연산을 사용하고 리턴 된 오류를 사용하여 문자열이 숫자인지 여부를 판별하는 것입니다.

또한 언급 한 함수를 사용했지만 곧 문자열을 "Nan", "Inf"로 표시하고 그 변형이 숫자로 간주됩니다. 따라서 함수의 개선 된 버전을 제안합니다. 그러면 해당 유형의 입력에서 false가 반환되고 "1e3"변형이 실패하지 않습니다.

def is_float(text):
    try:
        float(text)
        # check for nan/infinity etc.
        if text.isalpha():
            return False
        return True
    except ValueError:
        return False

이 코드는 정규식을 사용하지 않고 지수, 부동 소수점 및 정수를 처리합니다.

return True if str1.lstrip('-').replace('.','',1).isdigit() or float(str1) else False

사용자 도우미 기능 :

def if_ok(fn, string):
  try:
    return fn(string)
  except Exception as e:
    return None

그때

if_ok(int, my_str) or if_ok(float, my_str) or if_ok(complex, my_str)
is_number = lambda s: any([if_ok(fn, s) for fn in (int, float, complex)])

True 및 False보다 유용한 값을 반환하여 예외 기술을 유용한 방식으로 일반화 할 수 있습니다. 예를 들어이 함수는 따옴표를 둥근 문자열로 표시하지만 숫자 만 남겨 둡니다. R에 대한 변수 정의를 만들기 위해 빠르고 더러운 필터에 필요한 것입니다.

import sys

def fix_quotes(s):
    try:
        float(s)
        return s
    except ValueError:
        return '"{0}"'.format(s)

for line in sys.stdin:
    input = line.split()
    print input[0], '<- c(', ','.join(fix_quotes(c) for c in input[1:]), ')'

나는이 스레드로 이끌어 낸 문제, 즉 가장 직관적 인 방법으로 데이터 모음을 문자열과 숫자로 변환하는 방법을 연구하고있었습니다. 원래 코드를 읽은 후 필요한 두 가지 방법이 다르다는 것을 깨달았습니다.

1-문자열이 정수를 나타내는 경우 정수 결과를 원했습니다.

2-숫자 또는 문자열 결과가 데이터 구조에 달라 붙기를 원했습니다.

그래서 나는이 파생물을 생성하기 위해 원래 코드를 수정했습니다.

def string_or_number(s):
    try:
        z = int(s)
        return z
    except ValueError:
        try:
            z = float(s)
            return z
        except ValueError:
            return s

이 시도.

 def is_number(var):
    try:
       if var == int(var):
            return True
    except Exception:
        return False

def is_float(s):
    if s is None:
        return False

    if len(s) == 0:
        return False

    digits_count = 0
    dots_count = 0
    signs_count = 0

    for c in s:
        if '0' <= c <= '9':
            digits_count += 1
        elif c == '.':
            dots_count += 1
        elif c == '-' or c == '+':
            signs_count += 1
        else:
            return False

    if digits_count == 0:
        return False

    if dots_count > 1:
        return False

    if signs_count > 1:
        return False

    return True