In Python, come posso analizzare una stringa numerica come "545.2222"al suo valore float corrispondente, 545.2222? O analizzare la stringa "31"in un numero intero 31,?

Voglio solo sapere come analizzare un float str in a floate (separatamente) un int str in un int.

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

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

Metodo Python per verificare se una stringa è un float:

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

Un nome più lungo e più preciso per questa funzione potrebbe essere: is_convertible_to_float(value)

Ciò che è e non è un float in Python potrebbe sorprenderti:

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

Pensi di sapere quali sono i numeri? Non sei bravo come pensi! Non è una grande sorpresa.

Non utilizzare questo codice su software critico per la vita!

Catturare ampie eccezioni in questo modo, uccidere i canarini e divorare l'eccezione crea una piccola possibilità che un float valido come stringa restituisca false. La float(...)riga di codice può non riuscire per uno qualsiasi dei mille motivi che non hanno nulla a che fare con il contenuto della stringa. Ma se stai scrivendo un software critico per la vita in un linguaggio prototipo tipografico come Python, hai problemi molto più grandi.

Questo è un altro metodo che merita di essere menzionato qui, ast.literal_eval :

Questo può essere usato per valutare in sicurezza stringhe contenenti espressioni Python da fonti non attendibili senza la necessità di analizzare i valori da soli.

Cioè, un 'eval' sicuro

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

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

Localizzazione e virgole

Si dovrebbe considerare la possibilità di virgole nella rappresentazione di stringa di un numero, per casi come quelli float("545,545.2222")che generano un'eccezione. Utilizzare invece i metodi in localeper convertire le stringhe in numeri e interpretare le virgole correttamente. Il locale.atofmetodo converte in un float in un solo passaggio dopo aver impostato la locale per la convenzione numerica desiderata.

Esempio 1 - Convenzioni numeriche degli Stati Uniti

Negli Stati Uniti e nel Regno Unito, le virgole possono essere utilizzate come separatore delle migliaia. In questo esempio con le impostazioni internazionali americane, la virgola viene gestita correttamente come separatore:

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

Esempio 2 - Convenzioni numeriche europee

Nella maggior parte dei paesi del mondo , le virgole vengono utilizzate per i segni decimali anziché i punti. In questo esempio con le impostazioni internazionali francesi, la virgola viene gestita correttamente come segno decimale:

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

Il metodo locale.atoiè anche disponibile, ma l'argomento dovrebbe essere un numero intero.

Se non sei contrario ai moduli di terze parti, puoi dare un'occhiata al modulo fastnumbers . Fornisce una funzione chiamata fast_real che fa esattamente quello che questa domanda sta chiedendo e lo fa più velocemente di un'implementazione pure-Python:

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

Utenti codelogic e harley sono corretti, ma tieni presente che se sai che la stringa è un numero intero (ad esempio, 545) puoi chiamare int ("545") senza prima lanciare il float.

Se le stringhe sono in un elenco, è possibile utilizzare anche la funzione mappa.

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

Va bene solo se sono tutti dello stesso tipo.

In Python, come posso analizzare una stringa numerica come "545.2222" al suo corrispondente valore float, 542.2222? O analizzare la stringa "31" in un numero intero, 31? Voglio solo sapere come analizzare una stringa float in un float e (separatamente) una stringa int in un int.

È bene che tu chieda di farlo separatamente. Se li stai mescolando, potresti essere pronto per problemi in seguito. La semplice risposta è:

"545.2222" galleggiare:

>>> float("545.2222")
545.2222

"31" a un numero intero:

>>> int("31")
31

Altre conversioni, ints da e verso stringhe e valori letterali:

Conversioni da varie basi e dovresti conoscere la base in anticipo (10 è l'impostazione predefinita). Nota che puoi prefissarli con ciò che Python si aspetta per i suoi valori letterali (vedi sotto) o rimuovere il prefisso:

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

Se non conosci la base in anticipo, ma sai che avranno il prefisso corretto, Python può dedurlo per te se passi 0come base:

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

Letterali non decimali (cioè interi) da altre basi

Se la tua motivazione è che il tuo codice rappresenti chiaramente valori specifici codificati, tuttavia, potrebbe non essere necessario convertire dalle basi: puoi lasciare che Python lo faccia automaticamente per te con la sintassi corretta.

È possibile utilizzare i prefissi apropos per ottenere la conversione automatica in numeri interi con i seguenti letterali . Questi sono validi per Python 2 e 3:

Binario, prefisso 0b

>>> 0b11111
31

Ottale, prefisso 0o

>>> 0o37
31

Esadecimale, prefisso 0x

>>> 0x1f
31

Ciò può essere utile quando si descrivono flag binari, autorizzazioni di file nel codice o valori esadecimali per i colori, ad esempio non notare virgolette:

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

Rendere ambigui gli ottali Python 2 compatibili con Python 3

Se vedi un numero intero che inizia con uno 0, in Python 2, questa è sintassi ottale (deprecata).

>>> 037
31

È un male perché sembra che il valore dovrebbe essere 37. Quindi in Python 3 ora genera un SyntaxError:

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

Converti i tuoi ottali Python 2 in ottali che funzionano sia in 2 che in 3 con il 0oprefisso:

>>> 0o37
31

La domanda sembra un po 'vecchia. Ma lasciatemi suggerire una funzione, parseStr, che rende qualcosa di simile, ovvero restituisce numeri interi o float e se una determinata stringa ASCII non può essere convertita in nessuna di esse, la restituisce intatta. Il codice ovviamente potrebbe essere modificato per fare solo quello che vuoi:

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

float("545.2222") e int(float("545.2222"))

Uso questa funzione per questo

import ast

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

Converte la stringa nel suo tipo

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

Il parser YAML può aiutarti a capire quale tipo di dati è la tua stringa. Utilizzare yaml.load(), quindi è possibile utilizzare type(result)per verificare il tipo:

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

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

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

È necessario tenere conto dell'arrotondamento per farlo correttamente.

Cioè int (5.1) => 5 int (5.6) => 5 - sbagliato, dovrebbe essere 6, quindi facciamo int (5.6 + 0.5) => 6

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

Sono sorpreso che nessuno abbia menzionato regex perché a volte la stringa deve essere preparata e normalizzata prima di lanciare il numero

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

utilizzo:

parseNumber('13,345')
> 13345.0

parseNumber('- 123 000')
> -123000.0

parseNumber('99999\n')
> 99999.0

e comunque, qualcosa per verificare che tu abbia un numero:

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

Per digitare in python usa le funzioni di costruzione del tipo, passando la stringa (o qualunque valore tu stia provando a trasmettere) come parametro.

Per esempio:

>>>float("23.333")
   23.333

Dietro le quinte, Python sta chiamando il __float__metodo object , che dovrebbe restituire una rappresentazione float del parametro. Questo è particolarmente potente, in quanto puoi definire i tuoi tipi (usando le classi) con un __float__metodo in modo che possa essere lanciato in un float usando float (myobject).

Questa è una versione corretta di https://stackoverflow.com/a/33017514/5973334

Ciò tenterà di analizzare una stringa e restituire uno into floatsecondo ciò che rappresenta la stringa. Potrebbe generare eccezioni di analisi o avere un comportamento imprevisto .

  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

Passa la stringa a questa funzione:

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

Restituirà int, float o stringa a seconda di ciò che è stato passato.

stringa che è un int

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

stringa che è un float

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

stringa che è una stringa

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

stringa che sembra un galleggiante

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

Uso:

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

Questo è il modo più Pythonic che potrei trovare.

Gestisce hex, ottale, binario, decimale e float

Questa soluzione gestirà tutte le convenzioni di stringa per i numeri (tutto quello che so).

def to_number(n):
    ''' Convert any number representation to a number 
    This covers: float, decimal, hex, and octal numbers.
    '''

    try:
        return int(str(n), 0)
    except:
        try:
            # python 3 doesn't accept "010" as a valid octal.  You must use the
            # '0o' prefix
            return int('0o' + n, 0)
        except:
            return float(n)

L'output di questo caso di prova illustra ciò di cui sto parlando.

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

Ecco il test:

class test_to_number(unittest.TestCase):

    def test_hex(self):
        # All of the following should be converted to an integer
        #
        values = [

                 #          HEX
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                (0xDEADBEEF  , 3735928559), # Hex
                ("0xFEEDFACE", 4277009102), # Hex
                ("0x0"       ,          0), # Hex

                 #        Decimals
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                (100         ,        100), # Decimal
                ("42"        ,         42), # Decimal
            ]



        values += [
                 #        Octals
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                (0o10        ,          8), # Octal
                ("0o20"      ,         16), # Octal
                ("020"       ,         16), # Octal
            ]


        values += [
                 #        Floats
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                (3.14        ,       3.14), # Float
                ("2.72"      ,       2.72), # Float
                ("1e3"       ,       1000), # Float
                (1e-3        ,      0.001), # Float
            ]

        values += [
                 #        All ints
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                ("0xA"       ,         10), 
                ("012"       ,         10), 
                ("0o12"      ,         10), 
                ("0b01010"   ,         10), 
                ("10"        ,         10), 
                ("10.0"      ,         10), 
                ("1e1"       ,         10), 
            ]

        for _input, expected in values:
            value = to_number(_input)

            if isinstance(_input, str):
                cmd = 'to_number("{}")'.format(_input)
            else:
                cmd = 'to_number({})'.format(_input)

            print("{:23} = {:10} == {:10}".format(cmd, value, expected))
            self.assertEqual(value, expected)

Uso:

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

Questa è una funzione che converte qualsiasi object(non solo str) in into float, in base al fatto che la stringa effettivamente fornita sia simile int o float. Inoltre, se si tratta di un oggetto con entrambi __floate __int__metodi, viene utilizzato per impostazione predefinita__float__

def conv_to_num(x, num_type='asis'):
    '''Converts an object to a number if possible.
    num_type: int, float, 'asis'
    Defaults to floating point in case of ambiguity.
    '''
    import numbers

    is_num, is_str, is_other = [False]*3

    if isinstance(x, numbers.Number):
        is_num = True
    elif isinstance(x, str):
        is_str = True

    is_other = not any([is_num, is_str])

    if is_num:
        res = x
    elif is_str:
        is_float, is_int, is_char = [False]*3
        try:
            res = float(x)
            if '.' in x:
                is_float = True
            else:
                is_int = True
        except ValueError:
            res = x
            is_char = True

    else:
        if num_type == 'asis':
            funcs = [int, float]
        else:
            funcs = [num_type]

        for func in funcs:
            try:
                res = func(x)
                break
            except TypeError:
                continue
        else:
            res = x

Usando i metodi int e float possiamo convertire una stringa in numero intero e float.

s="45.8"
print(float(s))

y='67'
print(int(y))

eval()è un'ottima soluzione a questa domanda. Non ha bisogno di verificare se il numero è int o float, fornisce solo l'equivalente corrispondente. Se sono richiesti altri metodi, provare

if '.' in string:
    print(float(string))
else:
    print(int(string))

In alternativa è possibile utilizzare anche try -cept. Prova a convertire la stringa in int all'interno del blocco try. Se la stringa sarà un valore float, genererà un errore che verrà rilevato nel blocco di eccezione, in questo modo

try:
    print(int(string))
except:
    print(float(string))

Ecco un'altra interpretazione della tua domanda (suggerimento: è vaga). È possibile che tu stia cercando qualcosa del genere:

def parseIntOrFloat( aString ):
    return eval( aString )

Funziona così ...

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

Teoricamente, c'è una vulnerabilità all'iniezione. La stringa potrebbe, ad esempio, essere "import os; os.abort()". Senza alcun background su da dove provenga la stringa, tuttavia, la possibilità è la speculazione teorica. Poiché la domanda è vaga, non è affatto chiaro se questa vulnerabilità esiste o meno.