wake-up-neo.com

Wie analysiere ich einen String in ein Float oder ein Int?

Wie kann ich in Python einen numerischen String wie "545.2222" auf den entsprechenden Gleitkommawert 545.2222 parsen? Oder analysieren Sie die Zeichenfolge "31" in eine Ganzzahl, 31?

Ich möchte nur wissen, wie man ein floatstr zu einem float und (separat) ein intstr zu einem int.

2056
>>> a = "545.2222"
>>> float(a)
545.22220000000004
>>> int(float(a))
545
2417
Harley Holcombe
def num(s):
    try:
        return int(s)
    except ValueError:
        return float(s)
483
Javier

Python-Methode zum Überprüfen, ob ein String ein Float ist:

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

Ein längerer und genauerer Name für diese Funktion könnte sein: is_convertible_to_float(value)

Was ist, und ist kein Schwimmer in Python kann Sie überraschen:

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

Sie glauben zu wissen, was Zahlen sind? Du bist nicht so gut wie du denkst! Keine große Überraschung.

Verwenden Sie diesen Code nicht für lebenswichtige Software!

Wenn Sie auf diese Weise breite Ausnahmen abfangen, Kanarienvögel töten und die Ausnahme verschlingen, besteht eine geringe Wahrscheinlichkeit, dass ein gültiger float als String false zurückgibt. Die Codezeile float(...) kann aus tausend Gründen fehlschlagen, die nichts mit dem Inhalt der Zeichenfolge zu tun haben. Wenn Sie jedoch lebenswichtige Software in einer Prototypensprache wie Python schreiben, haben Sie viel größere Probleme.

474
Eric Leschinski

Dies ist eine weitere Methode, die hier erwähnt werden sollte ast.literal_eval :

Dies kann zum sicheren Auswerten von Zeichenfolgen verwendet werden, die Python Ausdrücke aus nicht vertrauenswürdigen Quellen enthalten, ohne dass die Werte selbst analysiert werden müssen.

Das heißt, eine sichere "Bewertung"

>>> import ast
>>> ast.literal_eval("545.2222")
545.2222
>>> ast.literal_eval("31")
31
121
wim
float(x) if '.' in x else int(x)
75
Dino Viehland

Lokalisierung und Kommas

Sie sollten die Möglichkeit von Kommas in der Zeichenfolgendarstellung einer Zahl in Betracht ziehen, für Fälle wie float("545,545.2222"), die eine Ausnahme auslösen. Verwenden Sie stattdessen Methoden in locale, um die Zeichenfolgen in Zahlen zu konvertieren und Kommas korrekt zu interpretieren. Die locale.atof -Methode wird in einem Schritt in ein Float konvertiert, sobald das Gebietsschema für die gewünschte Nummernkonvention festgelegt wurde.

Beispiel 1 - US-amerikanische Nummernkonventionen

In den USA und Großbritannien können Kommas als Tausendertrennzeichen verwendet werden. In diesem Beispiel mit amerikanischem Gebietsschema wird das Komma ordnungsgemäß als Trennzeichen behandelt:

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

Beispiel 2 - Europäische Nummernkonventionen

In den meisten Ländern der Welt werden Kommas anstelle von Punkten für Dezimalzeichen verwendet. In diesem Beispiel mit französischem Gebietsschema wird das Komma korrekt als Dezimalzeichen behandelt:

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

Die Methode locale.atoi ist ebenfalls verfügbar, das Argument sollte jedoch eine Ganzzahl sein.

60
Mark Chackerian

Wenn Sie keine Abneigung gegen Module von Drittanbietern haben, können Sie das Modul fastnumbers ausprobieren. Es bietet eine Funktion mit dem Namen fast_real , die genau das tut, was diese Frage verlangt, und dies schneller als eine reine Python-Implementierung:

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

Die Benutzer codelogic und harley sind korrekt, aber denken Sie daran, dass Sie int ("545") aufrufen können, wenn Sie wissen, dass die Zeichenfolge eine Ganzzahl ist (z. B. 545) Gießen, um zu schweben.

Wenn sich Ihre Zeichenfolgen in einer Liste befinden, können Sie auch die Kartenfunktion verwenden.

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

Es ist nur gut, wenn sie alle vom selben Typ sind.

24
Chris Cameron

Die Frage scheint ein bisschen alt. Aber lassen Sie mich eine Funktion vorschlagen, parseStr, die etwas Ähnliches erzeugt, dh Integer oder Float zurückgibt, und wenn eine gegebene Zeichenfolge ASCII nicht in keine konvertiert werden kann, wird sie unberührt zurückgegeben. Der Code kann natürlich angepasst werden, um nur das zu tun, was Sie wollen:

   >>> 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'
19
krzym

Wie kann ich in Python eine numerische Zeichenfolge wie "545.2222" auf den entsprechenden Gleitkommawert (542.2222) parsen? Oder parsen Sie die Zeichenfolge "31" in eine Ganzzahl, 31? Ich möchte nur wissen, wie eine float-Zeichenfolge in eine float-Zeichenfolge und (separat) eine int-Zeichenfolge in eine int-Zeichenfolge umgewandelt wird.

Es ist gut, dass Sie darum bitten, dies separat zu tun. Wenn Sie sie mischen, können Sie sich später auf Probleme einstellen. Die einfache Antwort lautet:

"545.2222" um zu schweben:

>>> float("545.2222")
545.2222

"31" zu einer ganzen Zahl:

>>> int("31")
31

Andere Konvertierungen, Ints zu und von Strings und Literalen:

Konvertierungen von verschiedenen Basen, und Sie sollten die Basis im Voraus kennen (10 ist die Standardeinstellung). Beachten Sie, dass Sie ihnen das Präfix voranstellen können, was Python für seine Literale erwartet (siehe unten), oder das Präfix entfernen:

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

Wenn Sie die Basis nicht im Voraus kennen, aber wissen, dass sie das richtige Präfix haben, kann Python dies für Sie herleiten, wenn Sie 0 als Basis übergeben:

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

Nicht dezimale (d. H. Ganzzahlige) Literale aus anderen Basen

Wenn Ihre Motivation darin besteht, dass Ihr eigener Code fest codierte spezifische Werte eindeutig darstellt, müssen Sie möglicherweise nicht von den Basen aus konvertieren - Sie können Python dies automatisch mit der richtigen Syntax für Sie tun lassen.

Sie können die Präfixe apropos verwenden, um eine automatische Konvertierung in Ganzzahlen mit den folgenden Literalen zu erhalten. Diese gelten für Python 2 und 3:

Binär, Präfix 0b

>>> 0b11111
31

Oktal, Präfix 0o

>>> 0o37
31

Hexadezimal, Präfix 0x

>>> 0x1f
31

Dies kann hilfreich sein, wenn Sie Binärflags, Dateiberechtigungen im Code oder hexadezimale Werte für Farben beschreiben. Beachten Sie beispielsweise keine Anführungszeichen:

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

Mehrdeutige Python 2 Oktale mit Python 3 kompatibel machen

Wenn Sie in Python 2 eine Ganzzahl sehen, die mit einer 0 beginnt, ist dies eine (veraltete) Oktalsyntax.

>>> 037
31

Es ist schlecht, weil es so aussieht, als ob der Wert 37 sein sollte. In Python 3 wird nun SyntaxError ausgelöst:

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

Konvertieren Sie Ihre Python 2 Oktale in Oktale, die sowohl in 2 als auch in 3 mit dem 0o-Präfix funktionieren:

>>> 0o37
31
19
Aaron Hall

float("545.2222") und int(float("545.2222"))

16
codelogic

Ich benutze diese Funktion dafür

import ast

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

Die Zeichenfolge wird in den Typ konvertiert

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

Mit dem Parser YAML können Sie herausfinden, um welchen Datentyp es sich bei Ihrer Zeichenfolge handelt. Verwenden Sie yaml.load(), und testen Sie dann mit type(result) den Typ:

>>> 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'>
13
Rafe
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
11
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')
9
Jerry T

Sie müssen die Rundung berücksichtigen, um dies richtig zu tun.

Das heißt int (5.1) => 5 int (5.6) => 5 - falsch, sollte 6 sein, also machen wir int (5.6 + 0.5) => 6

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

Ich bin überrascht, dass niemand Regex erwähnt hat, da die Zeichenfolge manchmal vorbereitet und normalisiert werden muss, bevor sie auf die Nummer geworfen wird

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

verwendungszweck:

parseNumber('13,345')
> 13345.0

parseNumber('- 123 000')
> -123000.0

parseNumber('99999\n')
> 99999.0

übrigens, um zu überprüfen, ob Sie eine Nummer haben:

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

Verwenden Sie für die Typumwandlung in python die Konstruktorfunktionen des Typs und übergeben Sie den String (oder den Wert, den Sie umwandeln möchten) als Parameter.

Zum Beispiel:

>>>float("23.333")
   23.333

Hinter den Kulissen ruft python die Methode objects __float__ auf, die eine Float-Darstellung des Parameters zurückgeben soll. Dies ist besonders leistungsstark, da Sie Ihre eigenen Typen (mithilfe von Klassen) mit einer __float__ -Methode definieren können, sodass sie mit float (myobject) in ein Float umgewandelt werden können.

5
qwerty12345

Python bietet diese große Flexibilität beim Parsen in einem Liner.

str = "545.2222"
print ("int: ", + int(float(a)))
print ("float: ", +(float(a)))
4
Harry_pb

Dies ist eine korrigierte Version von https://stackoverflow.com/a/33017514/5973334

Dadurch wird versucht, eine Zeichenfolge zu analysieren, und es wird entweder int oder float zurückgegeben, je nachdem, was die Zeichenfolge darstellt. Es können Parsing-Ausnahmen auftreten oder nerwartetes Verhalten .

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

Sie können str() verwenden, um eine Variable in einen String umzuwandeln, int(), um String-Ganzzahlen in Ganzzahlen umzuwandeln, und float(), um String-Gleitkommazahlen in Gleitkommazahlen umzuwandeln.

str_to_float = float("545.2222")
str_to_int = int("31")
2

Verwenden:

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

Dies ist der pythonischste Weg, den ich finden konnte.

1
SeasonalShot

Dies ist eine Funktion, die jeden object (nicht nur str) in int oder float konvertiert, je nachdem, ob der tatsächlich angegebene String sieht aus wie = int oder float. Wenn es sich um ein Objekt handelt, das über die Methoden __float und __int__ verfügt, wird standardmäßig __float__ verwendet.

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
0
Abhishek Bhatia

Verwenden:

>>> 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'>
0
amirt