# syntax – How do you express binary literals in Python?

## syntax – How do you express binary literals in Python?

For reference—future Python possibilities:
Starting with Python 2.6 you can express binary literals using the prefix 0b or 0B:

``````>>> 0b101111
47
``````

You can also use the new bin function to get the binary representation of a number:

``````>>> bin(173)
0b10101101
``````

Development version of the documentation: Whats New in Python 2.6

``````>>> print int(01010101111,2)
687
>>> print int(11111111,2)
255
``````

Another way.

# How do you express binary literals in Python?

Theyre not binary literals, but rather, integer literals. You can express integer literals with a binary format with a `0` followed by a `B` or `b` followed by a series of zeros and ones, for example:

``````>>> 0b0010101010
170
>>> 0B010101
21
``````

From the Python 3 docs, these are the ways of providing integer literals in Python:

Integer literals are described by the following lexical definitions:

``````integer      ::=  decinteger | bininteger | octinteger | hexinteger
decinteger   ::=  nonzerodigit ([_] digit)* | 0+ ([_] 0)*
bininteger   ::=  0 (b | B) ([_] bindigit)+
octinteger   ::=  0 (o | O) ([_] octdigit)+
hexinteger   ::=  0 (x | X) ([_] hexdigit)+
nonzerodigit ::=  1...9
digit        ::=  0...9
bindigit     ::=  0 | 1
octdigit     ::=  0...7
hexdigit     ::=  digit | a...f | A...F
``````

There is no limit for the length of integer literals apart from what
can be stored in available memory.

Note that leading zeros in a non-zero decimal number are not allowed.
This is for disambiguation with C-style octal literals, which Python
used before version 3.0.

Some examples of integer literals:

``````7     2147483647                        0o177    0b100110111
100_000_000_000                   0b_1110_0101
``````

Changed in version 3.6: Underscores are now allowed for grouping purposes in literals.

## Other ways of expressing binary:

You can have the zeros and ones in a string object which can be manipulated (although you should probably just do bitwise operations on the integer in most cases) – just pass int the string of zeros and ones and the base you are converting from (2):

``````>>> int(010101, 2)
21
``````

You can optionally have the `0b` or `0B` prefix:

``````>>> int(0b0010101010, 2)
170
``````

If you pass it `0` as the base, it will assume base 10 if the string doesnt specify with a prefix:

``````>>> int(10101, 0)
10101
>>> int(0b10101, 0)
21
``````

## Converting from int back to human readable binary:

You can pass an integer to bin to see the string representation of a binary literal:

``````>>> bin(21)
0b10101
``````

And you can combine `bin` and `int` to go back and forth:

``````>>> bin(int(010101, 2))
0b10101
``````

You can use a format specification as well, if you want to have minimum width with preceding zeros:

``````>>> format(int(010101, 2), {fill}{width}b.format(width=10, fill=0))
0000010101
>>> format(int(010101, 2), 010b)
0000010101
``````