Python metodă de a verifica dacă un șir este un float:

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

O mai fi si nume mult mai potrivit pentru această funcție ar putea fi: is_convertible_to_float(valoare)

Ceea ce este, și nu este un float în Python ar putea să vă surprindă:

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

Crezi că știi ce numere sunt? Nu sunt atât de bun pe cât crezi! Nu mare surpriză.

Don't de a folosi acest cod pe viață software-ul esențial!

Prinderea largă excepții de acest fel, uciderea canari si inghitit excepția creează o mică șansă ca un valabile plutesc ca string va returna false. Anii float(...) linie de cod poate nu a reușit pentru oricare din o mie de motive care nu au nimic de-a face cu conținutul șirului. Dar dacă te're scris viața software-ul esențial într-o rață-tastarea prototip de limbă, cum ar fi Python, atunci'am probleme mai mari.

Aceasta este o altă metodă care merită să fie menționate aici, ast.literal_eval:

Acest lucru poate fi folosit în condiții de siguranță pentru evaluarea siruri de caractere care conțin expresii Python de la surse de încredere, fără necesitatea de a analiza valorile sine.

Asta este, o sigur 'eval'

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

Localizare și virgule

Tu ar trebui să ia în considerare posibilitatea de virgule în șir de reprezentare a unui număr, pentru cazuri ca float("545,545.2222") care aruncă o excepție. În schimb, utilizați metode în "locale" pentru a converti șiruri de numere și de a interpreta corect virgule. Anii locale.atof metoda convertește la un flotor într-un singur pas odata locale a fost stabilit pentru numărul dorit de convenții.

Exemplu 1 -- Statele Unite ale americii numărul convențiilor

În Statele Unite ale americii și marea BRITANIE, virgule poate fi folosit ca un separator de mii. În acest exemplu, cu American locale, virgula este manipulat în mod corespunzător ca un separator:

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

Exemplu 2-European număr de convenții

În majoritatea țărilor lumii, virgulele sunt folosite pentru semnele zecimale în loc de perioade. În acest exemplu, cu locale francez, virgula este corect tratată ca o marca zecimală:

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

Metoda locale.atoi este, de asemenea, disponibile, dar argumentul ar trebui să fie un număr întreg.

Dacă nu't de potrivnic module terțe părți, ai putea verifica fastnumbers modulul. Acesta oferă o funcție numită fast_real, care face exact ceea ce această întrebare este de a cere și nu-l mai repede decât o pură implementare 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

Utilizatori codelogic și harley sunt corecte, dar păstrează în minte, dacă știi șir este un număr întreg (de exemplu, 545) puteți apela int("545"), fără prima de turnare să plutească.

Dacă siruri de caractere sunt într-o listă, puteți folosi funcția hartă la fel de bine.

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

Este bună doar dacă au're toate de același tip.

Întrebarea pare un pic mai vechi. Dar permiteți-mi să sugerez o funcție, parseStr, care face ceva similar, care este, se întoarce întreg sau float și dacă un anumit șir ASCII nu poate fi convertit la nici unul dintre ei se întoarce neatinsă. Codul de curs ar putea fi ajustate pentru a face doar ceea ce vrei:

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

În Python, cum pot analiza numerică șir de genul "545.2222" sa corespunzătoare float valoare, 542.2222? Sau parse string "31" la un număr întreg, 31? Vreau doar să știu cum de a analiza un float string la un float, și (separat) un întreg șir de la un int.

L's bine că vă cere să o facă separat. Daca're amestecarea lor, poate fi setarea-te pentru probleme mai târziu. Răspunsul simplu este:

`"545.2222" să float:

>>> float("545.2222")
545.2222

`"31" la un număr întreg:

>>> int("31")
31

Alte conversii, int la și de la siruri de caractere și literali:

Conversii din diverse baze, și ar trebui să știi de bază în avans (10 este implicit). Notă puteți prefix-le cu ce Python se așteaptă pentru literali (vezi mai jos) sau elimina prefixul:

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

Dacă tu nu't știu bază în avans, dar nu știi că va avea prefixul corect, Python poate deduce acest lucru pentru tine dacă treci de la " 0 " ca bază:

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

Non-Zecimal (de exemplu Integer) Literali din alte Baze

Dacă motivația ta este de a avea propriul cod în mod clar reprezintă hard-coded valori specifice, cu toate acestea, este posibil să nu nevoie pentru a converti de la baze - puteți să Python face pentru tine în mod automat cu sintaxa corectă.

Puteți utiliza apropos prefixe pentru a obține conversia automată a numerelor întregi cu următoarele literali. Acestea sunt valabile si pentru Python 2 și 3:

Binar, prefix 0b

>>> 0b11111
31

Octal, prefixul 0

>>> 0o37
31

Hexazecimal, prefix 0x

>>> 0x1f
31

Acest lucru poate fi util atunci când descrie binar steaguri, permisiunile de fișiere în cod, sau valori hex pentru culori - de exemplu, nota nr citate:

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

Face ambiguă Python 2 octals compatibil cu Python 3

Dacă vedeți un număr întreg care începe cu 0, în Python 2, aceasta este (învechită) octal sintaxă.

>>> 037
31

Este rău pentru că se pare că valoarea ar trebui să fie 37. Deci, în Python 3, acum se ridică o SyntaxError:

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

Convert Python 2 octals să octals, care funcționează în ambele 2 și 3 cu 0o prefix:

>>> 0o37
31

float("545.2222") " și " int(float("545.2222"))

De YAML parser poate ajuta să îți dai seama ce tip de date string este. Folosesc yaml.load(), și apoi puteți folositip(rezultat) la testul de tip:

>>> import yaml

>>> a = "545.2222"
>>> result = yaml.load(a)
>>> result
545.22220000000004
>>> type(result)


>>> b = "31"
>>> result = yaml.load(b)
>>> result
31
>>> type(result)


>>> c = "HI"
>>> result = yaml.load(c)
>>> result
'HI'
>>> type(result)

Eu folosesc această funcție pentru că

import ast

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

Acesta va converti șirul tip

value = parse_str('1')  # Returns Integer
value = parse_str('1.5')  # Returns 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 """ încercați: return int(s) cu excepția ValueError: încercați: reveni float(s) cu excepția ValueError: raise ValueError('argument nu este un șir de numărul de')

Ai nevoie să ia în considerare rotunjirea pentru a face acest lucru în mod corespunzător.

I. e. int(5.1) => 5 int(5.6) => 5 -- greșit, ar trebui să fie de 6, deci avem de a face int(5.6 + 0.5) => 6

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

Pentru a distribui în python utilizați constructorul funtions de tip, trece în șir (sau orice valoare sunteți încercarea de a arunca) ca un parametru.

De exemplu:

>>>float("23.333")
   23.333

În spatele scenei, python este de asteptare obiectelorfloatmetoda, care ar trebui să se întoarcă un flotor de reprezentare a parametrului. Acest lucru este deosebit de puternic, după cum puteți defini propriile tipuri (folosind clase) cu ofloat` metodă, astfel încât acesta poate fi turnat într-un flotor folosind float(myobject).

Sunt surprins că nimeni nu a menționat regex pentru că, uneori, string trebuie să fie pregătite și normalizat înainte de turnare să număr

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

utilizare:

parseNumber('13,345')
> 13345.0

parseNumber('- 123 000')
> -123000.0

parseNumber('99999\n')
> 99999.0

și apropo, ceva pentru a verifica dacă aveți un număr:

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

Aceasta este o versiune corectată de https://stackoverflow.com/a/33017514/5973334

Acest lucru va încerca să elimine un șir de caractere și de a reveni fie int sau "float" în funcție de ceea ce șir reprezintă. S-ar putea ridica parsarea excepții sau au un comportament neașteptat.

  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

Utilizare:

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

Acesta este cel mai Pythonic fel am putea veni cu.