Python'da, "545.2222"karşılık gelen kayan nokta değerine benzer bir sayısal dizeyi nasıl ayrıştırabilirim 545.2222? Ya dizeyi ayrıştırmak "31", bir tam sayıya 31?

Sadece ayrıştırmak nasıl bilmek istiyorum şamandıra str bir etmek floatve (ayrı) bir int str bir etmek int.

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

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

Bir dizenin kayan nokta olup olmadığını kontrol etmek için Python yöntemi:

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

Bu işlev için daha uzun ve daha doğru bir ad şunlar olabilir: is_convertible_to_float(value)

Python'da bir şamandıra nedir ve bir şamandıra sizi şaşırtabilir:

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

Numaraların ne olduğunu bildiğini mi sanıyorsun? Sandığınız kadar iyi değilsiniz! Büyük sürpriz değil.

Bu kodu hayati öneme sahip yazılımlarda kullanmayın!

Geniş istisnaları bu şekilde yakalamak, kanaryaları öldürmek ve istisnayı azaltmak, dize olarak geçerli bir şamandıranın yanlış dönmesi için küçük bir şans yaratır. float(...)Kod satırının dizesinin içeriğiyle ilgisi olmayan bin nedenlerden herhangi birine başarısız olabilir. Ancak, hayat açısından kritik bir yazılımı Python gibi ördek tipi bir prototip dilde yazıyorsanız, çok daha büyük sorunlarınız var.

Bu, burada belirtilmeyi hak eden başka bir yöntemdir, ast.literal_eval :

Bu, değerleri kendileri ayrıştırmaya gerek kalmadan, güvenilmeyen kaynaklardan Python ifadeleri içeren dizeleri güvenle değerlendirmek için kullanılabilir.

Yani, güvenli bir 'eval'

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

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

Yerelleştirme ve virgül

float("545,545.2222")İstisna atanan durumlar için, bir sayının dize gösteriminde virgül olasılığını göz önünde bulundurmalısınız . Bunun yerine, localedizeleri sayılara dönüştürmek ve virgülleri doğru yorumlamak için yöntemleri kullanın . locale.atofYerele kez tek bir adımda bir şamandıra yöntem dönüştürür istenen sayıda kuralı için ayarlandı.

Örnek 1 - Birleşik Devletler sayı sözleşmeleri

Amerika Birleşik Devletleri ve Birleşik Krallık'ta, virgüller binlerce ayırıcı olarak kullanılabilir. Amerikan yerel ayarına sahip bu örnekte, virgül ayırıcı olarak düzgün kullanılır:

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

Örnek 2 - Avrupa sayı sözleşmeleri

Dünya ülkelerinin çoğunda virgül, nokta yerine ondalık işareti için kullanılır. Fransızca yerel ayarlı bu örnekte, virgül ondalık işareti olarak doğru şekilde işlenir:

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

Yöntem locale.atoide kullanılabilir, ancak argüman bir tamsayı olmalıdır.

Üçüncü taraf modüllere karşı değilseniz, fastnumbers modülünü kontrol edebilirsiniz . Bu sorunun tam olarak ne istediğini yapan ve salt Python uygulamasından daha hızlı yapan fast_real adlı bir işlev sağlar :

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

Kullanıcılar codelogic ve harley doğrudur, ancak dizenin bir tamsayı olduğunu biliyorsanız (örneğin, 545), önce yüzmek için döküm yapmadan int ("545") diyebilirsiniz.

Dizeleriniz bir listede bulunuyorsa, harita işlevini de kullanabilirsiniz.

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

Sadece hepsi aynı türdeyse iyi olur.

Python'da "545.2222" gibi sayısal bir dizeyi 542.2222 karşılık gelen kayan noktalı değere nasıl ayrıştırabilirim? Veya "31" dizesini 31, Ben sadece bir kayan nokta için bir kayan nokta dize ayrıştırmak ve bir int için (ayrı ayrı) bir int string bilmek istiyorum.

Bunları ayrı ayrı yapmanız iyi olur. Onları karıştırıyorsanız, daha sonra sorunlara hazırlıklı olabilirsiniz. Basit cevap:

"545.2222" Batmak:

>>> float("545.2222")
545.2222

"31" bir tamsayıya:

>>> int("31")
31

Diğer dönüşümler, dizgilere ve değişmez metinlere giriş ve çıkışlar:

Çeşitli bazlardan dönüşümler ve tabanı önceden bilmeniz gerekir (10 varsayılan değerdir). Bunlara Python'un değişmez değerleri için ne beklediğini ön ekleyebilir (aşağıya bakın) veya ön eki kaldırabilirsiniz:

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

Tabanı önceden bilmiyorsanız, ancak doğru öneklere sahip olacaklarını biliyorsanız, temel olarak geçerseniz Python bunu sizin için çıkarabilir 0:

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

Diğer Tabanlardan Ondalık Olmayan (yani Tamsayı) Değişmez Değerler

Motivasyonunuz sabit kodlu belirli değerleri açıkça temsil etmekse, temellerden dönüştürmeniz gerekmeyebilir - Python'un bunu sizin için doğru sözdizimiyle otomatik olarak yapmasına izin verebilirsiniz.

Aşağıdaki değişmez değerlerle tamsayılara otomatik dönüşüm elde etmek için apropos öneklerini kullanabilirsiniz . Bunlar Python 2 ve 3 için geçerlidir:

İkili, önek 0b

>>> 0b11111
31

Sekizlik, önek 0o

>>> 0o37
31

Onaltılık, önek 0x

>>> 0x1f
31

Bu, ikili bayraklar, koddaki dosya izinleri veya renkler için onaltılık değerler tanımlanırken yararlı olabilir - örneğin, tırnak işareti yok:

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

Belirsiz Python 2 sekizliklerini Python 3 ile uyumlu hale getirme

0 ile başlayan bir tam sayı görürseniz, Python 2'de bu (kullanımdan kaldırılmış) sekizlik sözdizimidir.

>>> 037
31

Kötü çünkü değer olması gerektiği gibi görünüyor 37. Python 3'te, şimdi bir SyntaxError:

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

Python 2 sekizliklerinizi 0oönek ile hem 2 hem de 3'te çalışan sekizliklere dönüştürün :

>>> 0o37
31

Soru biraz eski gibi görünüyor. Ama benzer bir şey yapan parseStr işlevini önereyim, yani tamsayı veya kayan nokta döndürür ve belirli bir ASCII dizesi bunların hiçbirine dönüştürülemezse ona dokunulmaz. Elbette kod sadece istediğinizi yapacak şekilde ayarlanabilir:

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

Bunun için bu işlevi kullanıyorum

import ast

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

Dizeyi türüne dönüştürür

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

YAML ayrıştırıcı Eğer veri türü dize olduğunu anlamaya yardımcı olabilir. Kullanın yaml.load()ve sonra type(result)türü test etmek için kullanabilirsiniz :

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

Bunu düzgün yapmak için yuvarlamayı dikkate almanız gerekir.

İnt (5.1) => 5 int (5.6) => 5 - yanlış, 6 olmalı, böylece int (5.6 + 0.5) => 6

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

Kimse regex bahsetmedim şaşırdım çünkü bazen dize numaraya dökümden önce hazırlanmalı ve normalleştirilmelidir

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

kullanımı:

parseNumber('13,345')
> 13345.0

parseNumber('- 123 000')
> -123000.0

parseNumber('99999\n')
> 99999.0

ve bu arada, bir numaranız olduğunu doğrulamak için bir şey:

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

Python'da tahmin etmek için, dizeyi (veya yayınlamaya çalıştığınız değeri) parametre olarak geçirerek türün yapıcı işlevlerini kullanın.

Örneğin:

>>>float("23.333")
   23.333

Perde arkasında, python __float__parametrenin şamandıra temsilini döndürmesi gereken nesneler yöntemini çağırıyor . Bu, özellikle kendi türlerinizi (sınıfları kullanarak) bir __float__yöntemle tanımlayabileceğiniz için güçlüdür, böylece şamandıra (myobject) kullanılarak bir şamandıraya dökülebilir.

Bu düzeltilmiş bir versiyonu arasında https://stackoverflow.com/a/33017514/5973334

Bu, bir dizeyi ayrıştırmaya ve dizenin neyi temsil ettiğine bağlı olarak ya intda döndürmeye çalışacaktır float. Ayrıştırma istisnalarını artırabilir veya beklenmedik davranışlar gösterebilir .

  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

Dizenizi bu işleve iletin:

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)

Ne geçtiğine bağlı olarak int, float veya string döndürür.

int olan dize

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

kayan nokta

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

dize olan dize

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

kayan nokta gibi görünen dize

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

kullanın:

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

Bu benim gelebileceğim en Pitonik yol.

Onaltılık, sekizli, ikili, ondalık ve kayan nokta işlemek

Bu çözüm, sayılar için tüm dize kurallarını (bildiğim her şeyi) işleyecektir.

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)

Bu test senaryosu çıktısı, neden bahsettiğimi gösteriyor.

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

İşte 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)

kullanın:

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

Bu, sağlanan gerçek dizgenin veya gibi görünmesine bağlı olarak object(yalnızca değil str) intveya işlevini dönüştüren bir işlevdir . İkisi birlikte bir nesne daha halinde ve yöntemler kullanarak bu varsayılanfloat intfloat__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

İnt ve float yöntemlerini kullanarak bir dizeyi tamsayı ve float'a dönüştürebiliriz.

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

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

eval()bu soruya çok iyi bir çözümdür. Sayının int veya float olup olmadığını kontrol etmek gerekmez, sadece karşılık gelen eşdeğeri verir. Başka yöntemler gerekiyorsa,

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

try-hariç alternatif olarak da kullanılabilir. Dizeyi try bloğunun içindeki int değerine dönüştürmeyi deneyin. Dize kayan değer olacaksa, hariç blokta yakalanacak bir hata atar, şöyle

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

İşte sorunuzun başka bir yorumu (ipucu: belirsiz). Bunun gibi bir şey arıyor olabilirsiniz:

def parseIntOrFloat( aString ):
    return eval( aString )

Bu şekilde çalışır ...

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

Teorik olarak, bir enjeksiyon güvenlik açığı vardır. Dize, örneğin olabilir "import os; os.abort()". Bununla birlikte, ipin nereden geldiğine dair herhangi bir arka plan olmadan, olasılık teorik spekülasyondur. Soru belirsiz olduğu için, bu güvenlik açığının gerçekten var olup olmadığı açık değildir.