Vraag Hoe parseer ik een string naar een float of int in Python?


Hoe kan ik in Python een numerieke reeks ontleden? "545.2222" naar de bijbehorende vlotterwaarde, 542.2222? Of ontleed de string "31" tot een geheel getal, 31?

Ik wil gewoon weten hoe ik een a vlotter  string naar een float, en (afzonderlijk) een int  string aan een int.


1757
2017-12-19 01:52


oorsprong


antwoorden:


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

2084
2017-12-19 01:54



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

441
2017-12-19 02:31



Python-methode om te controleren of een string een float is:

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

Een langere en meer accurate naam voor deze functie zou kunnen zijn: isConvertibleToFloat(value)

Wat is, en is geen float in Python kan je verrassen:

val                   isfloat(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

Denk je dat je weet wat getallen zijn? Je bent niet zo goed als je denkt! Geen grote verrassing.


416
2018-01-05 04:15



Dit is een andere methode die hier verdient te worden vermeld, ast.literal_eval:

Dit kan worden gebruikt voor het veilig evalueren van strings die Python-expressies uit niet-vertrouwde bronnen bevatten zonder dat de waarden zelf moeten worden ontleed.

Dat wil zeggen, een veilige 'eval'

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

104
2018-03-01 04:23



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

74
2017-12-19 02:32



Lokalisatie en komma's

Je moet rekening houden met de mogelijkheid van komma's in de tekenreeksrepresentatie van een getal, voor gevallen zoals float("545,545.2222") welke een uitzondering werpt. Gebruik in plaats daarvan methoden in locale om de strings naar getallen te converteren en komma's correct te interpreteren. De locale.atof methode converteert naar een float in één stap zodra de locale is ingesteld voor de gewenste nummerconventie.

Voorbeeld 1 - Nummerconventies in de Verenigde Staten 

In de Verenigde Staten en het VK kunnen komma's als scheidingsteken voor duizendtallen worden gebruikt. In dit voorbeeld met Amerikaanse locale wordt de komma correct behandeld als scheidingsteken:

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

Voorbeeld 2 - Europese nummerconventies

In de meerderheid van de landen van de wereld, komma's worden gebruikt voor decimale tekens in plaats van punten. In dit voorbeeld met de Franse locale wordt de komma correct behandeld als een decimaalteken:

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

De methode locale.atoi is ook beschikbaar, maar het argument moet een geheel getal zijn.


45
2017-07-23 16:00



gebruikers codelogic en harley zijn correct, maar onthoud dat als u weet dat de reeks een geheel getal is (bijvoorbeeld 545) u int ("545") kunt aanroepen zonder eerst te zweven.

Als uw strings in een lijst staan, kunt u ook de kaartfunctie gebruiken.

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

Het is alleen goed als ze allemaal hetzelfde type zijn.


22
2017-12-19 02:09



Als u niet vies bent van modules van derden, kunt u de fastnumbers module. Het biedt een functie genaamd fast_real dat doet precies waar deze vraag om vraagt ​​en doet het sneller dan een pure Python-implementatie:

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

21
2017-08-14 03:21



Hoe kan ik in Python een numerieke reeks zoals "545.2222" parseren op de overeenkomende floatwaarde, 542.2222? Of ontleed de tekenreeks "31" naar een geheel getal 31?   Ik wil gewoon weten hoe ik een float-string moet parseren naar een float en (apart) een int-string naar een int.

Het is goed dat je vraagt ​​om deze apart te doen. Als je ze aan het mixen bent, kun je je later misschien voor problemen stellen. Het simpele antwoord is:

"545.2222" drijven:

>>> float("545.2222")
545.2222

"31"naar een geheel getal:

>>> int("31")
31

Andere conversies, ints van en naar strings en literals:

Conversies van verschillende basissen, en u zou de basis van tevoren moeten kennen (10 is de standaard). Merk op dat je ze kunt invoegen met wat Python verwacht voor zijn letterlijke tekens (zie hieronder) of het voorvoegsel verwijderen:

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

Als je de basis niet van tevoren kent, maar je weet wel dat ze de juiste prefix hebben, kan Python dit voor jou afleiden als je voorbij komt 0 als de basis:

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

Niet-decimale (dat wil zeggen geheel getal) literalen van andere basen

Als je motivatie is om je eigen code duidelijk harde gecodeerde specifieke waarden te laten weergeven, hoef je de basis misschien niet te converteren - je kunt Python het automatisch laten doen met de juiste syntaxis.

U kunt de prefix apropos gebruiken om de automatische conversie naar gehele getallen te verkrijgen de volgende literalen. Deze zijn geldig voor Python 2 en 3:

Binair, voorvoegsel 0b

>>> 0b11111
31

Octaal, voorvoegsel 0o

>>> 0o37
31

Hexadecimaal, voorvoegsel 0x

>>> 0x1f
31

Dit kan handig zijn bij het beschrijven van binaire vlaggen, bestandspermissies in code of hex-waarden voor kleuren - noteer bijvoorbeeld geen aanhalingstekens:

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

Het maken van dubbelzinnige Python 2 octals compatibel met Python 3

Als u een geheel getal ziet dat begint met een 0, in Python 2, is dit de (verouderd) octaalsyntaxis.

>>> 037
31

Het is slecht omdat het lijkt alsof de waarde zou moeten zijn 37. Dus in Python 3 wordt nu een SyntaxError:

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

Converteer uw Python 2 octals naar octals die werken in zowel 2 als 3 met de 0o voorvoegsel:

>>> 0o37
31

17
2017-07-23 13:26



De vraag lijkt een beetje oud. Maar laat me een functie voorstellen, parseStr, die iets soortgelijks maakt, dat wil zeggen, integer of float retourneert en als een gegeven ASCII-reeks niet naar geen enkele kan worden geconverteerd, wordt deze functie onaangeroerd. De code kan natuurlijk worden aangepast om alleen te doen wat je wilt:

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

16
2017-09-28 19:45



float("545.2222") en int(float("545.2222"))


13
2017-12-19 01:54