syntax - Come si esprimono letterali binari in Python?

original title: "syntax - How do you express binary literals in Python?"


How do you express an integer as a binary number with Python literals?

I was easily able to find the answer for hex:

>>> 0x12AF
>>> 0x100

and octal:

>>> 01267
>>> 0100

How do you use literals to express binary in Python?

Summary of Answers

  • Python 2.5 and earlier: can express binary using int('01010101111',2) but not with a literal.
  • Python 2.5 and earlier: there is no way to express binary literals.
  • Python 2.6 beta: You can do like so: 0b1100111 or 0B1100111.
  • Python 2.6 beta: will also allow 0o27 or 0O27 (second character is the letter O) to represent an octal.
  • Python 3.0 beta: Same as 2.6, but will no longer allow the older 027 syntax for octals.

Come si esprime un numero intero come numero binario con valori letterali Python? Sono stato facilmente in grado di trovare la risposta per hex: >>> 0x12AF 4783 >>> 0x100 256 e ottale: >>> 01267 695 >>> 0100 64 Come d ...

Questo è il riepilogo dopo la traduzione, se è necessario visualizzare la traduzione completa, fare clic sull'icona "traduci"

Tutte le risposte
  • Translate

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

    >>> 0b101111

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

    >>> bin(173)

    Development version of the documentation: What's New in Python 2.6

  • Translate
    >>> print int('01010101111',2)
    >>> print int('11111111',2)

    Another way.

  • Translate

    How do you express binary literals in Python?

    They're 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
    >>> 0B010101

    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
    3     79228162514264337593543950336     0o377    0xdeadbeef
          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)

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

    >>> int('0b0010101010', 2)

    If you pass it 0 as the base, it will assume base 10 if the string doesn't specify with a prefix:

    >>> int('10101', 0)
    >>> int('0b10101', 0)

    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)

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

    >>> bin(int('010101', 2))

    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))
    >>> format(int('010101', 2), '010b')

  • Translate

    0 in the start here specifies that the base is 8 (not 10), which is pretty easy to see:

    >>> int('010101', 0)

    If you don't start with a 0, then python assumes the number is base 10.

    >>> int('10101', 0)

  • Translate

    As far as I can tell Python, up through 2.5, only supports hexadecimal & octal literals. I did find some discussions about adding binary to future versions but nothing definite.

  • Translate

    I am pretty sure this is one of the things due to change in Python 3.0 with perhaps bin() to go with hex() and oct().

    EDIT: lbrandy's answer is correct in all cases.