Jaki jest najlepszy możliwy sposób sprawdzenia, czy ciąg może być reprezentowany jako liczba w Pythonie?

Obecnie posiadam funkcję:

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

Co nie tylko jest brzydkie i powolne, wydaje się niezgrabne. Nie znalazłem jednak lepszej metody, ponieważ wywołanie floatfunkcji głównej jest jeszcze gorsze.

Co nie tylko jest brzydkie i wolne

Spierałbym się o jedno i drugie.

Wyrażenie regularne lub inna metoda parsowania łańcuchów byłaby brzydsza i wolniejsza.

Nie jestem pewien, czy cokolwiek może być szybsze niż powyższe. Wywołuje funkcję i zwraca. Try / Catch nie wprowadza dużego obciążenia, ponieważ najczęstszy wyjątek jest wychwytywany bez obszernego wyszukiwania ramek stosu.

Problem polega na tym, że każda funkcja konwersji numerycznej ma dwa rodzaje wyników

• Liczba, jeśli numer jest prawidłowy
• Kod stanu (np. Przez errno) lub wyjątek pokazujący, że nie można przeanalizować żadnego poprawnego numeru.

C (na przykład) włamuje się do tego na wiele sposobów. Python określa to jasno i wyraźnie.

Myślę, że twój kod do tego jest idealny.

Jeśli szukasz liczb całkowitych (dodatnich, niepodpisanych) zamiast liczb zmiennoprzecinkowych, możesz użyć isdigit()funkcji dla obiektów łańcuchowych.

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

Metody łańcuchowe - isdigit(): Python2 , Python3

Jest też coś w ciągach znaków Unicode, których nie znam zbytnio w Unicode - jest dziesiętny / dziesiętny

TL; DR Najlepszym rozwiązaniem jests.replace('.','',1).isdigit()

Zrobiłem kilka benchmarków porównując różne podejścia

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

Jeśli ciąg nie jest liczbą, blok wyjątków jest dość wolny. Ale co ważniejsze, metoda try-wyjątkiem jest jedynym podejściem, które poprawnie obsługuje notacje naukowe.

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

Notacja zmiennoprzecinkowa „.1234” nie jest obsługiwana przez:
- 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__)

Notacja naukowa „1.000000e + 50” nie jest obsługiwana przez:
- is_number_regex
- is_number_repl_isdigit
Notacja naukowa „1e50” nie jest obsługiwana przez:
- is_number_regex
- is_number_repl_isdigit

EDYCJA: Wyniki testu porównawczego

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

gdzie przetestowano następujące funkcje

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

Jest jeden wyjątek, który możesz wziąć pod uwagę: ciąg „NaN”

Jeśli chcesz, aby is_number zwrócił FALSE dla „NaN”, ten kod nie będzie działał, ponieważ Python konwertuje go na reprezentację liczby, która nie jest liczbą (mów o problemach z tożsamością):

>>> float('NaN')
nan

W przeciwnym razie powinienem naprawdę podziękować za fragment kodu, którego teraz intensywnie używam. :)

SOL.

co powiesz na to:

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

która zwróci wartość prawdy tylko wtedy, gdy jest jedna lub nie ma jej. ” w ciągu cyfr.

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

zwróci fałsz

edycja: właśnie zobaczyłem kolejny komentarz ... można dodać .replace(badstuff,'',maxnum_badstuff)dla innych przypadków. jeśli podajesz sól, a nie arbitralne przyprawy (ref: xkcd # 974 ), to zrobi dobrze: P

Co nie tylko jest brzydkie i powolne, wydaje się niezgrabne.

Może to trochę przyzwyczaić się, ale jest to pythonowy sposób. Jak już wspomniano, alternatywy są gorsze. Ale jest jeszcze jedna zaleta robienia rzeczy w ten sposób: polimorfizm.

Główną ideą pisania kaczek jest to, że „jeśli chodzi i mówi jak kaczka, to jest to kaczka”. Co jeśli zdecydujesz, że musisz podklasować ciąg znaków, abyś mógł zmienić sposób określania, czy coś można przekształcić w liczbę zmiennoprzecinkową? A co, jeśli zdecydujesz się całkowicie przetestować jakiś inny obiekt? Możesz robić te rzeczy bez konieczności zmiany powyższego kodu.

Inne języki rozwiązują te problemy za pomocą interfejsów. Zapiszę analizę, które rozwiązanie jest lepsze dla innego wątku. Chodzi o to, że Python jest zdecydowanie po stronie pisania kaczki równania i prawdopodobnie będziesz musiał przyzwyczaić się do takiej składni, jeśli planujesz dużo programowania w Pythonie (ale to nie znaczy musisz to oczywiście polubić).

Jeszcze jedna rzecz, którą warto wziąć pod uwagę: Python jest dość szybki w rzucaniu i wychwytywaniu wyjątków w porównaniu do wielu innych języków (na przykład 30 razy szybszy niż .Net). Do licha, sam język generuje nawet wyjątki w komunikowaniu nietypowych, normalnych warunków programu (za każdym razem, gdy używasz pętli for). Dlatego nie martwiłbym się zbytnio aspektami wydajności tego kodu, dopóki nie zauważysz znaczącego problemu.

Zaktualizowano po tym, jak Alfe wskazał, że nie trzeba sprawdzać pływaka osobno, ponieważ złożone obsługuje oba:

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

    return True

Wcześniej powiedziane: Czy w niektórych rzadkich przypadkach może być konieczne sprawdzenie liczb zespolonych (np. 1 + 2i), które nie mogą być reprezentowane przez liczbę zmiennoprzecinkową:

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

Aby intużyć tego:

>>> "1221323".isdigit()
True

Ale floatpotrzebujemy kilku sztuczek ;-). Każda liczba zmiennoprzecinkowa ma jeden punkt ...

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

Również dla liczb ujemnych po prostu dodaj lstrip():

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

A teraz mamy uniwersalny sposób:

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

Just Mimic C #

W języku C # istnieją dwie różne funkcje, które obsługują parsowanie wartości skalarnych:

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

float.parse ():

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

Uwaga: jeśli zastanawiasz się, dlaczego zmieniłem wyjątek na TypeError, oto dokumentacja .

float.try_parse ():

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

Uwaga: Nie chcesz zwracać wartości logicznej „False”, ponieważ nadal jest to typ wartości. Żadne nie jest lepsze, ponieważ wskazuje na niepowodzenie. Oczywiście, jeśli chcesz czegoś innego, możesz zmienić parametr fail na dowolny.

Aby rozszerzyć float o „parse ()” i „try_parse ()”, musisz dodać małpy do klasy „float”, aby dodać te metody.

Jeśli chcesz szanować istniejące wcześniej funkcje, kod powinien wyglądać następująco:

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

SideNote: Osobiście wolę nazywać to Monkey Punching, ponieważ wydaje mi się, że nadużywam języka, gdy to robię, ale YMMV.

Stosowanie:

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

A wielki Mędrzec Python powiedział do Stolicy Apostolskiej Sharpisus: „Wszystko, co możesz zrobić, mogę zrobić lepiej; Mogę zrobić wszystko lepiej niż ty”.

W przypadku ciągów nieliczbowych try: except:jest faktycznie wolniejszy niż wyrażenia regularne. W przypadku ciągów prawidłowych liczb wyrażenie regularne jest wolniejsze. Tak więc odpowiednia metoda zależy od danych wejściowych.

Jeśli okaże się, że jesteś w powiązaniu z wydajnością, możesz użyć nowego modułu innej firmy o nazwie fastnumbers, który udostępnia funkcję o nazwie isfloat . Pełne ujawnienie, jestem autorem. Zawarłem jego wyniki w poniższych harmonogramach.

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

Jak widzisz

• try: except: był szybki dla wprowadzania numerycznego, ale bardzo wolny dla nieprawidłowego wprowadzania
• Wyrażenie regularne jest bardzo wydajne, gdy dane wejściowe są nieprawidłowe
• fastnumbers wygrywa w obu przypadkach

Wiem, że jest to szczególnie stare, ale dodam odpowiedź, która moim zdaniem obejmuje informacje brakujące w głosowaniu, które uzyskały najwyższą ocenę, które mogą być bardzo cenne dla każdego, kto to znajdzie:

Dla każdej z poniższych metod połącz je z liczbą, jeśli potrzebujesz jakichkolwiek danych wejściowych do zaakceptowania. (Zakładając, że używamy wokalnych definicji liczb całkowitych zamiast 0–255 itd.)

x.isdigit() działa dobrze do sprawdzania, czy x jest liczbą całkowitą.

x.replace('-','').isdigit() działa dobrze do sprawdzania, czy x jest ujemne. (Sprawdź - w pierwszej pozycji)

x.replace('.','').isdigit() działa dobrze do sprawdzania, czy x jest liczbą dziesiętną.

x.replace(':','').isdigit() działa dobrze do sprawdzania, czy x jest stosunkiem.

x.replace('/','',1).isdigit() działa dobrze do sprawdzania, czy x jest ułamkiem.

Ta odpowiedź zawiera przewodnik krok po kroku mający funkcję z przykładami do znalezienia łańcucha:

• Dodatnia liczba całkowita
• Pozytywna / negatywna - liczba całkowita / liczba zmiennoprzecinkowa
• Jak odrzucić ciągi „NaN” (nie liczbę) podczas sprawdzania liczby?

Sprawdź, czy ciąg jest dodatnią liczbą całkowitą

Możesz użyć, str.isdigit()aby sprawdzić, czy podany ciąg jest dodatnią liczbą całkowitą.

Przykładowe wyniki:

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

Sprawdź, czy ciąg jest dodatni / ujemny - liczba całkowita / liczba zmiennoprzecinkowa

str.isdigit()zwraca, Falsejeśli ciąg jest liczbą ujemną lub liczbą zmiennoprzecinkową. Na przykład:

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

Jeśli chcesz również sprawdzić ujemne liczby całkowitefloat , a następnie możesz napisać niestandardową funkcję, aby to sprawdzić jako:

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

Przykładowy przebieg:

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

Odrzuć ciągi „NaN” (nie liczbę) podczas sprawdzania liczby

Powyższe funkcje zwrócą Trueciąg „NAN” (nie liczba), ponieważ dla Pythona jest to poprawna liczba zmiennoprzecinkowa, która nie jest liczbą. Na przykład:

>>> is_number('NaN')
True

Aby sprawdzić, czy liczba to „NaN”, możesz użyć math.isnan()jako:

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

>>> math.isnan(nan_num)
True

Lub jeśli nie chcesz importować dodatkowej biblioteki, aby to sprawdzić, możesz po prostu to sprawdzić, porównując go z samym sobą ==. Python zwraca, Falsegdy liczba nanzmiennoprzecinkowa jest porównywana z samym sobą. Na przykład:

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

Stąd powyżej funkcja is_numbermoże być aktualizowana, aby powrócić Falsedo"NaN" jako:

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

Przykładowy przebieg:

>>> 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: Każda operacja dla każdej kontroli w zależności od rodzaju numeru wiąże się z dodatkowym kosztem. Wybierz wersję is_numberfunkcji, która odpowiada Twoim wymaganiom.

Rzutowanie do float i przechwytywanie ValueError jest prawdopodobnie najszybszym sposobem, ponieważ float () jest specjalnie do tego przeznaczony. Wszystko inne, które wymaga analizowania ciągów (wyrażenia regularne itp.), Będzie prawdopodobnie wolniejsze, ponieważ nie jest dostrojone do tej operacji. Moje 0,02 $.

Możesz używać ciągów Unicode, mają metodę robienia tego, co chcesz:

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

Lub:

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

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

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

Chciałem zobaczyć, która metoda jest najszybsza. Ogólnie najlepsze i najbardziej spójne wyniki dała check_replacefunkcja. Najszybsze wyniki dała check_exceptionfunkcja, ale tylko wtedy, gdy nie został zgłoszony żaden wyjątek - co oznacza, że ​​jego kod jest najbardziej wydajny, ale narzut związany z rzuceniem wyjątku jest dość duży.

Pamiętaj, że sprawdzanie poprawności rzutowania to jedyna metoda, która jest dokładna, na przykład działa to, check_exceptionale pozostałe dwie funkcje testowe zwrócą wartość False dla prawidłowej liczby zmiennoprzecinkowej:

huge_number = float('1e+100')

Oto kod testu porównawczego:

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

Oto wyniki z Python 2.7.10 na MacBooku Pro 2017 2017:

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

Oto wyniki z Python 3.6.5 na MacBooku Pro 2017 2017:

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

Oto wyniki z PyPy 2.7.13 na MacBooku Pro 2017 2017:

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

Podsumowując, sprawdzając Nan, nieskończoność i liczby zespolone (wydaje się, że są one określone przez j, a nie i, tj. 1 + 2j), daje:

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

Dane wejściowe mogą być następujące:

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

1-Ogólne dane wejściowe:

Wejście tej funkcji może być wszystkim!

Sprawdza, czy podana zmienna jest liczbą. Ciągi liczbowe składają się z opcjonalnego znaku, dowolnej liczby cyfr, opcjonalnej części dziesiętnej i opcjonalnej części wykładniczej. Zatem + 0123.45e6 jest prawidłową wartością liczbową. Notacje szesnastkowe (np. 0xf4c3b00c) i binarne (np. 0b10100111001) są niedozwolone.

funkcja 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

test:

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

is_floatfunkcja

Sprawdza, czy dana zmienna jest zmiennoprzecinkowa. ciągi pływające składają się z opcjonalnego znaku, dowolnej liczby cyfr, ...

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

test:

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

co jest ast ?

2- Jeśli masz pewność, że zmienna treść to String :

użyj metody 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-numeryczne wprowadzanie danych:

wykryj wartość int:

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

wykrywanie pływaka:

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

Zrobiłem test prędkości. Powiedzmy, że jeśli łańcuch może być liczbą, strategia try / try jest najszybsza z możliwych. Jeśli łańcuch nie jest prawdopodobnie liczbą i jesteś zainteresowany sprawdzaniem liczb całkowitych , warto wykonać test (isdigit plus nagłówek „-”). Jeśli chcesz sprawdzić liczbę zmiennoprzecinkową, musisz użyć kodu try / oprócz bez znaku ucieczki.

Musiałem ustalić, czy ciąg rzutowany na podstawowe typy (float, int, str, bool). Po nie znalezieniu niczego w Internecie stworzyłem to:

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)

Przykład

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       

Możesz uchwycić typ i użyć go

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

RyanN sugeruje

Jeśli chcesz zwrócić False dla NaN i Inf, zmień wiersz na x = float (s); return (x == x) i (x - 1! = x). Powinno to zwrócić wartość True dla wszystkich pływaków oprócz Inf i NaN

Ale to nie do końca działa, ponieważ dla wystarczająco dużych pływaków x-1 == xzwraca true. Na przykład,2.0**54 - 1 == 2.0**54

Myślę, że twoje rozwiązanie jest w porządku, ale tak jest poprawna implementacja wyrażenia regularnego.

Wydaje się, że istnieje wiele nienawiści do wyrażeń regularnych wobec tych odpowiedzi, które moim zdaniem są nieuzasadnione, wyrażenia regularne mogą być dość czyste, poprawne i szybkie. To naprawdę zależy od tego, co próbujesz zrobić. Pierwotne pytanie brzmiało, jak „sprawdzić, czy ciąg może być reprezentowany przez liczbę (liczba zmiennoprzecinkowa)” (zgodnie z tytułem). Prawdopodobnie zechcesz użyć wartości liczbowej / zmiennoprzecinkowej po sprawdzeniu jej poprawności, w którym to przypadku próba / wyjątek ma sens. Ale jeśli z jakiegoś powodu chcesz po prostu sprawdzić, czy łańcuch jest liczbąto wyrażenie regularne również działa dobrze, ale trudno jest poprawić. Myślę, że większość dotychczasowych wyrażeń regularnych, na przykład, nie analizuje poprawnie ciągów znaków bez części całkowitej (takiej jak „.7”), która jest liczbą zmiennoprzecinkową, jeśli chodzi o python. Jest to nieco trudne do sprawdzenia w jednym wyrażeniu regularnym, w którym część ułamkowa nie jest wymagana. Dodałem dwa wyrażenia regularne, aby to pokazać.

Rodzi to interesujące pytanie, czym jest „liczba”. Czy dołączasz „inf”, który jest poprawny jako zmiennoprzecinkowy w Pythonie? Czy może zawierasz liczby, które są „liczbami”, ale może nie mogą być reprezentowane w pythonie (takie jak liczby większe niż liczba zmiennoprzecinkowa).

Istnieją również niejasności w sposobie przetwarzania liczb. Na przykład, co z „--20”? Czy to jest „liczba”? Czy to legalny sposób przedstawienia „20”? Python pozwoli ci zrobić „var = --20” i ustawić go na 20 (choć tak naprawdę dzieje się tak, ponieważ traktuje to jako wyrażenie), ale liczba zmiennoprzecinkowa („- 20”) nie działa.

W każdym razie, bez dodatkowych informacji, oto regex, który moim zdaniem obejmuje wszystkie inty i unosi się, gdy pyton je analizuje .

# 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

Niektóre przykładowe wartości testowe:

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

Uruchamianie benchmarkingu kod @ Ron-Reitera odpowiedziami pokazuje, że ten regex jest rzeczywiście szybciej niż normalny regex i jest znacznie szybciej na obsługę złych wartości niż wyjątkiem, co sprawia, że jakiś sens. Wyniki:

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

Oto mój prosty sposób na zrobienie tego. Powiedzmy, że przeglądam niektóre ciągi i chcę je dodać do tablicy, jeśli okażą się liczbami.

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

Zamień plik myvar.apppend na dowolną operację, którą chcesz zrobić z łańcuchem, jeśli okaże się, że jest liczbą. Chodzi o to, aby spróbować użyć operacji float () i użyć zwróconego błędu, aby ustalić, czy łańcuch jest liczbą, czy nie.

Użyłem również funkcji, o której wspomniałeś, ale wkrótce zauważam, że ciągi znaków jako „Nan”, „Inf” i jej odmiany są uważane za liczbę. Proponuję więc ulepszoną wersję twojej funkcji, która zwróci false dla tego typu danych wejściowych i nie zawiedzie wariantów „1e3”:

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

Ten kod obsługuje wykładniki, liczby zmiennoprzecinkowe i liczby całkowite bez użycia wyrażenia regularnego.

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

Funkcja pomocnika użytkownika:

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

następnie

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

Możesz uogólnić technikę wyjątku w przydatny sposób, zwracając bardziej przydatne wartości niż Prawda i Fałsz. Na przykład ta funkcja umieszcza cudzysłowy w okrągłych ciągach, ale pozostawia liczby same. Właśnie tego potrzebowałem do szybkiego i brudnego filtra, aby stworzyć pewne zmienne definicje dla 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:]), ')'

Pracowałem nad problemem, który doprowadził mnie do tego wątku, a mianowicie jak przekonwertować zbiór danych na ciągi i liczby w najbardziej intuicyjny sposób. Po przeczytaniu oryginalnego kodu zrozumiałem, że to, czego potrzebowałem, było inne na dwa sposoby:

1 - Chciałem uzyskać wynik w postaci liczby całkowitej, jeśli ciąg reprezentował liczbę całkowitą

2 - Chciałem, aby wynik liczbowy lub ciągowy przylgnął do struktury danych

więc dostosowałem oryginalny kod, aby uzyskać tę pochodną:

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

Spróbuj tego.

 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