You can convert a string to a 32-bit signed integer with the int function:

string = "1234"
i = int(string)  # i is a 32-bit integer

If the string does not represent an integer, you'll get a ValueError exception. Note, however, that if the string does represent an integer, but that integer does not fit into a 32-bit signed int, then you'll actually get an object of type long instead.

You can then convert it to other widths and signednesses with some simple math:

s8 = (i + 2**7) % 2**8 - 2**7      # convert to signed 8-bit
u8 = i % 2**8                      # convert to unsigned 8-bit
s16 = (i + 2**15) % 2**16 - 2**15  # convert to signed 16-bit
u16 = i % 2**16                    # convert to unsigned 16-bit
s32 = (i + 2**31) % 2**32 - 2**31  # convert to signed 32-bit
u32 = i % 2**32                    # convert to unsigned 32-bit
s64 = (i + 2**63) % 2**64 - 2**63  # convert to signed 64-bit
u64 = i % 2**64                    # convert to unsigned 64-bit

You can convert strings to floating point with the float function:

f = float("3.14159")

Python floats are what other languages refer to as double, i.e. they are 64-bits. There are no 32-bit floats in Python.

Assuming:

1. You have 2's-complement representations in mind; and,
2. By (unsigned long) you mean unsigned 32-bit integer,

then you just need to add 2**32 (or 1 << 32) to the negative value.

For example, apply this to -1:

>>> -1
-1
>>> _ + 2**32
4294967295L
>>> bin(_)
'0b11111111111111111111111111111111'

Assumption #1 means you want -1 to be viewed as a solid string of 1 bits, and assumption #2 means you want 32 of them.

Nobody but you can say what your hidden assumptions are, though. If, for example, you have 1's-complement representations in mind, then you need to apply the ~ prefix operator instead. Python integers work hard to give the illusion of using an infinitely wide 2's complement representation (like regular 2's complement, but with an infinite number of "sign bits").

And to duplicate what the platform C compiler does, you can use the ctypes module:

>>> import ctypes
>>> ctypes.c_ulong(-1)  # stuff Python's -1 into a C unsigned long
c_ulong(4294967295L)
>>> _.value
4294967295L

C's unsigned long happens to be 4 bytes on the box that ran this sample.

You can use the nice struct module to unpack it. This will give you a tuple of 64 small integers (the B means "unsigned char"):

>>> print repr(data)
'V\x99\xf3\x0c\x1b\xc7]\x1f\xe4\nQ5$*\x88\x88Yg\xff{\xea\xe9e\xd8\xb32oD\xff\xcfV\x84\x90xv,\x9dw\x1e(\x12\xfe\x9a\xb4,\x96%\xad
;S\xb6\xa3\xf9\xb69\xfa\xec\x1dl\x97\x1d\xd64/'
>>> len(data)
64
>>> struct.unpack("64B", data)
(86, 153, 243, 12, 27, 199, 93, 31, 228, 10, 81, 53, 36, 42, 136, 136, 89, 103, 255, 123, 234, 233, 101, 216, 179, 50, 111, 68,
255, 207, 86, 132, 144, 120, 118, 44, 157, 119, 30, 40, 18, 254, 154, 180, 44, 150, 37, 173, 59, 83, 182, 163, 249, 182, 57, 250
, 236, 29, 108, 151, 29, 214, 52, 47)

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

import ctypes

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