As others have said, 32-bit versions of numpy still support 64-bit dtypes. But if you really need to convert to int32, you can use the astype function:

>>> import numpy as np
>>> x = np.array([1,2,3], dtype=np.int64)
>>> x
array([1, 2, 3])
>>> x.dtype
dtype('int64')
>>> y = x.astype(np.int32)
>>> y
array([1, 2, 3], dtype=int32)

If the result should be an integer, you should use operator.floordiv, i.e. a // b, not a / b ¹:

from operator import add, sub, mul, floordiv, mod

op = {'+': add, '-': sub, '*': mul, '/': floordiv, '%': mod}

for i in range(int(input())):
    znak, *nums = input().split()

    print(opznak))

By the way, the code above does exactly the same as yours, but it's around two times shorter!

How?

• why check if znak is equal to something with tons of if/else statements, if you could put all the math operators in a dictionary op, and get the operator you need with op[znak]?
• you're on Python 3, so you can use that nice a, *b = iterable syntax which extracts the first item of iterable into a and puts other items into a list b, which looks super nice
• each op[znak] is a function that accepts two arguments, so you convert nums to integers with map(int, nums) and then pass them as separate arguments with the asterisk: *map(int, nums)
• last, but not least, why use this C-style while loop index incrementing if there's the Pythonic way to do it - with range(start, stop, [step])?
• finally, you don't really need the variable n, so you can plug it into range right away

Pssst, dude, feeling in need of some craziness? Take a look at how you can squeeze all this into two lines:

from operator import*

sum(0for _ in map(print,((lambda znak,*nums:{'+':add,'-':sub,'*':mul,'/':floordiv,'%':mod}znak))(*input().split())for _ in range(int(input())))))

Or only one line:

sum(0for _ in map(print,((lambda znak,*nums:{'+':lambda a,b:a+b,'-':lambda a,b:a-b,'*':lambda a,b:a*b,'/':lambda a,b:a//b,'%':lambda a,b:a%b}znak))(*input().split())for _ in range(int(input())))))

These work exactly as the first version. Now, this is just for fun, to show how powerful Python is and how messy it can be. Don't try this at home :D

¹ True division vs Floor division: 1 / 10 == 0.1, but 1 // 10 == 0.

Not sure if it's "nicer" or not...

import ctypes

def int32_to_uint32(i):
    return ctypes.c_uint32(i).value

numpy.ndarray.tolist will do it:

a.tolist()

If your data is a pandas series you can call their tolist wrapper with the same result.

def convert(i):
    return int(bin(i+2**32)[-32:])

print convert(1)
print convert(32)
print convert(100)
print convert(-1)
print type(convert(1))

outputs

00000000000000000000000000000001
00000000000000000000000000100000
00000000000000000000000001100100
11111111111111111111111111111111
<type 'long'>

'{:032b}'.format(n) where n is an integer. If the binary representation is greater than 32 digits it will expand as necessary:

>>> '{:032b}'.format(100)
'00000000000000000000000001100100'
>>> '{:032b}'.format(8589934591)
'111111111111111111111111111111111'
>>> '{:032b}'.format(8589934591 + 1)
'1000000000000000000000000000000000'    # N.B. this is 33 digits long