Built-in method to Generate Random Strings of Fixed Length From Given Characters
Question: This is what my problem is: I need to make a random string 50 characters long,
made up of `1`s and `0`s.

I know how to solve this problem, and even have a one-liner for it. I have
also looked for various solutions to this problem on SO, only to get back what
I already know([1](http://stackoverflow.com/questions/2257441/python-random-
string-generation-with-upper-case-letters-and-digits),
[2](http://stackoverflow.com/questions/2257441/python-random-string-
generation-with-upper-case-letters-and-digits), etc). But what I really want
is **the most** Pythonic way of doing this.

Currently, I'm leaning towards `''.join(( random.choice([0,1]) for i in
xrange(50) ))`

Is there a more pythonic way of doing this? Is there a built-in that does
something like this, perhaps in `itertools`?


Answer: For Python2.7 or better:

    
    
    In [83]: import random
    
    In [84]: '{:050b}'.format(random.randrange(1<<50))
    Out[84]: '10011110110110000011111000011100101111101001001011'
    

(In Python2.6, use `'{0:050b}'` instead of `'{:050b}'`.)

* * *

**Explanation** :

The `string.format` method can convert integers into their binary string
representations. The basic format code to do this is `'{:b}'`:

    
    
    In [91]: '{:b}'.format(10)
    Out[91]: '1010'
    

To make a string of width 50, use the format code `'{:50b}'`:

    
    
    In [92]: '{:50b}'.format(10)
    Out[92]: '                                              1010'
    

and to fill in the whitespace with zeros, use `{:050b}`:

    
    
    In [93]: '{:050b}'.format(10)
    Out[93]: '00000000000000000000000000000000000000000000001010'
    

The [syntax for str.format](http://docs.python.org/library/string.html#format-
string-syntax) is a bit daunting at first. Here is my cheat sheet:

    
    
    http://docs.python.org/library/string.html#format-string-syntax
    replacement_field ::= "{" field_name ["!" conversion] [":" format_spec] "}"
    field_name        ::= (identifier|integer)("."attribute_name|"["element_index"]")* 
    attribute_name    ::= identifier
    element_index     ::= integer
    conversion        ::= "r" | "s"
    format_spec       ::= [[fill]align][sign][#][0][width][,][.precision][type]
    fill              ::= <a character other than '}'>
    align             ::= "<" | ">" | "=" | "^"
                          "=" forces the padding to be placed after the sign (if any)
                              but before the digits. (for numeric types)
                          "<" left justification
                          ">" right justification 
                          "^" center justification
    sign              ::= "+" | "-" | " "
                          "+" places a plus/minus sign for all numbers    
                          "-" places a sign only for negative numbers
                          " " places a leading space for positive numbers
    #                     for integers with type b,o,x, tells format to prefix
                          output with 0b, 0o, or 0x.
    0                     enables zero-padding. equivalent to 0= fill align.
    width             ::= integer
    ,                     tells format to use a comma for a thousands separator
    precision         ::= integer
    type              ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" |
                          "o" | "x" | "X" | "%"
        c convert integer to corresponding unicode character
        n uses a locale-aware separator
        % multiplies number by 100, display in 'f' format, with percent sign
    

