How to convert list of strings to their correct Python types?

Question

Given a list of python strings, how can I automatically convert them to their correct type?

Meaning, if I have:

["hello", "3", "3.64", "-1"]

I'd like this to be converted to the list

["hello", 3, 3.64, -1]

where the first element is a string, the second an int, the third a float, and the fourth an int.

How can I do this?

score 25 · Accepted Answer · answered May 18 '10 at 17:49

25

import ast

L = ["hello", "3", "3.64", "-1"]

def tryeval(val):
  try:
    val = ast.literal_eval(val)
  except ValueError:
    pass
  return val

print [tryeval(x) for x in L]

answered May 18 '10 at 17:49

Ignacio Vazquez-Abrams

776,304
153
1,341
1,358

7

In honesty, this is a better solution than mine. – jemfinch May 18 '10 at 17:59
but evals are kinda hackish and overpowered – msw May 18 '10 at 18:14
3

If it's good enough for the Python compiler, then it's good enough for the user. – Ignacio Vazquez-Abrams May 18 '10 at 18:16
you are correct, I was ignorant of the safe semantics of `ast.literal_eval` *bows* – msw May 18 '10 at 18:24
Note that this does note work for cases like '01', where int('01')==1, but literal_eval throws an error. Depending on the use case, that means literal_eval isn't enough – BurnNote Jan 26 '21 at 16:06
Some others which throw `SyntaxError` instead of `ValueError` e.g. `*` and `+`, so probably worth it to `except SyntaxError` and `pass` too. – davetapley Jun 07 '23 at 22:02

score 8 · Answer 2 · answered May 18 '10 at 17:59

8

Without using evaluation:

def convert(val):
    constructors = [int, float, str]
    for c in constructors:
        try:
            return c(val)
        except ValueError:
            pass

answered May 18 '10 at 17:59

Ryan

15,016
6
48
50

1

Great solution (and safe!). The approach can easily be extended to any data type. +1 – Escualo May 18 '10 at 18:39
@Escualo not quite, a counter example would be the boolean type. – Mehdi Dec 16 '22 at 15:40

score 4 · Answer 3 · answered Nov 17 '14 at 18:45

4

I accomplished the same using json.loads method

def f(l):
    for i in l:
        try:
            yield json.loads(i)
        except:
            yield i

Test:

In [40]: l
Out[40]: ['hello', '3', '3.64', '-1']

In [41]: list(f(l))
Out[41]: ['hello', 3, 3.64, -1]

answered Nov 17 '14 at 18:45

Chillar Anand

27,936
9
119
136

1

For my task, this method is much better than the other one using ast lib. Thank you. – Mikhail S Jun 22 '22 at 10:25

score 3 · Answer 4 · answered May 18 '10 at 17:52

3

def tryEval(s):
  try:
    return eval(s, {}, {})
  except:
    return s

map(tryEval, ["hello", "3", "3.64", "-1"])

Only do this if you trust the input. Also, be aware that it supports more than just literals; arithmetic expressions will be evaluated as well.

answered May 18 '10 at 17:52

jemfinch

2,851
19
24

You should specify exception types (i.e. NameError, SyntaxError). – tgray May 18 '10 at 18:29
In general, yes, but in this implementation, definitely not. Do you really want to attempt the task of determining *all* exceptions that can possibly be raised by `eval`? ZeroDivisionError, TypeError, and probably some more that even I'm not thinking of? – jemfinch May 18 '10 at 19:46

score 0 · Answer 5 · answered May 18 '10 at 18:12

If the you are truly interested in only strings, floats, and ints, I prefer the more verbose, less-evalful

def interpret_constant(c):
    try:
        if str(int(c)) == c: return int(c)
    except ValueError:
        pass
    try:
        if str(float(c)) == c: return float(c)
    except ValueError:
        return c

test_list = ["hello", "3", "3.64", "-1"]

typed_list = [interpret_constant(x) for x in test_list]
print typed_list
print [type(x) for x in typed_list]

score 0 · Answer 6 · edited May 23 '17 at 12:18

This is not really an answer, but I wanted to point out how important this can be when you have a database of parameters with schema ID, PAR, VAL. For instance:

ID  PAR      VAL
001 velocity '123.45'
001 name     'my_name'
001 date     '18-dec-1978'

This schema is appropriate when you don't know how many parameters you need to store for a certain ID. The disadvantage is precisely that the values in VAL are all strings, and need to be converted to the correct data type on demand. You can do this by adding a fourth column to the schema, called TYPE, or you can use any of the approaches proposed thus far.

Good question!

PS. The database schema is related to one of my previous questions.

score 0 · Answer 7 · answered May 19 '10 at 11:27

A variant of ryans's nice solution, for numpy users:

def tonum( x ):
    """ -> int(x) / float(x) / None / x as is """
    if np.isscalar(x):  # np.int8 np.float32 ...
    # if isinstance( x, (int, long, float) ):
        return x
    try:
        return int( x, 0 )  # 0: "0xhex" too
    except ValueError:
        try:
            return float( x )  # strings nan, inf and -inf too
        except ValueError:
            if x == "None":
                return None
            return x

def numsplit( line, sep=None ):
    """ line -> [nums or strings ...] """
    return map( tonum, line.split( sep ))  # sep None: whitespace

How to convert list of strings to their correct Python types?

7 Answers7

Linked

Related