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.

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

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

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.

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

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

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.

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

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.

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

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'

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

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

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

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

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)

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

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

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

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

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.

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)

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

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

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

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

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.