The string is a literal.

3>> bin(int('0b1010', 2))
'0b1010'
3>> bin(int('1010', 2))
'0b1010'
3>> 0b1010
10
3>> int('0b1010', 2)
10

Something like this?

>>> st = "hello world"
>>> ' '.join(format(ord(x), 'b') for x in st)
'1101000 1100101 1101100 1101100 1101111 100000 1110111 1101111 1110010 1101100 1100100'

#using `bytearray`
>>> ' '.join(format(x, 'b') for x in bytearray(st, 'utf-8'))
'1101000 1100101 1101100 1101100 1101111 100000 1110111 1101111 1110010 1101100 1100100'

Use Python's int() function to convert the string to an integer. Use 2 for the base parameter since binary uses base 2:

binary_str = '10010110' # Binary string
num = int(binary_str, 2)
# Output: 150

Next, use the bin() function to convert the integer to binary:

binary_num = bin(num)
# Output: 0b10010110

import struct
with open("foo.bin", 'wb') as f:
    f.write(struct.pack('h', 0b0010010110101))

Will take 2 bytes (16 bits) as a short integer (h). You can define your own format string using the struct module, but I am not sure you will be able to get under the byte size.

EDIT

As per your comment, here's a bit of context:

When writing something in a file, it is always converted to binary. Character are encoded using some rule, called encoding (such as ASCII) where each character is mapped to a number, itself represented in binary. This way, the number 00100100 (36) and the character '$' are the same thing. '$' is represented by 36 on the file, and the software layers between you (such as an editor) will render every '00100100' it encounters as character '$'.

Now when you write the string '00100100' into a file, it will print the characters '0', '1' etc.... So the string '00100100' is represented by the binary number 110000110000110001110000110000110001110000110000. This is necessary because the input being a string, you need an unambiguous way of representing all possible 8-characters long strings, not only the ones representing 0s and 1s.

The Python API for writing files is always writing strings, i.e. it will perform this conversion string -> binary number automatically, and I don't know any way to override that. What you can do however is generate the string such that its binary representation is the actual binary string you wanted to write: if you want to write the number 00100100 in a file, you can just write f.write('$'), which is effectively the same thing.

That is exactly what the 'struct' module performs: it generates a string of bytes, or characters, which exactly match the number you are providing them.

In my example, I give it the number 0b0010010110101, and tell it to encode it as a short integer, i.e. on two bytes. If you execute struct.pack('h', 1205) in the Python interpreter, it will print out the two characters (bytes) \xb5\x04 which correspond to this number in 'byte-base', i.e. base 256 (with big-endian convention). Indeed:

>>> 0x04 * 256 + 0xb5
1205

Just like you can represent any decimal number in base 10 (e.g. 36), base 16 (e.g. 0x24), base 2 (e.g. 0b100100), you can also represent it in base 256 via the ASCII encoding (e.g. '$'). Struct does exactly that, also providing a convenient 'fmt' string convention for the type of data you are writing. You can also do it directly by converting each of your bytes into the corresponding character:

def encode(binary):
    # Aligning on bytes
    binary = '0' * (8 - len(binary) % 8) + binary
    # Generating the corresponding character for each
    # byte encountered
    return ''.join(chr(int('0b' + binary[i:i+8], base = 2)) 
                   for i in xrange(0, len(binary), 8))

This is a very crude and not super efficient way of proceeding, but it does convert every byte into its corresponding character, and returns the corresponding string, which you can directly write into a file:

>>> encode('001001001010100100100100100111110010101110100')
'\x04\x95$\x93\xe5t'

And indeed, writing this to a file produces 6 bytes, corresponding to the 6 characters:

with open("foo.bin", 'wb') as f:
    f.write('\x04\x95$\x93\xe5t')

>>> os.path.getsize("foo.bin")
6L

struct modules performs exactly the same thing, except with a fixed format, and in a more efficient fashion. Instead of getting the chr corresponding to the integer,

def encode2(binary):
    rawbytes = []
    while binary > 0:
        binary, byte = divmod(binary, 256)
        rawbytes.append(byte)
    fmt_string = '%sB' % len(rawbytes)
    print "Encoding %s into %s bytes (%s)" % (rawbytes, len(rawbytes), fmt_string)
    return struct.pack(fmt_string, *rawbytes)

>>> encode2(0b001001001010100100100100100111110010101110100)
Encoding [116L, 229L, 147L, 36L, 149L, 4L] into 6 bytes (6B)
't\xe5\x93$\x95\x04'

(Notice that these are the same character outputted as in encode. The only difference is the order, depending on endianness of the conversion).

You can then decode these character using struct as well, and the same format string:

>>> bytes = struct.unpack('6B', 't\xe5\x93$\x95\x04')
>>> bytes
(116, 229, 147, 36, 149, 4)
>>> bin(sum(x * 256 ** i for i, x in enumerate(bytes)))
'0b1001001010100100100100100111110010101110100'

Which is our original number.

Bottom line is: Python file API can only process characters, which are effectively bytes. There might be some magic way of writing individual bits to a file, but I wouldn't count too much on that, as this introduces its own world of problems, and bytes are more than sufficient in 99% of cases. To write binary data, represent it in base 256, and convert each of its b256 digits to the corresponding character. The binary representation of this string is, by definition, your original number.