Wie kann ich überprüfen, ob ein String eine Zahl (float) ist?

stimmen
1k

Was ist die beste Art und Weise zu überprüfen, ob eine Zeichenfolge als Zahl in Python dargestellt werden kann?

Die Funktion Im Moment habe ich gerade jetzt ist:

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

Welche, nicht nur hässlich und langsam ist, scheint klobig. Allerdings habe ich keine bessere Methode , weil Aufruf gefunden floatin der Hauptfunktion ist es noch schlimmer.

Veröffentlicht am 09/12/2008 um 21:03
quelle vom benutzer
In anderen Sprachen...                            


34 antworten

stimmen
1k

Falls Sie (positiv, unsigned) ganze Zahlen anstelle von Schwimmern suchen Parsen, können Sie die verwenden isdigit()Funktion für String - Objekte.

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

String-Methoden - isdigit()

Es gibt auch etwas auf Unicode - Strings, die ich mit nicht allzu vertraut bin Unicode - Ist Dezimal / dezimal

Beantwortet am 09/12/2008 um 21:15
quelle vom benutzer

stimmen
556

Welche, ist nicht nur hässlich und langsam

Ich würde beide bestreiten.

Ein regex oder andere Zeichenfolgenanalyse würde hässliche und langsamer.

Ich bin nicht sicher, dass alles viel schneller als die oben sein könnte. Es ruft die Funktion und kehrt zurück. Try / Catch nicht viel Aufwand nicht einführen, weil die häufigste Ausnahme ohne eine umfangreiche Suche von Stack-Frames gefangen wird.

Das Problem ist, dass jede numerische Konvertierungsfunktion hat zwei Arten von Ergebnissen

  • Eine Zahl, wenn die Zahl gültig
  • Ein Statuscode (zB über errno) oder eine Ausnahme zeigen, dass keine gültige Zahl analysiert werden kann.

C (als Beispiel) zerhackt, um dieses eine Reihe von Möglichkeiten. Python legt es klar und deutlich aus.

Ich denke, Ihr Code, dies zu tun ist perfekt.

Beantwortet am 09/12/2008 um 21:30
quelle vom benutzer

stimmen
62

Es gibt eine Ausnahme, die Sie vielleicht berücksichtigen: die Zeichenfolge ‚NaN‘

Wenn Sie is_number wollen FALSCH zurück für ‚NaN‘ Dieser Code wird nicht wie Python arbeiten wandelt sie in ihrer Darstellung einer Zahl, die keine Zahl (Diskussion über Identitätsfragen) ist:

>>> float('NaN')
nan

Andernfalls soll ich danke eigentlich für das Stück Code ich jetzt ausgiebig nutzen. :)

G.

Beantwortet am 01/09/2010 um 15:06
quelle vom benutzer

stimmen
56

TL; DR Die beste Lösung ists.replace('.','',1).isdigit()

Ich habe einige Benchmarks , die unterschiedlichen Ansätze zu vergleichen

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

Wenn der String keine Zahl ist, ist die Ausnahme-Block ziemlich langsam. Aber noch wichtiger ist, die try-except-Methode ist der einzige Ansatz, richtig wissenschaftliche Notationen behandelt.

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

Float Notation“0,1234" wird nicht unterstützt von:
- 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__)

Wissenschaftliche Notation "1.000000e + 50" wird nicht unterstützt von:
- is_number_regex
- is_number_repl_isdigit
wissenschaftlicher Schreibweise "1E50" wird nicht unterstützt von :
- is_number_regex
- is_number_repl_isdigit

EDIT: Die Benchmark-Ergebnisse

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

wobei die folgenden Funktionen wurden getestet

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

Geben Sie hier image description

Beantwortet am 13/05/2014 um 20:28
quelle vom benutzer

stimmen
51

Wie wäre es damit:

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

die gibt true zurück, nur wenn es eine oder nicht ist ‚‘ in der Folge von Ziffern.

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

wird return false

edit: gerade gesehen , einen weiteren Kommentar ... Hinzufügen einer .replace(badstuff,'',maxnum_badstuff)für den anderen Fällen getan werden kann. wenn Sie Salz sind vorbei und nicht willkürlich Würzmittel (ref: xkcd # 974 ) , wird dies tun gut: P

Beantwortet am 25/05/2012 um 23:22
quelle vom benutzer

stimmen
37

Aktualisiert nach Alfe wies darauf hin, Sie müssen nicht separat für Schwimmer zu überprüfen, wie komplex beide Griffe:

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

    return True

Zuvor sagte: Ist einige seltene Fälle, die Sie auch für komplexe Zahlen (zB 1 + 2i) zu überprüfen, müssen möglicherweise, die nicht durch einen Schwimmer dargestellt werden:

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
Beantwortet am 26/07/2010 um 14:10
quelle vom benutzer

stimmen
37

Welche, nicht nur hässlich und langsam ist, scheint klobig.

Es kann etwas gewöhnungsbedürftig, aber das ist die pythonic Art und Weise tun. Wie bereits darauf hingewiesen wurde, sind die Alternativen schlechter. Aber es gibt einen anderen Vorteil der Dinge auf diese Weise tun: Polymorphismus.

Die zentrale Idee hinter Duck Typing ist, dass „wenn es geht und spricht wie eine Ente, dann ist es eine Ente.“ Was passiert, wenn Sie entscheiden, dass Sie Zeichenfolge Unterklasse benötigen, so dass Sie ändern können, wie Sie feststellen, ob etwas in einem Schwimmer umgerechnet werden können? Oder was, wenn Sie sich entscheiden, ganz ein anderes Objekt zu testen? Sie können diese Dinge tun, ohne den obigen Code ändern zu müssen.

Andere Sprachen lösen diese Probleme durch Schnittstellen. Ich werde die Analyse davon sparen Lösung besser für einen anderen Thread ist. Der Punkt ist aber, dass Python entschieden auf die Ente Typisierung Seite der Gleichung ist, und Sie sind wahrscheinlich wie diese gehen zu müssen, gewöhnen Syntax, wenn Sie auf dem Tun viel Programmierung in Python planen (aber das bedeutet nicht, Sie haben es natürlich mögen).

Eine andere Sache, die Sie vielleicht in Betracht ziehen wollen: Python ist ziemlich schnell in Werfen und Ausnahmen im Vergleich zu vielen anderen Sprachen (30x schneller als .Net zum Beispiel) zu kontrollieren. Heck, die Sprache selbst wirft auch Ausnahmen kommunizieren nicht außergewöhnlich, normale Programmbedingungen (jedes Mal, wenn Sie eine for-Schleife). So würde ich nicht zu viel Sorgen über die Leistungsaspekte dieses Codes, bis Sie ein erhebliches Problem bemerken.

Beantwortet am 11/12/2008 um 05:56
quelle vom benutzer

stimmen
17

Für die intVerwendung dieses:

>>> "1221323".isdigit()
True

Aber floatwir brauchen ein paar Tricks ;-). Jeder Schwimmer Nummer hat einen Punkt ...

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

Auch für negative Zahlen nur hinzufügen lstrip():

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

Und jetzt bekommen wir eine universelle Art und Weise:

>>> '-12.34'.lstrip('-').replace('.','',1).isdigit()
True
>>> '.-234'.lstrip('-').replace('.','',1).isdigit()
False
Beantwortet am 08/09/2015 um 08:42
quelle vom benutzer

stimmen
14

Bei Strings von Nicht-Zahlen, try: except:ist tatsächlich langsamer als regulärer Ausdrücke. Bei Strings gültiger Zahlen ist regex langsamer. So hängt die entsprechende Methode auf Ihre Eingabe.

Wenn Sie feststellen , dass Sie in einer Performance binden sind, können Sie ein neues Dritt Modul namens verwenden fastnumbers , die eine Funktion namens bietet isfloat . Vollständige Offenlegung, ich bin der Autor. Ich habe seine Ergebnisse in den Zeiten unten enthalten.


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

Wie du siehst

  • try: except: für numerische Eingaben schnell war aber sehr langsam für eine ungültige Eingabe
  • regex ist sehr effizient, wenn die Eingabe ungültig ist
  • fastnumbers gewinnt in beiden Fällen
Beantwortet am 14/08/2014 um 04:34
quelle vom benutzer

stimmen
14

Nur Mimic C #

In C # gibt es zwei verschiedene Funktionen, die das Parsen von skalaren Werten verarbeiten:

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

float.parse ():

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

Hinweis: Wenn Sie sich fragen , warum ich die Ausnahme von einem Typeerror geändert, hier ist die Dokumentation .

float.try_parse ():

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

Hinweis: Sie wollen nicht die boolean ‚False‘ zurück, weil das immer noch ein Werttyp ist. Keiner ist besser, weil es Fehler anzeigt. Natürlich, wenn Sie etwas anderes wollen, können Sie den Parameter zum Scheitern verurteilt ändern, was auch immer Sie wollen.

Zur Verlängerung der Schwimmer umfassen die ‚Parse ()‘ und ‚try_parse ()‘ müssen Sie die ‚schweben‘ Klasse monkeypatch diese Methoden hinzuzufügen.

Wenn Sie respektieren wollen bereits bestehenden Funktionen sollte der Code so etwas wie:

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

Sidenote: Ich persönlich lieber nennen Affe Stanzen, weil es fühlt sich an wie ich die Sprache bin zu missbrauchen, wenn ich dies tun, aber YMMV.

Verwendung:

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

Und die große, sagte Sage Pythonas beim Heiligen Stuhl Sharpisus „Alles, was man tun kann ich besser machen kann, ich kann besser als Sie nichts tun.“

Beantwortet am 18/02/2012 um 02:35
quelle vom benutzer

stimmen
13

Ich weiß, das besonders alt ist, aber ich möchte hinzufügen, eine Antwort, die ich glaube, deckt die fehlenden Informationen aus der höchsten Antwort gestimmt, die zu einem sehr wertvoll sein könnte, die diesen finden:

Für jede der folgenden Methoden, um sie mit einer Zählung verbinden, wenn Sie jede Eingabe müssen in Kauf genommen werden. (Vorausgesetzt, wir sind mit Stimm Definitionen von ganzen Zahlen anstatt 0-255, etc.)

x.isdigit() wenn x funktioniert gut für die Überprüfung eine ganze Zahl ist.

x.replace('-','').isdigit() wenn x funktioniert gut für die Überprüfung negativ ist (Check - in der ersten Position).

x.replace('.','').isdigit() wenn x funktioniert gut für die Überprüfung eine Dezimalzahl ist.

x.replace(':','').isdigit() wenn x funktioniert gut für die Überprüfung ein Verhältnis ist.

x.replace('/','',1).isdigit() wenn x funktioniert gut für die Überprüfung ein Bruchteil ist.

Beantwortet am 05/01/2016 um 15:21
quelle vom benutzer

stimmen
10

Sie können Unicode-Strings verwenden, sie haben eine Methode genau das zu tun, was Sie wollen:

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

Oder:

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

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

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

Beantwortet am 04/03/2013 um 17:12
quelle vom benutzer

stimmen
9

Casting zu schweben und Valueerror Fang ist wahrscheinlich der schnellste Weg, da Schwimmer () für die spezifisch gemeint ist einfach. Alles andere, die String-Parsing (regex, etc.) erfordert wird wahrscheinlich langsamer sein aufgrund der Tatsache, dass es für diese Operation nicht abgestimmt ist. My $ 0,02.

Beantwortet am 09/12/2008 um 21:31
quelle vom benutzer

stimmen
8

Lassen Sie uns sagen Sie Ziffern in Zeichenfolge haben. str = „100949“ und Sie würden überprüfen möchten, ob es nur Zahlen hat

if str.isdigit():
returns TRUE or FALSE 

isdigit docs

sonst wird Ihre Methode funktioniert gut, das Auftreten einer Ziffer in einer Zeichenfolge zu finden.

Beantwortet am 13/10/2014 um 10:17
quelle vom benutzer

stimmen
7

Ich wollte sehen , welche Methode ist am schnellsten. Insgesamt sind die besten und beständigsten Ergebnisse wurden durch die gegebene check_replaceFunktion. Die schnellsten Ergebnisse wurden durch die gegebene check_exceptionFunktion, aber nur , wenn es keine Ausnahme gefeuert - seinen Code Bedeutung der effizienteste ist, aber der Aufwand für das Auslösen einer Ausnahme ist recht groß.

Bitte beachten Sie, dass für eine erfolgreiche Besetzung Überprüfung der einzige Methode ist , die genau ist, zum Beispiel, das funktioniert mit , check_exceptionaber die andere beiden Testfunktionen werden falsch für einen gültigen Schwimmer zurück:

huge_number = float('1e+100')

Hier ist der Benchmark-Code:

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

Hier sind die Ergebnisse mit Python 2.7.10 auf eine 2017 MacBook Pro 13:

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

Hier sind die Ergebnisse mit Python 3.6.5 auf eine 2017 MacBook Pro 13:

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

Hier sind die Ergebnisse mit PyPy 2.7.13 auf eine 2017 MacBook Pro 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
Beantwortet am 16/01/2013 um 07:09
quelle vom benutzer

stimmen
6

Also um es alle zusammen, für Nan Überprüfung, Unendlichkeit und komplexe Zahlen (es scheint sie mit j angegeben sind, nicht i, dh 1 + 2j) führt dies zu:

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
Beantwortet am 23/03/2012 um 17:10
quelle vom benutzer

stimmen
5

Ihr Code sieht für mich in Ordnung.

Vielleicht denken Sie, der Code wegen der Verwendung von Ausnahmen „klobig“ ist? Beachten Sie, dass Python-Programmierer sind in der Regel Ausnahmen großzügig verwenden, wenn es die Lesbarkeit des Codes, dank seiner geringen Leistungseinbuße verbessert.

Beantwortet am 11/12/2008 um 05:03
quelle vom benutzer

stimmen
4

Diese Antwort wird Schritt für Schritt Anleitung, die Funktion mit Beispielen die Zeichenfolge zu finden ist:

  • Positive ganze Zahl
  • Positiv / Negativ - integer / float
  • Wie zu verwerfen „NaN“ (keine Zahl) Saiten, während für Nummernprüfung?

Überprüfen Sie, ob String positive ganze Zahl

Sie können verwendet werden str.isdigit()um zu überprüfen , ob gegebene Zeichenfolge positive ganze Zahl ist .

Probenergebnisse:

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

Überprüfen Sie, ob String als positiv / negativ - integer / float

str.isdigit()zurück , Falsewenn die Zeichenfolge a negative Zahl oder eine Gleitkommazahl. Beispielsweise:

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

Wenn Sie wollen auch für die Überprüfung negativ ganzen Zahlen undfloat , dann können Sie eine benutzerdefinierte Funktion schreiben für sie zu überprüfen , wie:

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

Probelauf:

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

Verwerfen „NaN“ (keine Zahl) Saiten, während für Nummernprüfung

Die oben genannten Funktionen kehren Truefür die „NAN“ (Not a number) Zeichenfolge , weil für Python ist gültig Schwimmer repräsentiert es keine Zahl ist. Beispielsweise:

>>> is_number('NaN')
True

Um zu prüfen , ob die Zahl „NaN“, können Sie verwenden math.isnan()als:

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

>>> math.isnan(nan_num)
True

Oder wenn Sie nicht wollen , zusätzliche Bibliothek importieren , um dies zu überprüfen, dann können Sie einfach überprüfen , über den Vergleich mit sich selbst verwendet ==. Python zurück , Falsewenn nanSchwimmer mit sich selbst verglichen wird. Beispielsweise:

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

Daher oben Funktion is_numberkann zurückkehren werden aktualisiert Falsefür"NaN" wie:

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

Probelauf:

>>> 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: Jede Operation für jede Überprüfung des Nummerntyp abhängig kommt mit zusätzlichen Overhead. Wählen Sie die Version der is_numberFunktion , die Ihren Anforderungen entspricht.

Beantwortet am 11/02/2018 um 08:34
quelle vom benutzer

stimmen
4

Ich brauchte, um zu bestimmen, ob ein String in Grundtypen gegossen (float, int, str, bool). Nach dem nichts im Internet finden, die ich diese erstellt:

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)

Beispiel

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       

Sie können die Art erfassen und verwenden

s = "6.0"
type_ = str_to_type(s) # float
f = type_(s) 
Beantwortet am 03/07/2014 um 18:12
quelle vom benutzer

stimmen
4

Ich habe einige Geschwindigkeitstests. Lassen Sie uns sagen , dass , wenn die Zeichenfolge ist wahrscheinlich eine Anzahl der sein try / except Strategie der schnellste possible.If ist die Zeichenfolge nicht wahrscheinlich , um eine Zahl zu sein und Sie sind interessiert an Integer - Check, es lohnt sich einige Test (isdigit zu tun und Überschrift '-'). Wenn Sie Interesse zu prüfen float Zahl sind, müssen Sie die Verwendung try / except Code whitout Flucht.

Beantwortet am 12/10/2010 um 08:43
quelle vom benutzer

stimmen
3

Die Eingabe kann wie folgt sein:

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


1-Allgemeine-Eingang:

Die Eingabe dieser Funktion kann alles sein!

Prüft, ob die gegebene Variable numerisch ist. Numerische Strings bestehen aus optionalen Vorzeichen, eine beliebige Anzahl von Ziffern, optional Dezimalteil und optional exponentiellen Teil. So + 0123.45e6 ist ein gültiger numerischer Wert. Hexadezimal (zB 0xf4c3b00c) und binäre (zB 0b10100111001) Notation ist nicht erlaubt.

is_numeric Funktion

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

Prüfung:

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

is_float Funktion

Prüft, ob die gegebene Variable float ist. float Saiten bestehen aus optionalen Vorzeichen, eine beliebige Anzahl von Ziffern, ...

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

Prüfung:

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

was ist ast ?


2- Wenn Sie sicher sind , dass der variable Gehalt String :

Verwendung str.isdigit () Methode

>>> 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-Numerical-Eingang:

erkennen int-Wert:

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

erkennen float:

>>> isinstance("45.1", float)
False
>>> isinstance(45.1, float)
True
Beantwortet am 06/10/2018 um 07:23
quelle vom benutzer

stimmen
3

Ryann schlägt vor,

Wenn Sie möchten, für eine NaN und Inf, ändern Linie x = float Falsch zurück (s); return (x == x) und (x - 1 = x). Dies sollte für alle Schwimmer außer Inf und NaN true zurück

Aber das funktioniert nicht ganz, denn für ausreichend großen Schwimmer, x-1 == xtrue zurück. Beispielsweise,2.0**54 - 1 == 2.0**54

Beantwortet am 29/07/2013 um 15:08
quelle vom benutzer

stimmen
1

Ich habe auch die Funktion, die Sie erwähnten, aber bald merke ich, dass Strings als „Nan“, „Inf“ und es ist Variation als Zahl betrachtet werden. Also schlage ich Ihnen Version Ihrer Funktion verbessert, die auf jene Art von Eingabe false zurück und wird nicht scheitern „1e3“ Varianten:

def is_float(text):
    try:
        float(text)
        # check for nan/infinity etc.
        if text.isalpha():
            return False
        return True
    except ValueError:
        return False
Beantwortet am 15/10/2016 um 21:11
quelle vom benutzer

stimmen
1

Sie können regex verwenden.

number = raw_input("Enter a number: ")
if re.match(r'^\d+$', number):
    print "It's integer"
    print int(number)
elif re.match(r'^\d+\.\d+$', number):
    print "It's float"
    print float(number)
else:
    print("Please enter a number")
Beantwortet am 23/08/2015 um 13:22
quelle vom benutzer

stimmen
1

Versuche dies.

 def is_number(var):
    try:
       if var == int(var):
            return True
    except Exception:
        return False
Beantwortet am 30/05/2015 um 17:12
quelle vom benutzer

stimmen
1

Ich arbeite an einem Problem, das mich auf diesen Thread geführt, nämlich wie eine Sammlung von Daten in Strings und Zahlen in der meisten intuitiven Art und Weise zu konvertieren. Ich erkennen nach dem ursprünglichen Code zu lesen, dass, was ich brauchte in zweierlei Hinsicht anders war:

1 - Ich wollte ein ganzzahliges Ergebnis, wenn die Zeichenfolge eine ganze Zahl repräsentiert

2 - Ich wollte eine Zahl oder eine Zeichenkette Ergebnis in eine Datenstruktur kleben

so angepasst ich den Original-Code, um dieses Derivat zu erzeugen:

def string_or_number(s):
    try:
        z = int(s)
        return z
    except ValueError:
        try:
            z = float(s)
            return z
        except ValueError:
            return s
Beantwortet am 09/11/2014 um 14:06
quelle vom benutzer

stimmen
1

Hier ist meine einfache Art und Weise tun. Lassen Sie uns sagen, dass ich durch einige Saiten bin Looping und ich möchte, dass sie zu einem Array hinzuzufügen, wenn sie sich als Zahlen.

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

Ersetzen Sie die myvar.apppend mit dem, was den Betrieb wollen Sie mit der Zeichenfolge zu tun, wenn sich herausstellt, eine Nummer zu sein. Die Idee ist, zu versuchen, einen Schwimmer () Betrieb zu verwenden, und den zurückgegebene Fehler verwenden, um zu bestimmen, ob die Zeichenfolge eine Zahl ist.

Beantwortet am 16/07/2009 um 18:45
quelle vom benutzer

stimmen
1

Wenn Sie , wenn die wissen wollen , ganze kann Zeichenfolge als Zahl dargestellt werden Sie wollen einen regulären Ausdruck verwenden (oder vielleicht den Schwimmer konvertieren zurück in einen String und vergleichen Sie es mit dem Source - String, aber ich vermute , das ist nicht sehr schnell ).

Beantwortet am 10/12/2008 um 10:15
quelle vom benutzer

stimmen
0

Dieser Code behandelt die Exponenten, die Schwimmer und ganze Zahlen, wihtout regex.

return True if str1.lstrip('-').replace('.','',1).isdigit() or float(str1) else False
Beantwortet am 16/12/2018 um 07:12
quelle vom benutzer

stimmen
0
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
Beantwortet am 02/08/2018 um 11:06
quelle vom benutzer

stimmen
0

verwenden folgende es alle Fälle behandelt: -

import re
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.3') 
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '.3')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.3sd')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.3')
Beantwortet am 24/02/2017 um 11:11
quelle vom benutzer

stimmen
0

Um zu überprüfen , ob der Eingangswert a ist float, können Sie die Art des Eingangs zu einer Vergleichfloat

def isFloat(s):
    realFloat = 0.1

    if type(s) == type(realFloat):
        return True
    else:
        return False

Kehrt zurück:

False     # s = 5
True      # s = 1.2345

Die ursprüngliche Post würde tatsächlich zurückkehren Truezu , s = 5da es eine Zahl (integer) und Sie können einen Guss intzu einem floatohne ValueError. Wenn Sie überprüfen wollen , dass es eine wirklich ist , floatanstatt nur eine Zahl, müßten Sie für diesen Fall zu berücksichtigen.

Beantwortet am 16/09/2016 um 05:00
quelle vom benutzer

stimmen
0

Sie können durch Rücksendung nützliche Werte als Wahr und Falsch, die Ausnahme-Technik in einer sinnvollen Weise verallgemeinern. Zum Beispiel setzt diese Funktion Zitate runden Schnüre lässt aber Zahlen allein. Das ist genau das, was ich für einen schnellen und schmutzige Filter benötigt, um einige variable Definitionen für R. zu machen

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:]), ')'
Beantwortet am 24/05/2013 um 22:36
quelle vom benutzer

stimmen
-1

Ich habe ein ähnliches Problem. Anstatt eine ISNUMBER Funktion definieren, ich möchte eine Liste von Zeichenketten konvertieren schwimmt, etwas, das in einer hohen Abstraktionsebene wäre:

[ float(s) for s in list if isFloat(s)]

Es ist eine Selbstverständlichkeit wir den Schwimmer nicht wirklich trennen kann (n) von den isFloat (n) Funktionen: Diese beiden Ergebnisse sind durch die gleiche Funktion zurückgegeben werden. Auch, wenn Schwimmer (s) ausfällt, der gesamte Prozess fehlschlägt, statt nur das fehlerhafte Element zu ignorieren. Plus „0“ ist eine gültige Zahl und sollte in die Liste aufgenommen werden. Wenn schlechte Elemente herausgefiltert werden, sicher sein, nicht 0 auszuschließen.

Daher muss das oben Verständnis modifiziert werden, irgendwie:

  • wenn ein Element in der Liste kann nicht konvertiert werden, ignorieren sie und wirft keine Ausnahme
  • vermeiden Schwimmer Aufruf (e) mehr als einmal für jedes Element (eine für die Umwandlung, die andere für den Test)
  • wenn der konvertierte Wert 0 ist, sollte es noch in der endgültigen Liste vorhanden sein

Ich schlage vor, eine Lösung in dem Nullable numerischen Typen von C # inspiriert. Diese Typen werden intern durch eine Struktur dargestellt, die den numerischen Wert hat und fügt eine Bedingung, die anzeigt, ob der Wert gültig ist:

def tryParseFloat(s):
    try:
        return(float(s), True)
    except:
        return(None, False)

tupleList = [tryParseFloat(x) for x in list]
floats = [v for v,b in tupleList if b]
Beantwortet am 18/03/2018 um 00:18
quelle vom benutzer

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more