# How to convert strings into integers?

Each Answer to this Q is separated by one/two green lines.

I have a tuple of tuples from a MySQL query like this:

``````T1 = (('13', '17', '18', '21', '32'),
('07', '11', '13', '14', '28'),
('01', '05', '06', '08', '15', '16'))
``````

I’d like to convert all the string elements into integers and put them back into a list of lists:

``````T2 = [[13, 17, 18, 21, 32], [7, 11, 13, 14, 28], [1, 5, 6, 8, 15, 16]]
``````

I tried to achieve it with `eval` but didn’t get any decent result yet.

`int()` is the Python standard built-in function to convert a string into an integer value. You call it with a string containing a number as the argument, and it returns the number converted to an integer:

``````>>> int("1") + 1
2
``````

If you know the structure of your list, T1 (that it simply contains lists, only one level), you could do this in Python 3:

``````T2 = [list(map(int, x)) for x in T1]
``````

In Python 2:

``````T2 = [map(int, x) for x in T1]
``````

You can do this with a list comprehension:

``````T2 = [[int(column) for column in row] for row in T1]
``````

The inner list comprehension (`[int(column) for column in row]`) builds a `list` of `int`s from a sequence of `int`-able objects, like decimal strings, in `row`. The outer list comprehension (`[... for row in T1])`) builds a list of the results of the inner list comprehension applied to each item in `T1`.

The code snippet will fail if any of the rows contain objects that can’t be converted by `int`. You’ll need a smarter function if you want to process rows containing non-decimal strings.

If you know the structure of the rows, you can replace the inner list comprehension with a call to a function of the row. Eg.

``````T2 = [parse_a_row_of_T1(row) for row in T1]
``````

I would rather prefer using only comprehension lists:

``````[[int(y) for y in x] for x in T1]
``````

Instead of putting `int( )`, put `float( )` which will let you use decimals along with integers.

I would agree with everyones answers so far but the problem is is that if you do not have all integers they will crash.

If you wanted to exclude non-integers then

``````T1 = (('13', '17', '18', '21', '32'),
('07', '11', '13', '14', '28'),
('01', '05', '06', '08', '15', '16'))
new_list = list(list(int(a) for a in b) for b in T1 if a.isdigit())
``````

This yields only actual digits. The reason I don’t use direct list comprehensions is because list comprehension leaks their internal variables.

Try this.

``````x = "1"
``````

x is a string because it has quotes around it, but it has a number in it.

``````x = int(x)
``````

Since x has the number 1 in it, I can turn it in to a integer.

To see if a string is a number, you can do this.

``````def is_number(var):
try:
if var == int(var):
return True
except Exception:
return False

x = "1"

y = "test"

x_test = is_number(x)

print(x_test)
``````

It should print to IDLE True because x is a number.

``````y_test = is_number(y)

print(y_test)
``````

It should print to IDLE False because y in not a number.

``````T3=[]

for i in range(0,len(T1)):
T3.append([])
for j in range(0,len(T1[i])):
b=int(T1[i][j])
T3[i].append(b)

print T3
``````

Using list comprehensions:

``````t2 = [map(int, list(l)) for l in t1]
``````

See this function

``````def parse_int(s):
try:
res = int(eval(str(s)))
if type(res) == int:
return res
except:
return
``````

Then

``````val = parse_int('10')  # Return 10
val = parse_int('0')  # Return 0
val = parse_int('10.5')  # Return 10
val = parse_int('0.0')  # Return 0
val = parse_int('Ten')  # Return None
``````

You can also check

``````if val == None:  # True if input value can not be converted
pass  # Note: Don't use 'if not val:'
``````

Yet another functional solution for Python 2:

``````from functools import partial

map(partial(map, int), T1)
``````

Python 3 will be a little bit messy though:

``````list(map(list, map(partial(map, int), T1)))
``````

we can fix this with a wrapper

``````def oldmap(f, iterable):
return list(map(f, iterable))

oldmap(partial(oldmap, int), T1)
``````

In Python 3.5.1 things like these work:

``````c = input('Enter number:')
print (int(float(c)))
print (round(float(c)))
``````

and

``````Enter number:  4.7
4
5
``````

George.

Python has built in function int(string) and optional parameter base.

if your string contains an Integer value, it will convert that to the corresponding Integer value.
However if you have decimnal number as string you’ll need float() to convert it.

Usage:

``````a="22"
b = int(a)
``````

and

``````if a="22.22"
b = int(a) '''will give error, invalid literal for int().'''
b = float(a) '''will convert the string.'''
``````

If it’s only a tuple of tuples, something like `rows=[map(int, row) for row in rows]` will do the trick. (There’s a list comprehension and a call to map(f, lst), which is equal to [f(a) for a in lst], in there.)

Eval is not what you want to do, in case there’s something like `__import__("os").unlink("importantsystemfile")` in your database for some reason.
Always validate your input (if with nothing else, the exception int() will raise if you have bad input).

I want to share an available option that doesn’t seem to be mentioned here yet:

``````rumpy.random.permutation(x)
``````

Will generate a random permutation of array x. Not exactly what you asked for, but it is a potential solution to similar questions.

You can do something like this:

``````T1 = (('13', '17', '18', '21', '32'),
('07', '11', '13', '14', '28'),
('01', '05', '06', '08', '15', '16'))
new_list = list(list(int(a) for a in b if a.isdigit()) for b in T1)
print(new_list)
``````

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .