Dengan Python, bagaimana saya bisa mengurai string numerik seperti "545.2222"nilai float yang sesuai 545.2222,? Atau parsing string "31"ke integer 31,?

Saya hanya ingin tahu cara mengurai float str ke float, dan (secara terpisah) int str ke int.

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

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

Metode Python untuk memeriksa apakah string adalah float:

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

Nama yang lebih panjang dan lebih akurat untuk fungsi ini adalah: is_convertible_to_float(value)

Apa itu, dan bukan float di Python mungkin mengejutkan Anda:

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

Anda pikir Anda tahu nomor apa itu? Anda tidak sebagus yang Anda kira! Bukan kejutan besar.

Jangan gunakan kode ini pada perangkat lunak yang kritis!

Menangkap pengecualian luas dengan cara ini, membunuh kenari dan melahap pengecualian menciptakan peluang kecil bahwa pelampung yang valid sebagai string akan kembali palsu. The float(...)baris kode dapat gagal untuk setiap seribu alasan yang tidak ada hubungannya dengan isi string. Tetapi jika Anda menulis perangkat lunak penting dalam bahasa prototipe mengetik bebek seperti Python, maka Anda memiliki masalah yang jauh lebih besar.

Ini adalah metode lain yang layak disebutkan di sini, ast.literal_eval :

Ini dapat digunakan untuk mengevaluasi string yang berisi ekspresi Python dari sumber yang tidak dipercaya dengan aman tanpa harus menguraikan nilai-nilai itu sendiri.

Artinya, 'eval' yang aman

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

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

Lokalisasi dan koma

Anda harus mempertimbangkan kemungkinan koma dalam representasi string angka, untuk kasus seperti float("545,545.2222")yang melempar pengecualian. Alih-alih, gunakan metode localeuntuk mengonversi string menjadi angka dan menafsirkan koma dengan benar. The locale.atofMetode bertobat untuk pelampung dalam satu langkah setelah lokal telah ditetapkan untuk konvensi angka yang diinginkan.

Contoh 1 - Konvensi nomor Amerika Serikat

Di Amerika Serikat dan Inggris, koma dapat digunakan sebagai pemisah ribuan. Dalam contoh ini dengan lokal Amerika, koma ditangani dengan benar sebagai pemisah:

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

Contoh 2 - konvensi nomor Eropa

Di sebagian besar negara di dunia , koma digunakan untuk tanda desimal alih-alih tanda titik. Dalam contoh ini dengan lokal Prancis, koma ditangani dengan benar sebagai tanda desimal:

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

Metode locale.atoiini juga tersedia, tetapi argumen harus berupa bilangan bulat.

Jika Anda tidak menolak modul pihak ketiga, Anda bisa melihat modul fastnumber . Ini menyediakan fungsi yang disebut fast_real yang melakukan persis apa yang diminta pertanyaan ini dan melakukannya lebih cepat daripada implementasi murni-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

Pengguna codelogic dan harley benar, tetapi perlu diingat jika Anda tahu string adalah integer (misalnya, 545), Anda dapat memanggil int ("545") tanpa terlebih dahulu melakukan casting untuk mengapung.

Jika string Anda ada dalam daftar, Anda bisa menggunakan fungsi peta juga.

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

Itu hanya baik jika mereka semua tipe yang sama.

Dalam Python, bagaimana saya bisa mengurai string numerik seperti "545.2222" ke nilai float yang sesuai, 542.2222? Atau parsing string "31" ke integer, 31? Saya hanya ingin tahu bagaimana mengurai string float ke float, dan (secara terpisah) string int ke int.

Ada baiknya Anda meminta untuk melakukan ini secara terpisah. Jika Anda mencampurnya, Anda mungkin menyiapkan diri untuk masalah nanti. Jawaban sederhananya adalah:

"545.2222" untuk mengapung:

>>> float("545.2222")
545.2222

"31" ke integer:

>>> int("31")
31

Konversi lain, int ke dan dari string dan literal:

Konversi dari berbagai pangkalan, dan Anda harus tahu pangkalan di muka (10 adalah default). Catatan Anda bisa mengawali mereka dengan apa yang Python harapkan untuk literalnya (lihat di bawah) atau menghapus awalan:

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

Jika Anda tidak tahu basis sebelumnya, tetapi Anda tahu mereka akan memiliki awalan yang benar, Python dapat menyimpulkan ini untuk Anda jika Anda lulus 0sebagai basis:

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

Literal Non-Desimal (yaitu Integer) dari Basa lain

Namun, jika motivasi Anda adalah untuk memiliki kode sendiri dengan jelas mewakili nilai spesifik yang dikodekan secara keras, Anda mungkin tidak perlu mengonversi dari basis - Anda dapat membiarkan Python melakukannya untuk Anda secara otomatis dengan sintaks yang benar.

Anda dapat menggunakan awalan apropos untuk mendapatkan konversi otomatis ke bilangan bulat dengan literal berikut . Ini berlaku untuk Python 2 dan 3:

Biner, awalan 0b

>>> 0b11111
31

Oktal, awalan 0o

>>> 0o37
31

Heksadesimal, awalan 0x

>>> 0x1f
31

Ini dapat berguna saat menggambarkan flag biner, izin file dalam kode, atau nilai hex untuk warna - misalnya, perhatikan tanpa tanda kutip:

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

Membuat ambigual Python 2 oktal kompatibel dengan Python 3

Jika Anda melihat bilangan bulat yang dimulai dengan 0, dalam Python 2, ini adalah sintaks oktal (tidak digunakan).

>>> 037
31

Itu buruk karena sepertinya nilainya seharusnya 37. Jadi dalam Python 3, sekarang memunculkan SyntaxError:

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

Ubah Python 2 oktal Anda menjadi oktal yang berfungsi di 2 dan 3 dengan 0oawalan:

>>> 0o37
31

Pertanyaannya agak lama. Tapi izinkan saya menyarankan fungsi, parseStr, yang membuat sesuatu yang serupa, yaitu, mengembalikan integer atau float dan jika string ASCII yang diberikan tidak dapat dikonversi ke tidak satupun dari mereka mengembalikannya tidak tersentuh. Kode tentu saja dapat disesuaikan untuk hanya melakukan apa yang Anda inginkan:

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

Saya menggunakan fungsi ini untuk itu

import ast

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

Ini akan mengkonversi string ke tipenya

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

The YAML parser dapat membantu Anda mengetahui apa yang datatype string Anda adalah. Gunakan yaml.load(), dan kemudian Anda dapat menggunakan type(result)untuk menguji jenis:

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

Anda perlu mempertimbangkan pembulatan akun untuk melakukan ini dengan benar.

Yaitu int (5.1) => 5 int (5.6) => 5 - salah, harus 6 jadi kita melakukan int (5.6 + 0.5) => 6

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

Saya terkejut tidak ada yang menyebutkan regex karena kadang-kadang string harus disiapkan dan dinormalisasi sebelum casting ke nomor

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

pemakaian:

parseNumber('13,345')
> 13345.0

parseNumber('- 123 000')
> -123000.0

parseNumber('99999\n')
> 99999.0

dan omong-omong, sesuatu untuk memverifikasi Anda memiliki nomor:

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

Untuk typecast dalam python gunakan fungsi konstruktor dari tipe tersebut, meneruskan string (atau nilai apa pun yang Anda coba gunakan) sebagai parameter.

Sebagai contoh:

>>>float("23.333")
   23.333

Di belakang layar, python memanggil __float__metode objek , yang seharusnya mengembalikan representasi parameter. Ini sangat kuat, karena Anda dapat mendefinisikan tipe Anda sendiri (menggunakan kelas) dengan __float__metode sehingga dapat dilemparkan ke float menggunakan float (myobject).

Ini adalah versi koreksi dari https://stackoverflow.com/a/33017514/5973334

Ini akan mencoba mengurai string dan mengembalikan salah satu intatau floattergantung pada apa yang diwakili string tersebut. Mungkin muncul pengecualian parsing atau memiliki beberapa perilaku yang tidak terduga .

  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

Lewati string Anda ke fungsi ini:

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)

Ini akan mengembalikan int, float atau string tergantung pada apa yang telah dilewati.

string yang merupakan int

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

string yang mengapung

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

string yang merupakan string

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

string yang terlihat seperti pelampung

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

Menggunakan:

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

Ini adalah cara paling Pythonic yang bisa saya lakukan.

Menangani hex, oktal, biner, desimal, dan float

Solusi ini akan menangani semua konvensi string untuk angka (semua yang saya ketahui).

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)

Output test case ini menggambarkan apa yang saya bicarakan.

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

Inilah tesnya:

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)

Menggunakan:

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

Ini adalah fungsi yang akan mengkonversi object(tidak hanya str) menjadi intatau float, berdasarkan apakah string aktual yang disediakan terlihat seperti int atau float. Lebih lanjut jika itu adalah objek yang memiliki keduanya __floatdan __int__metode, itu default untuk digunakan__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

Dengan menggunakan metode int dan float kita dapat mengonversi string menjadi integer dan float.

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

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

eval()adalah solusi yang sangat bagus untuk pertanyaan ini. Tidak perlu memeriksa apakah nomornya int atau float, itu hanya memberikan padanan yang sesuai. Jika diperlukan metode lain, coba

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

coba-kecuali juga bisa dijadikan alternatif. Coba konversi string menjadi int di dalam blok try. Jika string akan menjadi nilai float, itu akan melempar kesalahan yang akan ditangkap di blok kecuali, seperti ini

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

Berikut ini interpretasi lain dari pertanyaan Anda (petunjuk: tidak jelas). Mungkin Anda mencari sesuatu seperti ini:

def parseIntOrFloat( aString ):
    return eval( aString )

Ini berfungsi seperti ini ...

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

Secara teoritis, ada kerentanan injeksi. String bisa, misalnya "import os; os.abort()". Namun, tanpa latar belakang dari mana string itu berasal, kemungkinannya adalah spekulasi teoretis. Karena pertanyaannya tidak jelas, sama sekali tidak jelas apakah kerentanan ini benar-benar ada atau tidak.