Як в Python я можу проаналізувати числовий рядок, як "545.2222"його відповідне значення float 545.2222,? Або проаналізувати рядок "31"на ціле число 31,?

Я просто хочу знати, як проаналізувати float str до a floatта (окремо) int str to an int.

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

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

Метод Python, щоб перевірити, чи є рядок float:

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

Більш довга і точна назва цієї функції може бути: is_convertible_to_float(value)

Що є, а не поплавок у Python, може вас здивувати:

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

Ви думаєте, що знаєте, що таке цифри? Ти не такий хороший, як ти думаєш! Не великий сюрприз.

Не використовуйте цей код на життєво важливому програмному забезпеченні!

Таким чином, уловлюючи широкі винятки, вбиваючи канарки та гуляючи виняток, створюється невелика ймовірність того, що дійсний float як string повернеться хибним. float(...)Рядок коду може не вдалося уздовж будь-яких тисячі причин , які не мають нічого спільного з вмістом рядка. Але якщо ви пишете життєво важливе програмне забезпечення на мові прототипу качки, як Python, то у вас є набагато більші проблеми.

Це ще один метод, який заслуговує на згадку тут, ast.literal_eval :

Це можна використовувати для безпечного оцінювання рядків, що містять вирази Python з ненадійних джерел, без необхідності аналізувати самі значення.

Тобто, безпечний 'eval'

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

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

Локалізація та коми

Вам слід врахувати можливість коми в рядковому поданні числа для випадків, float("545,545.2222")які призводять до винятку. Натомість скористайтеся методами, localeщоб перетворити рядки в числа та правильно інтерпретувати коми. У locale.atofметоді перетворює до поплавця в одному кроці раз локал було встановлено для необхідного номера конвенції.

Приклад 1 - числові конвенції США

У Сполучених Штатах та Великобританії коси можна використовувати як роздільник тисяч. У цьому прикладі з американським локалом кома обробляється належним чином як роздільник:

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

Приклад 2 - Європейські конвенції про число

У більшості країн світу коми використовуються для десяткових знаків замість крапок. У цьому прикладі з французькою мовою кома правильно обробляється як десятковий знак:

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

Метод locale.atoiтакож доступний, але аргумент повинен бути цілим числом.

Якщо ви не проти сторонніх модулів, ви можете перевірити модуль fastnumbers . Він надає функцію під назвою fast_real, яка робить саме те, про що задається це питання, і робить це швидше, ніж реалізація чистого 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

Користувачі codelogic і Харлі є правильними, але майте на увазі , якщо ви знаєте , що рядок являє собою ціле число (наприклад, 545), можна назвати INT ( «545») без першого лиття з поплавком.

Якщо ваші рядки є у списку, ви також можете використовувати функцію карти.

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

Це добре лише, якщо вони всі одного типу.

Як у Python, як я можу проаналізувати числовий рядок типу "545.2222" на відповідне значення з плаваючою здатністю 542.2222? Або проаналізуйте рядок "31" на ціле число, 31? Мені просто хочеться знати, як проаналізувати поплавковий рядок до float та (окремо) рядок int до int.

Добре, що ви просите зробити це окремо. Якщо ви їх змішуєте, ви, можливо, пізніше налаштуєте себе на проблеми. Проста відповідь:

"545.2222" плавати:

>>> float("545.2222")
545.2222

"31" до цілого числа:

>>> int("31")
31

Інші перетворення, вставки до та з рядків і літералів:

Перетворення з різних баз, і ви повинні заздалегідь знати базу (за замовчуванням 10). Зауважте, ви можете додати їх до того, що очікує Python для своїх літералів (див. Нижче) або видалити префікс:

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

Якщо ви не знаєте бази заздалегідь, але ви знаєте, що вони матимуть правильний префікс, Python може зробити це для вас, якщо ви перейдете 0як базу:

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

Недесятичні (тобто цілі) літерали з інших баз

Якщо ваша мотивація полягає в тому, щоб ваш власний код чітко відображав жорстко кодовані конкретні значення, однак, вам може не знадобитися перетворення з баз - ви можете дозволити Python робити це за вас автоматично з правильним синтаксисом.

Ви можете використовувати префікси apropos для автоматичного перетворення в цілі числа з наступними буквами . Вони дійсні для Python 2 та 3:

Двійковий, префікс 0b

>>> 0b11111
31

Октал, приставка 0o

>>> 0o37
31

Шістнадцятковий, префікс 0x

>>> 0x1f
31

Це може бути корисно при описі двійкових прапорів, дозволів на файли в коді або шістнадцяткових значень для кольорів - наприклад, відзначайте відсутні лапки:

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

Зробити неоднозначні вісімки Python 2 сумісними з Python 3

Якщо ви бачите ціле число, яке починається з 0, у Python 2 це (застарілий) восьмеричний синтаксис.

>>> 037
31

Це погано, бо, схоже, значення має бути 37. Отже, в Python 3 тепер він піднімає SyntaxError:

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

Перетворіть ваші восьмери вісімки Python 2 у вісімки, які працюють як у 2, так і у 3 з 0oпрефіксом:

>>> 0o37
31

Питання здається трохи застарілим. Але дозвольте мені запропонувати функцію parseStr, яка робить щось подібне, тобто повертає ціле чи плаваюче, і якщо заданий рядок ASCII не може бути перетворений в жоден із них, він повертає його недоторканим. Код, звичайно, може бути скоригований, щоб робити тільки те, що ви хочете:

   >>> 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") і int(float("545.2222"))

Для цього я використовую цю функцію

import ast

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

Він перетворить рядок у свій тип

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

YAML аналізатор може допомогти вам зрозуміти, що тип даних ваша рядок. Використовуйте yaml.load(), а потім ви можете використовувати type(result)для тестування на тип:

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

Для цього потрібно врахувати округлення.

Тобто int (5.1) => 5 int (5.6) => 5 - неправильно, має бути 6, тому ми робимо int (5.6 + 0.5) => 6

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

Я здивований, що ніхто не згадав про регулярний вираз, тому що іноді рядки повинні бути підготовлені та нормалізовані перед тим, як робити його на номер

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

використання:

parseNumber('13,345')
> 13345.0

parseNumber('- 123 000')
> -123000.0

parseNumber('99999\n')
> 99999.0

і до речі, щось для підтвердження наявності у вас номера:

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

Для набору в python використовуйте функції конструктора типу, передаючи рядок (або будь-яке значення, яке ви намагаєтеся надати) як параметр.

Наприклад:

>>>float("23.333")
   23.333

За лаштунками python викликає __float__метод об'єктів , який повинен повернути плаваюче представлення параметра. Це особливо потужно, оскільки ви можете визначити власні типи (за допомогою класів) __float__методом, щоб його можна було перекинути на флоат за допомогою float (myobject).

Це виправлена версія від https://stackoverflow.com/a/33017514/5973334

Це спробує розібрати рядок і повернути або, intабо floatзалежно від того, що являє собою рядок. Це може призвести до розбору винятків або до неочікуваної поведінки .

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

Він поверне int, float або string у залежності від того, що було передано.

рядок, що є int

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

струна, яка є поплавком

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

рядок, що є рядком

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

струна, що схожа на поплавок

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

Використання:

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

Це найбільш піфонічний спосіб, який я міг придумати.

Обробляє шістнадцяткові, восьмеричні, двійкові, десяткові та поплавкові

Це рішення обробляє всі строкові конвенції для чисел (все, що я знаю про).

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)

Цей вихідний тест ілюструє те, про що я говорю.

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

Ось тест:

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)

Використання:

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

Це функція, яка перетворить будь-яку object(не просто str) на intабо floatна основі, якщо фактичний доданий рядок виглядає як int або float. Далі, якщо це об'єкт, який має і те, __floatі __int__методи, він за замовчуванням використовує__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

Використовуючи методи int та float, ми можемо перетворити рядок у ціле число та floats.

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

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

eval()є дуже хорошим рішенням цього питання. Тут не потрібно перевіряти, чи є число int чи float, воно просто дає відповідний еквівалент. Якщо потрібні інші методи, спробуйте

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

спроба виключення також може бути використана в якості альтернативи. Спробуйте перетворити рядок в int всередині блоку спробу. Якщо рядок буде знаком float, він видасть помилку, яка буде зафіксована у винятковому блоці, як цей

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

Ось ще одне тлумачення вашого запитання (підказка: це невиразно). Можливо, ви шукаєте щось подібне:

def parseIntOrFloat( aString ):
    return eval( aString )

Це працює так ...

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

Теоретично існує вразливість до ін'єкцій. Рядок може, наприклад, бути "import os; os.abort()". Однак без будь-якого передумови, звідки береться рядок, можливі теоретичні спекуляції. Оскільки питання неясне, зовсім не зрозуміло, існує ця вразливість насправді чи ні.