{"id":914,"date":"2021-06-29T09:50:18","date_gmt":"2021-06-29T13:50:18","guid":{"rendered":"https:\/\/www.alpharithms.com\/?p=914"},"modified":"2022-06-16T15:23:54","modified_gmt":"2022-06-16T19:23:54","slug":"python-bin-built-in-function","status":"publish","type":"post","link":"https:\/\/www.alpharithms.com\/python-bin-built-in-function-185009\/","title":{"rendered":"Python bin(): Binary Values Handled with Ease"},"content":{"rendered":"

The Python bin() method converts an integer value to a string representation of its binary representation. Python’s bin() method can also be used to return the binary representation of any object that has implemented a valid __index__ method.<\/p>\n

The Python bin()<\/code> built-in function is a useful tool in translating between languages, domains, and understanding the fundamentals of how low-level data is represented. In this article, you will learn the basic usage of the bin()<\/code> function, some advanced uses, and ways in which one might break things using it.<\/p>\n

TL;DR<\/strong> – The Python bin()<\/code> function returns a string representation of an integer’s binary value.<\/p>\n

# Define a number\r\n>>> number = 42\r\n42\r\n\r\n# Use bin to get binary value\r\n>>> bin(number)\r\n0b101010\r\n\r\n# Check the type\r\n>>> type(bin(number))\r\n<class 'str'>\r\n\r\n# Only works for integers\r\n>>> bin(42.0)\r\nTypeError: 'float' object cannot be interpreted as an integer<\/pre>\n
Basic Use<\/h2>\n
The Python bin()<\/code> function can be used for a range of applications where binary values are of interest. The simplest use-case is to return the binary value of an integer value\u2014the only valid numerical representation for which the bin()<\/code> function will accept. Let’s see that in action:<\/p>\n
# Define a number\r\nnumber = 42\r\n\r\n# Get its binary value via bin()\r\nbin_value = bin(42)\r\n\r\n# Display the value, check the type\r\nprint(bin_value)\r\nprint(type(bin_value))\r\n\r\n# Output\r\n0b101010\r\n<class 'str'>\r\n\r\n<\/pre>\n
A few things to note here:<\/p>\n
    \n
  1. The return value is a str<\/code> object<\/li>\n
  2. The return value is prefixed with 0b<\/li>\n
  3. Six 1's<\/code> and 0's<\/code> are used to represent values, the absolute minimum required.<\/li>\n<\/ol>\n
    Python’s bin() function will show you the binary representation of a number but there isn’t a lot you can do with that information explicitly. For example, let’s try to convert a binary string to a hexadecimal value:<\/p>\n
    # Convert to hexadecimal\r\nhex_value = hex(bin_value)\r\n\r\n# Result\r\nTypeError: 'str' object cannot be interpreted as an integer<\/pre>\n
    Yikes. So that isn’t\u00a0great<\/em> news but it\u00a0is<\/em> expected behavior given the implementation of the hex() function. Consider how the official Python documentation<\/a> describes its use:<\/p>\n
    Convert an integer number to a lowercase hexadecimal string prefixed with \u201c0x\u201d.\u00a0<\/em><\/p>\n
    If our true goal was to get the hexadecimal value of 42 this would be a silly example\u2014we’d just skip the bin(<\/code>) function altogether as such: hex(42)<\/code>. But we’re learning here, so let’s ignore that hiccup and see some more ridiculous examples.<\/p>\n
    Check out the article on how to convert hexadecimal values to binary in Python<\/a> for more examples of how the bin()<\/code> and hex()<\/code> functions work in concert (also how they break things sometimes!)<\/p>\n
    Using Bin on Non-Integer Objects<\/h2>\n
    Recall that Python represents all data an object<\/a>. This is essential to understand how the Python bin()<\/code> function will interact with other objects.\u00a0 Some language features like operators and conditionals are special cases but, for everything else, Python models them as objects with a slew of attributes and methods available. For example, let’s check under the hood of our\u00a0humble<\/em> value 42 using the dir()<\/code> method:<\/p>\n
    # Get a list of valid attributes for our int 'object'\r\n>>> dir(42)\r\n\r\n['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']\r\n<\/pre>\n
    Wow. There’s a\u00a0lot\u00a0<\/em>going on here. Don’t worry I’m not going to try and unpack all that. Just know; everything<\/em> in Python has a big long list of associated attributes and usually methods as well.<\/p>\n
    For now, the only attribute we’ll focus on is the __index__<\/code> attribute. This language feature was made available via PEP357<\/a> circa Python version 2.5 (early 2006) and is described as follows:<\/p>\n
    This PEP proposes adding … an __index__ special method so that arbitrary objects can be used whenever integers are explicitly needed in Python …<\/em><\/p>\n
    In other words, we can make any custom object work with the bin()<\/code> function by implementing a custom __index__<\/code> method. Consider the following:<\/p>\n
    class CustomHex:\r\n    \"\"\"A custom hexadecimal representation of an integer\"\"\"\r\n    def __init__(self, num: int):\r\n        self.value = hex(num)\r\n\r\n\r\n# Define an integer value\r\nnum = 42\r\n\r\n# Show as built-in hex\r\nprint(hex(42))\r\n\r\n>>> 0x2a\r\n\r\n# Create custom hex object\r\nbetter_hex = CustomHex(num)\r\n\r\n# See hex value\r\nprint(better_hex.value)\r\n\r\n>>> 0x2a\r\n\r\n# Get binary value\r\nprint(bin(better_hex))\r\n\r\n>>> TypeError: 'CustomHex' object cannot be interpreted as an integer\r\n<\/pre>\n
    Here I’ve created a custom CustomHex<\/code> class that converts an integer’s value and stores it internally as a hexadecimal string referenced by the object’s self.value<\/code> attribute. When this object is passed to the bin()<\/code> method it results in an TypeError<\/code>.<\/p>\n
    This error results because our object doesn’t let Python know how it should\u00a0<\/em>be represented as an integer. Let’s see what happens when we implement a custom __index__<\/code> method as the documentation suggests:<\/p>\n
    class CustomHex:\r\n    \"\"\"A custom hexadecimal representation of an integer\"\"\"\r\n    def __init__(self, num: int):\r\n        self.value = hex(num)\r\n\r\n    def __index__(self):\r\n        \"\"\"Custom method to define the integer representation\"\"\"\r\n        return int(self.value, 16)\r\n\r\n\r\n# Instantiate a new CustomHex object\r\nbetter_hex = CustomHex(42)\r\n\r\n# Get binary value\r\nprint(bin(better_hex))\r\n\r\n>>> 0b101010<\/pre>\n
    That’s a bingo! This example illustrates, albeit in another contrived imagining, how the bin()<\/code> function can be coupled with the __index__<\/code> attribute to represent just about anything as a binary string in Python. Is this a common case? Not in my experience.<\/p>\n
    Common Cases<\/h2>\n
    Python’s bin()<\/code> function serves its purpose well. There are a number of common case uses in which this method is used. Whether you want to convert an int to a binary string, a string to binary, or a binary string to an int\u2014the Python bin()<\/code> built-in function can help. In some cases, it may require the use of other built-ins such as the hex()<\/code> function to translate between values. Let’s take bin()<\/code> out for a spin()<\/strong>.<\/p>\n
    Convert an Int to Binary<\/h3>\n
    Integers are the classic use case for Python’s bin() function. They can be used directly to extract a binary representation as such:<\/p>\n
    # Get the binary value of an integer\r\n>>> bin(42)\r\n\r\n0b101010\r\n<\/pre>\n
    This returns a str<\/code> object using as few 1’s and 0’s as possible. Note the prefix of 0b. There is no built-in way to remove that notation but, using string indexing, it can be done easy enough:<\/p>\n
    >>> bin(42)[2:]\r\n\r\n101010<\/pre>\n
    Easy enough. Let’s consider how one might return the binary representation of a string.<\/p>\n
    String to Binary<\/h3>\n
    Keep in mind that everything in non-quantum computing boils down to 1’s and 0’s. Strings are no exception. The amount of 1’s and 0’s required to represent text quickly becomes impractical but can still be seen easily enough using Python’s bin()<\/code> function. For this, we’ll have to use Python’s ord() function<\/a> to get an integer value of each character in a string.<\/p>\n
    >>> \"-\".join(bin(ord(c))[2:] for c in 'overcoded')\r\n\r\n1101111-1110110-1100101-1110010-1100011-1101111-1100100-1100101-1100100<\/pre>\n
    (Uh oh, a\u00a0one-liner<\/em>.) Here I’ve created a binary string for the word overcoded<\/code> with each character’s binary value separated by a single dash for visual clarity and dropped the leading 0b<\/code> as well. The hoop-jumping of using the ord() function is, again, to satisfy Python’s bin() function’s need for an integer value.<\/p>\n
    Binary to Int<\/h3>\n
    Python’s bin()<\/code> function demands an integer value but can a binary value be easily converted into an integer? Let’s consider the binary string of the integer value 42<\/code> given to us by Python’s bin()<\/code> function:<\/p>\n
    val = bin(42)\r\nprint(val, type(val))\r\n\r\n>>> 0b101010 <class 'str'>\r\n\r\nint(val)\r\n\r\n>>> ValueError: invalid literal for int() with base 10: '0b101010'\r\n<\/pre>\n
    It would seem that Python’s bin()<\/code> function is good at giving orders regarding integer values but not so good at taking<\/em> orders. Let’s see if we can come up with a work-around.<\/p>\n
    # Get the binary value of a number\r\nbin_value = bin(42)\r\nprint(bin_value, type(bin_value))\r\n\r\n0b101010 <class 'str'>\r\n\r\n# Get Integer Value from Binary\r\nint_value = int(bin_value, 2)\r\nprint(int_value, type(int_value))\r\n\r\n42 <class 'int'>\r\n\r\n# Convert int back to binary\r\nbin_again = bin(int_value)\r\nprint(bin_again, type(bin_again))\r\n\r\n0b101010 <class 'str'>\r\n\r\n# Compare\r\nprint(bin_value == bin_again)\r\n\r\nTrue<\/pre>\n
    This circuitous sequence of events demonstrates the process of converting a binary value to an integer value in python and back again. I don’t know why one might want to do this but it does illustrate the underpinnings and interplay of Python’s bin and int features well.<\/p>\n
    Note<\/strong>: In using the int type to cast our binary string to an integer I used a second argument with the value 2<\/code>. This instructs Python’s int that the first argument is a numerical representation in base 2 notation. If we’d been converting from hexadecimal a value of 16 would have been used. We have a useful article on\u00a0how computers represent numbers<\/a> if you want to learn more on that subject.<\/p>\n
    Convert Binary to String<\/h3>\n
    Python’s bin()<\/code> function can be used to convert a binary value, represented as a string of 1’s and 0’s or an integer value, to a string of characters. This involves some consideration for encoding, but I’m going to side-step most of that here. We’ll be assuming that ASCII characters<\/a> are intended.<\/p>\n
    # Convert a binary value to a string\r\n>>> str(1111010), type(str(1111010))\r\n\r\n1111010, <class 'str'>\r\n<\/pre>\n
    Well, that isn’t very useful. The issue here is that 1111010<\/code> looks<\/em> like a binary value but, in fact, is an integer<\/em> value. These values aren’t the same under the hood and we need to offer Python some clarification regarding our intent. Namely, we need to explicitly express that our integer value is to be interpreted as the binary notation for an ASCII-format character.<\/p>\n
    # Define a character\r\nchar = 'z'\r\nprint(char, type(char))\r\n\r\n>>> z <class 'str'>\r\n\r\n# Get the binary value\r\nchar_bin = bin(ord(char))\r\nprint(char_bin, type(char_bin))\r\n\r\n>>> 0b1111010 <class 'str'>\r\n\r\n# Convert binary repr to\r\n# explict integer value\r\nexp_int = int(char_bin[2:])\r\nprint(exp_int, type(exp_int))\r\n\r\n>>> 1111010 <class 'int'>\r\n\r\n# Interpret an integer representation\r\n# of a binary value as actual binary\r\ninteger_value = int(str(exp_int), 2)\r\nprint(integer_value, type(integer_value))\r\n\r\n>>> 122 <class 'int'>\r\n\r\n# Convert our actual integer to an\r\n# ASCII character\r\nchar_again = chr(integer_value)\r\nprint(char_again, type(char_again))\r\n\r\n>>> z <class 'str'>\r\n\r\n# Compare against initial value\r\nprint(char == char_again)\r\n\r\n>>> True<\/pre>\n
    I’ll be honest\u2014that was a bit of a headache. The issue comes from trying to represent a binary value as that integer value explicitly. The binary value 1111010<\/code> does not equal the integer value of 1111010<\/code>. Rather, the binary value 1111010<\/code> represents the integer value 122<\/code>. Keep in mind, that’s because our initial binary value is in Base 2 notation. You can’t just\u00a0magically<\/em> represent a base 2 number as a base 10 value without undergoing some conversion process\u2014at least not without corrupting data.<\/p>\n
    This example isn’t by any means reflective of any common case that I’ve come across. The most applicable use I can imagine would be for a script that accepted binary data as input and needed to convert it into a different notation. That’s a common enough requirement but I don’t often see engineers jumping into Python to accomplish such a feat.<\/p>\n
    Review<\/h2>\n
    Python’s bin()<\/code> function is a simple enough function but, as with many of the simple ones, there is more to the story. The cases of feeding bin()<\/code> erroneously representative numbers (non-converted integer values for example) or objects without __index__<\/code> attributes implemented can wreak havoc and result in TypeErrors<\/code> that aren’t always clear.<\/p>\n
    The utility bin()<\/code> provides is incredibly useful as an introspective and learning tool. I’ve used it countless times to debug data from other projects (here’s looking at you, MIPS<\/em><\/a>) and to automate the decoding of network transmission data<\/a>. It’s not something that most applications need for real-time use but still, one of the many features that make Python one of the most versatile programming languages<\/a> available today.<\/p>\n","protected":false},"excerpt":{"rendered":"
    The Python bin() method converts an integer value to a string representation of its binary representation. Python’s bin() method can also be used to return the binary representation of any object that has implemented a valid __index__ method. The Python bin() built-in function is a useful tool in translating between languages, domains, and understanding the […]<\/p>\n","protected":false},"author":2,"featured_media":916,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[655,10],"tags":[377,240,271,29,33,334,143],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/914"}],"collection":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/comments?post=914"}],"version-history":[{"count":1,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/914\/revisions"}],"predecessor-version":[{"id":917,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/914\/revisions\/917"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/916"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=914"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=914"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=914"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}