Como analiso uma string em um float ou int?

2252

No Python, como posso analisar uma string numérica como "545.2222"seu valor flutuante correspondente 545.2222? Ou analise a string "31"em um número inteiro 31?

Eu só quero saber como analisar um float str para a floate (separadamente) um int str para um int.

Tristan Havelick
fonte
7
Como regra geral, se você tem um objeto em Python e deseja converter para esse tipo de objeto, chame type(my_object)-o. O resultado geralmente pode ser chamado como uma função para fazer a conversão. Por exemplo, type(100)resulta em int, então você pode ligar int(my_object)para tentar converter my_objectem um número inteiro. Isso nem sempre funciona, mas é um bom "primeiro palpite" ao codificar.
Robertlayton
1
int(x) if int(x) == float(x) else float(x)
tcpaiva 23/04

Respostas:

2627
>>> a = "545.2222"
>>> float(a)
545.22220000000004
>>> int(float(a))
545
Harley Holcombe
fonte
8
apenas querendo saber por que existe '04' no final? por que não simplesmente '00'? também minha versão atual do python não está tendo '04'.
Mangat Rai Modi
54
@MangatRaiModi Os números de ponto flutuante são inerentemente imperfeitos para representar decimais. Para obter mais informações, consulte stackoverflow.com/q/21895756/931277
dokkaebi
19
por que não simplesmente int(a)mas int(float(a))?
Idclev 463035818
24
int(a)dará um erro de que a string não é um número inteiro válido: ValueError: invalid literal for int() with base 10: '545.222'mas a conversão de um float para um int é uma conversão suportada.
David Parks
4
Você deve lidar com ValueErrorse você quiser ser seguro
Joe Bobson
515
def num(s):
    try:
        return int(s)
    except ValueError:
        return float(s)
Javier
fonte
81
a mistura implícita de flutuadores / entradas pode levar a erros sutis devido à possível perda de precisão ao trabalhar com flutuadores ou a resultados diferentes para o /operador em flutuadores / entradas. Dependendo do contexto, pode ser preferível retornar int ou float, não os dois.
JFS
14
@JFSebastian Você está completamente correto, mas há momentos em que você deseja que a entrada determine qual será. Deixar a entrada ditar qual deles pode funcionar bem com a digitação de patos.
precisa saber é o seguinte
4
Você pode aninhar outro trypara lançar uma exceção quando não for conversível para flutuar.
IBug
2
Falha coms = u'\u0000'
Matt Hancock
1
@iBug Good idea! Eu recomendo jogar ValueErroro correspondente except: P
marcelm 05/02/19
511

Método Python para verificar se uma string é flutuante:

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

Um nome mais longo e preciso para esta função pode ser: is_convertible_to_float(value)

O que é e não é um flutuador no Python pode surpreendê-lo:

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

Você acha que sabe o que são números? Você não é tão bom quanto pensa! Não é uma grande surpresa.

Não use esse código em softwares críticos para a vida!

Capturar grandes exceções dessa maneira, matar canários e engolir a exceção cria uma pequena chance de que um float válido como string retorne falso. A float(...)linha de código pode falhar por milhares de razões que nada têm a ver com o conteúdo da sequência. Mas se você estiver escrevendo um software essencial para a vida em uma linguagem de protótipo de digitação de pato como o Python, terá problemas muito maiores.

Eric Leschinski
fonte
1
Tão verdadeiro torna-se 1, que é que eu herdado de C ++ eu acho
FindOutIslamNow
6
Postei essa resposta em 2014. Esse UTF-8glifo para um chinês 4vem se transformando ao longo dos anos, dependendo de como os desenvolvedores do stackoverflow alteram seu esquema de codificação de caracteres na pilha de ferramentas da Microsoft. É uma curiosidade vê-lo fracassar ao longo dos anos, à medida que novos esquemas de conversão afirmam suas novas ideologias. Mas sim, qualquer UTF-8glifo para um numérico oriental oriental não é um flutuador Python. Bazinga.
Eric Leschinski
4
como isso pode ser tão votado, com uma exceção tão ampla?
E.Serra
Tudo com espaços intermediários não pode ser convertido, como "- 12.3"e"45 e6"
Simon
1
Esta cláusula exceto deve ser restrita aTypeError, ValueError
wim
131

Este é outro método que merece ser mencionado aqui, ast.literal_eval :

Isso pode ser usado para avaliar com segurança seqüências de caracteres contendo expressões Python de fontes não confiáveis, sem a necessidade de analisar os valores.

Ou seja, um 'eval' seguro

>>> import ast
>>> ast.literal_eval("545.2222")
545.2222
>>> ast.literal_eval("31")
31
wim
fonte
11
Esta não é uma boa solução para o problema. Funciona bem no Python 2, mas o seguinte acontece no Python 3: python >>> import ast >>> ast.literal_eval('1-800-555-1212') -2566 >>> Para esclarecer por que isso é um problema, se você deseja deixar os números de telefone em paz e não assumir que são expressões matemáticas, essa abordagem não é para você.
precisa saber é o seguinte
6
@ Royce3 Sim, esse é um bom argumento e os usuários devem tomar cuidado. O comportamento foi originalmente modificado para resolver alguns problemas com a análise de literais complexos. É sem dúvida um bug ast.literal_evale foi discutido aqui .
Wim
79
float(x) if '.' in x else int(x)
Dino Viehland
fonte
21
Nota: ter cuidado ao lidar com uma quantidade de dinheiro passado como cordas, como alguns países usam "" como separadores decimais
Ben G
127
@Emile: eu não chamaria "2e-3" de "caso extremo". Esta resposta está apenas quebrada.
jchl
14
@BenG NÃO manipule dinheiro como um flutuador. Isso está pedindo problemas. Use decimal por dinheiro! (Mas seu comentário sobre ',' ainda é válido e importante)
ToolmakerSteve
4
Não esqueça que "não é um número" (NaN) e +/- infinito também são valores flutuantes válidos. Então, float("nan")é um valor flutuante perfeitamente válido que a resposta acima não iria pegar em tudo
Ronny Andersson
2
Facilmente quebrável por um endereço IP - 192.168.0.1; ou"This is not a good approach. :)"
Todor Minakov
69

Localização e vírgulas

Você deve considerar a possibilidade de vírgulas na representação de string de um número, para casos como o float("545,545.2222")que lança uma exceção. Em vez disso, use métodos localepara converter as seqüências de caracteres em números e interpretar vírgulas corretamente. O locale.atofmétodo é convertido em um ponto flutuante em uma etapa depois que o código do idioma for definido para a convenção de número desejada.

Exemplo 1 - Convenções de números dos Estados Unidos

Nos Estados Unidos e no Reino Unido, as vírgulas podem ser usadas como separador de milhares. Neste exemplo com a localidade americana, a vírgula é tratada corretamente como um separador:

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

Exemplo 2 - Convenções de números europeus

Na maioria dos países do mundo , vírgulas são usadas para marcas decimais em vez de pontos. Neste exemplo com localidade francesa, a vírgula é tratada corretamente como uma marca decimal:

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

O método locale.atoitambém está disponível, mas o argumento deve ser um número inteiro.

Mark Chackerian
fonte
Essa parece ser uma solução ideal quando você sabe se um float ou int deve ser retornado, mas como você pode fazer com que isso retorne um int apenas se um int foi passado? Por exemplo, x = '1'; locale.atof(x)retorna 1.0quando eu realmente quero 1.
user5359531
Usando o método de Dino, eu acho que a resposta seria usar algo como isto:locale.atof(x) if locale.localeconv().get('decimal_point') in x else locale.atoi(x)
user5359531
Eu recomendaria utilizando o método de Javier acima (envolvimento locale.atoiem uma tentativa e usando locale.atofna exceção - é provavelmente mais legível.
Mark Chackerian
27

Se você não é avesso a módulos de terceiros, pode verificar o módulo fastnumbers . Ele fornece uma função chamada fast_real que faz exatamente o que esta pergunta está solicitando e faz mais rápido do que uma implementação em Python puro:

>>> 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
SethMMorton
fonte
24

Usuários codelogic e harley estão corretos, mas lembre-se de que, se você souber que a string é um número inteiro (por exemplo, 545), é possível chamar int ("545") sem que a primeira conversão seja lançada.

Se suas strings estiverem em uma lista, você também poderá usar a função map.

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

Só é bom se forem todos do mesmo tipo.

Peter Mortensen
fonte
21

No Python, como posso analisar uma sequência numérica como "545.2222" em seu valor flutuante correspondente, 542.2222? Ou analise a sequência "31" para um número inteiro, 31? Eu só quero saber como analisar uma seqüência de caracteres flutuante em um ponto flutuante e (separadamente) uma seqüência de caracteres int para um int.

É bom que você peça para fazer isso separadamente. Se você as estiver misturando, pode estar se preparando para problemas mais tarde. A resposta simples é:

"545.2222" flutuar:

>>> float("545.2222")
545.2222

"31" para um número inteiro:

>>> int("31")
31

Outras conversões, ints de e para strings e literais:

Conversões de várias bases, e você deve conhecer a base com antecedência (10 é o padrão). Observe que você pode prefixá-los com o que o Python espera para seus literais (veja abaixo) ou remover o prefixo:

>>> 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 você não conhece a base com antecedência, mas sabe que eles terão o prefixo correto, o Python pode inferir isso para você se você passar 0como base:

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

Literais não decimais (ou seja, número inteiro) de outras bases

Se sua motivação é ter seu próprio código claramente representando valores específicos codificados, no entanto, talvez você não precise converter a partir das bases - você pode deixar o Python fazer isso por você automaticamente com a sintaxe correta.

Você pode usar os prefixos apropos para obter a conversão automática em números inteiros com os seguintes literais . Estes são válidos para Python 2 e 3:

Prefixo binário 0b

>>> 0b11111
31

Octal, prefixo 0o

>>> 0o37
31

Hexadecimal, prefixo 0x

>>> 0x1f
31

Isso pode ser útil ao descrever sinalizadores binários, permissões de arquivo no código ou valores hexadecimais para cores - por exemplo, observe sem aspas:

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

Tornando octais ambíguos do Python 2 compatíveis com o Python 3

Se você vir um número inteiro que começa com 0, no Python 2, essa é a sintaxe octal (obsoleta).

>>> 037
31

É ruim porque parece que o valor deveria ser 37. Portanto, no Python 3, agora gera um SyntaxError:

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

Converta seus octais do Python 2 em octais que funcionam em 2 e 3 com o 0oprefixo:

>>> 0o37
31
Aaron Hall
fonte
20

A questão parece um pouco antiga. Mas deixe-me sugerir uma função, parseStr, que faz algo semelhante, ou seja, retorna inteiro ou float e, se uma determinada string ASCII não puder ser convertida em nenhum deles, ela a retornará intocada. O código do curso pode ser ajustado para fazer apenas o que você deseja:

   >>> 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'
krzym
fonte
8
1e3é um número em python, mas uma string de acordo com o seu código.
amigos estão dizendo
16

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

codelogic
fonte
1
Isso fornecerá um objeto float se sua string for "0" ou "0,0", em vez do int que ela fornece para outros números válidos.
18711 Brian
14

Eu uso essa função para isso

import ast

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

Ele converterá a string em seu tipo

value = parse_str('1')  # Returns Integer
value = parse_str('1.5')  # Returns Float
Shameem
fonte
Observe que parse_str(' 1')(com um espaço) retornará None, não 1.
Musiphil 02/05/19
13

O analisador YAML pode ajudá-lo a descobrir que tipo de dados sua string é. Use yaml.load()e, em seguida, você pode usar type(result)para testar o 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'>
Rafe
fonte
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
Totoro
fonte
1
Por que você aumentaria em sua exceptseção se não está fazendo nada lá? float () aumentaria para você.
Greg0ry
1
você está certo, acho que copiei e colei de uma funcionalidade que estava gerando uma exceção específica. irá editar. obrigada
Totoro
1
Isso tentará analisar uma string e retornar intou floatdependendo do que a string representa. Pode surgir analisando exceções ou [tem algum comportamento inesperado] [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')
Jerry T
fonte
6

Você precisa levar em consideração o arredondamento para fazer isso corretamente.

Ou seja, int (5.1) => 5 int (5.6) => 5 - errado, deve ser 6, então fazemos int (5.6 + 0.5) => 6

def convert(n):
    try:
        return int(n)
    except ValueError:
        return float(n + 0.5)
usuario
fonte
4
Bom ponto. Isso causa inflação, no entanto, o Python 3 e outras linguagens modernas usam o arredondamento de banqueiros.
Cees Timmerman
2
Esta resposta está errada (como originalmente escrita). Confunde os dois casos de inte float. E isso dará uma exceção, quando nfor uma string, conforme o OP desejado. Talvez você quis dizer: Quando um intresultado é desejado, rounddeve ser feito APÓS a conversão para flutuar. Se a função SEMPRE retornar um int, você não precisará da parte exceto - todo o corpo da função pode ser int(round(float(input))). Se a função retornar um int, se possível, caso contrário um float, a solução original de javier está correta!
Home
5

Estou surpreso que ninguém tenha mencionado regex porque às vezes a string deve ser preparada e normalizada antes da conversão para o número

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

uso:

parseNumber('13,345')
> 13345.0

parseNumber('- 123 000')
> -123000.0

parseNumber('99999\n')
> 99999.0

e, a propósito, algo para verificar se você tem um número:

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

Para digitar em python, use as funções de construtor do tipo, passando a string (ou qualquer valor que você esteja tentando converter) como parâmetro.

Por exemplo:

>>>float("23.333")
   23.333

Nos bastidores, python está chamando o __float__método de objetos , que deve retornar uma representação flutuante do parâmetro. Isso é especialmente poderoso, pois você pode definir seus próprios tipos (usando classes) com um __float__método para que ele possa ser convertido em um float usando float (myobject).

kCODINGeroo
fonte
3

Esta é uma versão corrigida de https://stackoverflow.com/a/33017514/5973334

Isso tentará analisar uma string e retornar intou floatdependendo do que a string representa. Pode surgir a análise de exceções ou ter algum comportamento inesperado .

  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
Kuzeko
fonte
2

Passe sua string para esta função:

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)

Ele retornará int, float ou string, dependendo do que foi passado.

string que é um int

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

string que é uma bóia

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

string que é uma string

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

corda que parece um flutuador

print(type(string_to_number("hel.lo")))
<class 'str'>
Cibernético
fonte
1

Usar:

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

Esta é a maneira mais pitônica que eu poderia inventar.

SeasonalShot
fonte
O gerador para após a primeira interpretação de float. O bloco trycatchprovavelmente deve estar dentro do forloop.
Musiphil 02/05/19
1

Lida com hex, octal, binário, decimal e float

Esta solução irá lidar com todas as convenções de string para números (tudo o que eu sei).

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)

Esta saída do caso de teste ilustra o que estou falando.

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

Aqui está o teste:

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)
shrewmouse
fonte
0

Usar:

>>> 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'>
Peter Mortensen
fonte
0

Esta é uma função que converterá qualquer object(não apenas str) para intou float, com base em se a cadeia de caracteres real fornecida for parecida com int ou float. Além disso, se é um objeto que possui métodos __floate ambos __int__, o padrão é usar__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
Abhishek Bhatia
fonte
-1

Usando métodos int e float, podemos converter uma string em número inteiro e floats.

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

y='67'
print(int(y))
Shekku Joseph
fonte
Esta resposta não adiciona nada de novo. Veja, por exemplo, esta resposta que fornece as mesmas informações e muito mais.
Georgy
-3

eval()é uma solução muito boa para esta pergunta. Ele não precisa verificar se o número é int ou float, apenas fornece o equivalente correspondente. Se outros métodos forem necessários, tente

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

try-except também pode ser usado como alternativa. Tente converter a string em int dentro do bloco try. Se a string for um valor flutuante, gerará um erro que será capturado no bloco de exceção, como este

try:
    print(int(string))
except:
    print(float(string))
Swati Srivastava
fonte
-10

Aqui está outra interpretação da sua pergunta (dica: é vaga). É possível que você esteja procurando algo assim:

def parseIntOrFloat( aString ):
    return eval( aString )

Funciona assim ...

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

Teoricamente, há uma vulnerabilidade de injeção. A cadeia poderia, por exemplo, ser "import os; os.abort()". Sem qualquer conhecimento de onde a corda vem, a possibilidade é especulação teórica. Como a pergunta é vaga, não está claro se essa vulnerabilidade existe ou não.

S.Lott
fonte
7
Mesmo que sua entrada seja 100% segura, eval()é mais de três vezes mais lenta que try: int(s) except: float(s).
fácil fazer o
1
Bem, evalé uma prática ruim (você deve saber porque você tem 310k reputação)
U10-Forward