Come posso analizzare una stringa in un float o int?


2252

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.


7
Come regola generale, se hai un oggetto in Python e desideri convertirlo in quel tipo di oggetto, chiamalo type(my_object). Il risultato può di solito essere chiamato come una funzione per fare la conversione. Ad esempio, type(100)risulta int, quindi puoi chiamare int(my_object)per provare a convertire my_objectin un numero intero. Questo non sempre funziona, ma è una buona "prima ipotesi" durante la programmazione.
robertlayton,

1
int(x) if int(x) == float(x) else float(x)
tcpaiva,

Risposte:


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

8
mi chiedo solo perché alla fine ci sia '04'? perché non semplicemente "00"? anche la mia versione attuale di Python non ha "04".
Mangat Rai Modi,

54
@MangatRaiModi I numeri in virgola mobile sono intrinsecamente imperfetti per rappresentare i decimali. Per ulteriori informazioni, consultare stackoverflow.com/q/21895756/931277
dokkaebi,

19
perché non semplicemente int(a)ma int(float(a))?
idclev 463035818,

24
int(a)darà un errore che la stringa non è un numero intero valido: ValueError: invalid literal for int() with base 10: '545.222'ma la conversione da un float a un int è una conversione supportata.
David Parks,

4
Dovresti gestirlo ValueErrorse vuoi essere al sicuro
Joe Bobson,

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

81
la miscelazione implicita di float / ints può portare a lievi bug dovuti a possibili perdite di precisione quando si lavora con float o a risultati diversi per l' /operatore su float / ints. A seconda del contesto, potrebbe essere preferibile restituire int o float, non entrambi.
jfs,

14
@JFSebastian Hai perfettamente ragione, ma ci sono momenti in cui vuoi che l'input determini quale sarà. Lasciare che l'input imponga quale si può lavorare bene con la tipizzazione delle anatre.
TimothyAwiseman

4
Puoi nidificarne un altro tryper generare un'eccezione quando non è convertibile in float.
iBug

2
Non riesce cons = u'\u0000'
Matt Hancock il

1
@iBug Buona idea! Consiglio di ValueErrorexcept
inserire

511

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.


1
Così vero diventa 1, cioè ho ereditato dal C ++ credo
FindOutIslamNow,

6
Ho pubblicato questa risposta nel 2014. Quel UTF-8glifo per un cinese si 4è trasformato nel corso degli anni a seconda di come gli sviluppatori di stackoverflow cambiano il loro schema di codifica dei caratteri sul loro toolstack di Microsoft. È una curiosità vederlo cadere negli anni mentre nuovi schemi di conversione affermano le loro nuove ideologie. Ma sì, qualsiasi UTF-8glifo per un numerico orientale orientale non è un galleggiante Python. Bazinga.
Eric Leschinski il

4
come può essere così votato, con un'eccezione così ampia?
E.Serra,

Tutto con spazi nel mezzo non può essere convertito, come "- 12.3"e"45 e6"
Simon

1
Questa clausola esclusa dovrebbe essere limitata aTypeError, ValueError
wim

131

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

11
questa non è una buona soluzione al problema. Funziona bene in Python 2, ma in Python 3 succede quanto segue: python >>> import ast >>> ast.literal_eval('1-800-555-1212') -2566 >>> Per chiarire perché questo è un problema, se vuoi che lasci i numeri di telefono da solo e non supponga che siano espressioni matematiche, allora questo approccio non fa per te.
royce3,

6
@ royce3 Sì, è un buon punto e gli utenti dovrebbero stare attenti. Il comportamento è stato originariamente modificato al fine di affrontare alcuni problemi con l'analisi di letterali complessi. Probabilmente è un bug ast.literal_evaled è stato discusso qui .
mercoledì

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

21
Nota: fai attenzione quando gestisci l'importo del denaro passato come stringhe, poiché alcuni paesi usano "," come separatori decimali
Ben G

127
@Emile: non definirei "2e-3" un "caso estremo". Questa risposta è appena rotta.
jchl

14
@BenG NON ​​manipolare il denaro come un galleggiante. Chiede problemi. Usa il decimale per soldi! (Ma il tuo commento su "," è ancora valido e importante)
ToolmakerSteve

4
Non dimenticare che "non un numero" (NaN) e +/- infinito sono anche valori float validi. Quindi float("nan")è un valore float perfettamente valido che la risposta di cui sopra non catturerebbe affatto
Ronny Andersson,

2
Facilmente separabile da un indirizzo IP - 192.168.0.1; oppure"This is not a good approach. :)"
Todor Minakov il

69

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.


Questa sembra una soluzione ideale quando sai se un float o un int devono essere restituiti, ma come puoi ottenerlo per restituire un int solo se un int è stato passato? Ad esempio, x = '1'; locale.atof(x)ritorna 1.0quando voglio davvero 1.
user5359531

Usando il metodo di Dino, immagino che la risposta sarebbe usare qualcosa del genere:locale.atof(x) if locale.localeconv().get('decimal_point') in x else locale.atoi(x)
user5359531

Consiglierei di usare il metodo Javier sopra (racchiudendolo locale.atoiin una prova e usando locale.atofin eccezione - è probabilmente più leggibile.
Mark Chackerian

27

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

24

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.


21

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

20

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'

8
1e3è un numero in Python, ma una stringa in base al tuo codice.
Cees Timmerman,

16

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


1
Questo ti darà un oggetto float se la tua stringa risulta essere "0" o "0.0", piuttosto che l'int che fornisce per altri numeri validi.
Brian,

14

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

Si noti che parse_str(' 1')(con uno spazio) tornerà None, no 1.
musiphil

13

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

11
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

1
Perché dovresti rilanciare nella tua exceptsezione se non stai facendo nulla lì? float () rilancerebbe per te.
Greg0ry

1
hai ragione immagino di aver copiato e incollato da una funzionalità che stavo sollevando una particolare eccezione. modificherà. grazie
Totoro,

1
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] [1].
Kuzeko,

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

6

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

4
Buon punto. Ciò causa inflazione, tuttavia, quindi Python 3 e altre lingue moderne usano l'arrotondamento del banchiere.
Cees Timmerman,

2
Questa risposta è errata (come originariamente scritto). Confonde i due casi di inte float. E darà un'eccezione, quando nè una stringa, come desiderato da OP. Forse intendevi: quandoint si desidera un risultato, rounddeve essere eseguito DOPO la conversione in float. Se la funzione dovrebbe SEMPRE restituire un int, allora non è necessaria la parte tranne - l'intero corpo della funzione può essere int(round(float(input))). Se la funzione deve restituire un int, se possibile, altrimenti un float, la soluzione originale di javier è corretta!
ToolmakerSteve

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

5

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


3

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

2

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

1

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.


Il generatore si arresta dopo la prima interpretazione di float. Il try... catchblocco dovrebbe probabilmente essere all'interno del forloop.
musiphil

1

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)

0

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

0

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

-1

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

Questa risposta non aggiunge nulla di nuovo. Vedi, ad esempio, questa risposta che fornisce le stesse informazioni e altro ancora.
Georgy,

-3

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

-10

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.


7
Anche se il suo input è sicuro al 100%, eval()è oltre 3 volte più lento di try: int(s) except: float(s).
Cees Timmerman,

1
Bene, evalè una cattiva pratica (devi sapere perché hai una reputazione di 310k)
U10-Forward
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.